JasonWoof Got questions, comments, patches, etc.? Contact Jason Woofenden
Update bar more often and remove ./ from baraction.sh
[spectrwm.git] / linux / linux.c
1 /* $scrotwm$ */
2
3 #include <sys/types.h>
4 #include <sys/cdefs.h>
5
6 #include <errno.h>
7 #include <errno.h>
8 #include <limits.h>
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12
13 #include "util.h"
14
15 /*
16  * All the workarounds for glibc stupidity are piled into this file...
17  */
18
19 /* --------------------------------------------------------------------------- */
20 /*      $OpenBSD: strlcpy.c,v 1.10 2005/08/08 08:05:37 espie Exp $      */
21
22 /*
23  * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
24  *
25  * Permission to use, copy, modify, and distribute this software for any
26  * purpose with or without fee is hereby granted, provided that the above
27  * copyright notice and this permission notice appear in all copies.
28  *
29  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
30  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
31  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
32  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
33  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
34  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
35  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
36  */
37
38 /*
39  * Copy src to string dst of size siz.  At most siz-1 characters
40  * will be copied.  Always NUL terminates (unless siz == 0).
41  * Returns strlen(src); if retval >= siz, truncation occurred.
42  */
43 size_t
44 strlcpy(char *dst, const char *src, size_t siz)
45 {
46         char *d = dst;
47         const char *s = src;
48         size_t n = siz;
49
50         /* Copy as many bytes as will fit */
51         if (n != 0 && --n != 0) {
52                 do {
53                         if ((*d++ = *s++) == 0)
54                                 break;
55                 } while (--n != 0);
56         }
57
58         /* Not enough room in dst, add NUL and traverse rest of src */
59         if (n == 0) {
60                 if (siz != 0)
61                         *d = '\0';              /* NUL-terminate dst */
62                 while (*s++)
63                         ;
64         }
65
66         return(s - src - 1);    /* count does not include NUL */
67 }
68
69 /* --------------------------------------------------------------------------- */
70 /*      $OpenBSD: strlcat.c,v 1.13 2005/08/08 08:05:37 espie Exp $      */
71
72 /*
73  * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
74  *
75  * Permission to use, copy, modify, and distribute this software for any
76  * purpose with or without fee is hereby granted, provided that the above
77  * copyright notice and this permission notice appear in all copies.
78  *
79  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
80  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
81  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
82  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
83  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
84  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
85  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
86  */
87
88 /*
89  * Appends src to string dst of size siz (unlike strncat, siz is the
90  * full size of dst, not space left).  At most siz-1 characters
91  * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
92  * Returns strlen(src) + MIN(siz, strlen(initial dst)).
93  * If retval >= siz, truncation occurred.
94  */
95 size_t
96 strlcat(char *dst, const char *src, size_t siz)
97 {
98         char *d = dst;
99         const char *s = src;
100         size_t n = siz;
101         size_t dlen;
102
103         /* Find the end of dst and adjust bytes left but don't go past end */
104         while (n-- != 0 && *d != '\0')
105                 d++;
106         dlen = d - dst;
107         n = siz - dlen;
108
109         if (n == 0)
110                 return(dlen + strlen(s));
111         while (*s != '\0') {
112                 if (n != 1) {
113                         *d++ = *s;
114                         n--;
115                 }
116                 s++;
117         }
118         *d = '\0';
119
120         return(dlen + (s - src));       /* count does not include NUL */
121 }
122
123 /* --------------------------------------------------------------------------- */
124 /*      $NetBSD: fgetln.c,v 1.3 2007/08/07 02:06:58 lukem Exp $ */
125
126 /*-
127  * Copyright (c) 1998 The NetBSD Foundation, Inc.
128  * All rights reserved.
129  *
130  * This code is derived from software contributed to The NetBSD Foundation
131  * by Christos Zoulas.
132  *
133  * Redistribution and use in source and binary forms, with or without
134  * modification, are permitted provided that the following conditions
135  * are met:
136  * 1. Redistributions of source code must retain the above copyright
137  *    notice, this list of conditions and the following disclaimer.
138  * 2. Redistributions in binary form must reproduce the above copyright
139  *    notice, this list of conditions and the following disclaimer in the
140  *    documentation and/or other materials provided with the distribution.
141  * 3. Neither the name of The NetBSD Foundation nor the names of its
142  *    contributors may be used to endorse or promote products derived
143  *    from this software without specific prior written permission.
144  *
145  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
146  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
147  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
148  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
149  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
150  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
151  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
152  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
153  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
154  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
155  * POSSIBILITY OF SUCH DAMAGE.
156  */
157
158 char *
159 fgetln(fp, len)
160         FILE *fp;
161         size_t *len;
162 {
163         static char *buf = NULL;
164         static size_t bufsiz = 0;
165         char *ptr;
166
167
168         if (buf == NULL) {
169                 bufsiz = BUFSIZ;
170                 if ((buf = malloc(bufsiz)) == NULL)
171                         return NULL;
172         }
173
174         if (fgets(buf, bufsiz, fp) == NULL)
175                 return NULL;
176
177         *len = 0;
178         while ((ptr = strchr(&buf[*len], '\n')) == NULL) {
179                 size_t nbufsiz = bufsiz + BUFSIZ;
180                 char *nbuf = realloc(buf, nbufsiz);
181
182                 if (nbuf == NULL) {
183                         int oerrno = errno;
184                         free(buf);
185                         errno = oerrno;
186                         buf = NULL;
187                         return NULL;
188                 } else
189                         buf = nbuf;
190
191                 *len = bufsiz;
192                 if (fgets(&buf[bufsiz], BUFSIZ, fp) == NULL)
193                         return buf;
194
195                 bufsiz = nbufsiz;
196         }
197
198         *len = (ptr - buf) + 1;
199         return buf;
200 }
201
202 /* --------------------------------------------------------------------------- */
203 /*      $OpenBSD: fparseln.c,v 1.6 2005/08/02 21:46:23 espie Exp $      */
204 /*      $NetBSD: fparseln.c,v 1.7 1999/07/02 15:49:12 simonb Exp $      */
205
206 /*
207  * Copyright (c) 1997 Christos Zoulas.  All rights reserved.
208  *
209  * Redistribution and use in source and binary forms, with or without
210  * modification, are permitted provided that the following conditions
211  * are met:
212  * 1. Redistributions of source code must retain the above copyright
213  *    notice, this list of conditions and the following disclaimer.
214  * 2. Redistributions in binary form must reproduce the above copyright
215  *    notice, this list of conditions and the following disclaimer in the
216  *    documentation and/or other materials provided with the distribution.
217  * 3. All advertising materials mentioning features or use of this software
218  *    must display the following acknowledgement:
219  *      This product includes software developed by Christos Zoulas.
220  * 4. The name of the author may not be used to endorse or promote products
221  *    derived from this software without specific prior written permission.
222  *
223  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
224  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
225  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
226  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
227  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
228  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
229  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
230  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
231  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
232  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
233  */
234
235 #define FPARSELN_UNESCESC       0x01
236 #define FPARSELN_UNESCCONT      0x02
237 #define FPARSELN_UNESCCOMM      0x04
238 #define FPARSELN_UNESCREST      0x08
239 #define FPARSELN_UNESCALL       0x0f
240
241 static int isescaped(const char *, const char *, int);
242
243 /* isescaped():
244  *      Return true if the character in *p that belongs to a string
245  *      that starts in *sp, is escaped by the escape character esc.
246  */
247 static int
248 isescaped(const char *sp, const char *p, int esc)
249 {
250         const char     *cp;
251         size_t          ne;
252
253         /* No escape character */
254         if (esc == '\0')
255                 return 1;
256
257         /* Count the number of escape characters that precede ours */
258         for (ne = 0, cp = p; --cp >= sp && *cp == esc; ne++)
259                 continue;
260
261         /* Return true if odd number of escape characters */
262         return (ne & 1) != 0;
263 }
264
265
266 /* fparseln():
267  *      Read a line from a file parsing continuations ending in \
268  *      and eliminating trailing newlines, or comments starting with
269  *      the comment char.
270  */
271 char *
272 fparseln(FILE *fp, size_t *size, size_t *lineno, const char str[3],
273     int flags)
274 {
275         static const char dstr[3] = { '\\', '\\', '#' };
276         char    *buf = NULL, *ptr, *cp, esc, con, nl, com;
277         size_t  s, len = 0;
278         int     cnt = 1;
279
280         if (str == NULL)
281                 str = dstr;
282
283         esc = str[0];
284         con = str[1];
285         com = str[2];
286
287         /*
288          * XXX: it would be cool to be able to specify the newline character,
289          * but unfortunately, fgetln does not let us
290          */
291         nl  = '\n';
292
293         while (cnt) {
294                 cnt = 0;
295
296                 if (lineno)
297                         (*lineno)++;
298
299                 if ((ptr = fgetln(fp, &s)) == NULL)
300                         break;
301
302                 if (s && com) {         /* Check and eliminate comments */
303                         for (cp = ptr; cp < ptr + s; cp++)
304                                 if (*cp == com && !isescaped(ptr, cp, esc)) {
305                                         s = cp - ptr;
306                                         cnt = s == 0 && buf == NULL;
307                                         break;
308                                 }
309                 }
310
311                 if (s && nl) {          /* Check and eliminate newlines */
312                         cp = &ptr[s - 1];
313
314                         if (*cp == nl)
315                                 s--;    /* forget newline */
316                 }
317
318                 if (s && con) {         /* Check and eliminate continuations */
319                         cp = &ptr[s - 1];
320
321                         if (*cp == con && !isescaped(ptr, cp, esc)) {
322                                 s--;    /* forget escape */
323                                 cnt = 1;
324                         }
325                 }
326
327                 if (s == 0 && buf != NULL)
328                         continue;
329
330                 if ((cp = realloc(buf, len + s + 1)) == NULL) {
331                         free(buf);
332                         return NULL;
333                 }
334                 buf = cp;
335
336                 (void) memcpy(buf + len, ptr, s);
337                 len += s;
338                 buf[len] = '\0';
339         }
340
341         if ((flags & FPARSELN_UNESCALL) != 0 && esc && buf != NULL &&
342             strchr(buf, esc) != NULL) {
343                 ptr = cp = buf;
344                 while (cp[0] != '\0') {
345                         int skipesc;
346
347                         while (cp[0] != '\0' && cp[0] != esc)
348                                 *ptr++ = *cp++;
349                         if (cp[0] == '\0' || cp[1] == '\0')
350                                 break;
351
352                         skipesc = 0;
353                         if (cp[1] == com)
354                                 skipesc += (flags & FPARSELN_UNESCCOMM);
355                         if (cp[1] == con)
356                                 skipesc += (flags & FPARSELN_UNESCCONT);
357                         if (cp[1] == esc)
358                                 skipesc += (flags & FPARSELN_UNESCESC);
359                         if (cp[1] != com && cp[1] != con && cp[1] != esc)
360                                 skipesc = (flags & FPARSELN_UNESCREST);
361
362                         if (skipesc)
363                                 cp++;
364                         else
365                                 *ptr++ = *cp++;
366                         *ptr++ = *cp++;
367                 }
368                 *ptr = '\0';
369                 len = strlen(buf);
370         }
371
372         if (size)
373                 *size = len;
374         return buf;
375 }
376
377 /* --------------------------------------------------------------------------- */
378 /*      $OpenBSD: strtonum.c,v 1.6 2004/08/03 19:38:01 millert Exp $    */
379
380 /*
381  * Copyright (c) 2004 Ted Unangst and Todd Miller
382  * All rights reserved.
383  *
384  * Permission to use, copy, modify, and distribute this software for any
385  * purpose with or without fee is hereby granted, provided that the above
386  * copyright notice and this permission notice appear in all copies.
387  *
388  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
389  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
390  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
391  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
392  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
393  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
394  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
395  */
396
397 #define INVALID         1
398 #define TOOSMALL        2
399 #define TOOLARGE        3
400
401 long long
402 strtonum(const char *numstr, long long minval, long long maxval,
403     const char **errstrp)
404 {
405         long long ll = 0;
406         char *ep;
407         int error = 0;
408         struct errval {
409                 const char *errstr;
410                 int err;
411         } ev[4] = {
412                 { NULL,         0 },
413                 { "invalid",    EINVAL },
414                 { "too small",  ERANGE },
415                 { "too large",  ERANGE },
416         };
417
418         ev[0].err = errno;
419         errno = 0;
420         if (minval > maxval)
421                 error = INVALID;
422         else {
423                 ll = strtoll(numstr, &ep, 10);
424                 if (numstr == ep || *ep != '\0')
425                         error = INVALID;
426                 else if ((ll == LLONG_MIN && errno == ERANGE) || ll < minval)
427                         error = TOOSMALL;
428                 else if ((ll == LLONG_MAX && errno == ERANGE) || ll > maxval)
429                         error = TOOLARGE;
430         }
431         if (errstrp != NULL)
432                 *errstrp = ev[error].errstr;
433         errno = ev[error].err;
434         if (error)
435                 ll = 0;
436
437         return (ll);
438 }