also add -fwrapv to CFLAGS (addresses #698908)
[alioth/cvs.git] / lib / sunos57-select.c
1 /* Work around the bug in Solaris 7 whereby a fd that is opened on
2    /dev/null will cause select/poll to hang when given a NULL timeout.
3
4    Copyright (C) 2004 Free Software Foundation, Inc.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2, or (at your option)
9    any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software Foundation,
18    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
19
20 /* written by Mark D. Baushke */
21
22 /*
23  * Observed on Solaris 7:
24  *   If /dev/null is in the readfds set, it will never be marked as
25  *   ready by the OS. In the case of a /dev/null fd being the only fd
26  *   in the select set and timeout == NULL, the select will hang.
27  *   If /dev/null is in the exceptfds set, it will not be set on
28  *   return from select().
29  */
30 #ifdef HAVE_CONFIG_H
31 # include <config.h>
32 #endif /* HAVE_CONFIG_H */
33
34 /* The rpl_select function calls the real select. */
35 #undef select
36
37 #include <stdbool.h>
38 #include <stdio.h>
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <errno.h>
42
43 #if defined(STDC_HEADERS) || defined(HAVE_STRING_H)
44 # include <string.h>
45 #else
46 # include <strings.h>
47 #endif
48 #ifdef HAVE_UNISTD_H
49 # include <unistd.h>
50 #endif /* HAVE_UNISTD_H */
51
52 #include "minmax.h"
53 #include "xtime.h"
54
55 static struct stat devnull;
56 static int devnull_set = -1;
57 int
58 rpl_select (int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
59             struct timeval *timeout)
60 {
61   int ret = 0;
62
63   /* Argument checking */
64   if (nfds < 1 || nfds > FD_SETSIZE)
65     {
66       errno = EINVAL;
67       return -1;
68     }
69
70   /* Perform the initial stat on /dev/null */
71   if (devnull_set == -1)
72     devnull_set = stat ("/dev/null", &devnull);
73
74   if (devnull_set >= 0)
75     {
76       int fd;
77       int maxfd = -1;
78       fd_set null_rfds, null_wfds;
79       bool altered = false;     /* Whether we have altered the caller's args.
80                                  */
81
82       FD_ZERO (&null_rfds);
83       FD_ZERO (&null_wfds);
84
85       for (fd = 0; fd < nfds; fd++)
86         {
87           /* Check the callers bits for interesting fds */
88           bool isread = (readfds && FD_ISSET (fd, readfds));
89           bool isexcept = (exceptfds && FD_ISSET (fd, exceptfds));
90           bool iswrite = (writefds && FD_ISSET (fd, writefds));
91
92           /* Check interesting fds against /dev/null */
93           if (isread || iswrite || isexcept)
94             {
95               struct stat sb;
96
97               /* Equivalent to /dev/null ? */
98               if (fstat (fd, &sb) >= 0
99                   && sb.st_dev == devnull.st_dev
100                   && sb.st_ino == devnull.st_ino
101                   && sb.st_mode == devnull.st_mode
102                   && sb.st_uid == devnull.st_uid
103                   && sb.st_gid == devnull.st_gid
104                   && sb.st_size == devnull.st_size
105                   && sb.st_blocks == devnull.st_blocks
106                   && sb.st_blksize == devnull.st_blksize)
107                 {
108                   /* Save the interesting bits for later use. */
109                   if (isread)
110                     {
111                       FD_SET (fd, &null_rfds);
112                       FD_CLR (fd, readfds);
113                       altered = true;
114                     }
115                   if (isexcept)
116                     /* Pass exception bits through.
117                      *
118                      * At the moment, we only know that this bug
119                      * exists in Solaris 7 and so this file should
120                      * only be compiled on Solaris 7. Since Solaris 7
121                      * never returns ready for exceptions on
122                      * /dev/null, we probably could assume this too,
123                      * but since Solaris 9 is known to always return
124                      * ready for exceptions on /dev/null, pass this
125                      * through in case any other systems turn out to
126                      * do the same. Besides, this will cause the
127                      * timeout to be processed as it would have been
128                      * otherwise.
129                      */
130                     maxfd = MAX (maxfd, fd);
131                   if (iswrite)
132                     {
133                       /* We know of no bugs involving selecting /dev/null
134                        * writefds, but we also know that /dev/null is always
135                        * ready for write.  Therefore, since we have already
136                        * performed all the necessary processing, avoid calling
137                        * the system select for this case.
138                        */
139                       FD_SET (fd, &null_wfds);
140                       FD_CLR (fd, writefds);
141                       altered = true;
142                     }
143                 }
144               else
145                 /* A non-/dev/null fd is present. */
146                 maxfd = MAX (maxfd, fd);
147             }
148         }
149
150       if (maxfd >= 0)
151         {
152           /* we need to call select, one way or another.  */
153           if (altered)
154             {
155               /* We already have some ready bits set, so timeout immediately
156                * if no bits are set.
157                */
158               struct timeval ztime;
159               ztime.tv_sec = 0;
160               ztime.tv_usec = 0;
161               ret = select (maxfd + 1, readfds, writefds, exceptfds, &ztime);
162               if (ret == 0)
163                 {
164                   /* Timeout.  Zero the sets since the system select might
165                    * not have.
166                    */
167                   if (readfds)
168                     FD_ZERO (readfds);
169                   if (exceptfds)
170                     FD_ZERO (exceptfds);
171                   if (writefds)
172                     FD_ZERO (writefds);
173                 }
174             }
175           else
176             /* No /dev/null fds.  Call select just as the user specified.  */
177             ret = select (maxfd + 1, readfds, writefds, exceptfds, timeout);
178         }
179
180       /*
181        * Borrowed from the Solaris 7 man page for select(3c):
182        * 
183        *   On successful completion, the objects pointed to by the
184        *   readfds, writefds, and exceptfds arguments are modified to
185        *   indicate which file descriptors are ready for reading,
186        *   ready for writing, or have an error condition pending,
187        *   respectively. For each file descriptor less than nfds, the
188        *   corresponding bit will be set on successful completion if
189        *   it was set on input and the associated condition is true
190        *   for that file descriptor.
191        *  
192        *   On failure, the objects pointed to by the readfds,
193        *   writefds, and exceptfds arguments are not modified. If the
194        *   timeout interval expires without the specified condition
195        *   being true for any of the specified file descriptors, the
196        *   objects pointed to by the readfs, writefs, and errorfds
197        *   arguments have all bits set to 0.
198        *  
199        *   On successful completion, select() returns the total number
200        *   of bits set in the bit masks. Otherwise, -1 is returned,
201        *   and errno is set to indicate the error.
202        */
203
204       /* Fix up the fd sets for any changes we may have made. */
205       if (altered)
206         {
207           /* Tell the caller that nothing is blocking the /dev/null fds */
208           for (fd = 0; fd < nfds; fd++)
209             {
210               /* If ret < 0, then we still need to restore the fd sets.  */
211               if (FD_ISSET (fd, &null_rfds))
212                 {
213                   FD_SET (fd, readfds);
214                   if (ret >= 0)
215                     ret++;
216                 }
217               if (FD_ISSET (fd, &null_wfds))
218                 {
219                   FD_SET (fd, writefds);
220                   if (ret >= 0)
221                     ret++;
222                 }                 
223             }
224         }
225     }
226   else
227     ret = select (nfds, readfds, writefds, exceptfds, timeout);
228
229   return ret;
230 }