socket-util: closesocket() for Windows.
[sliver-openvswitch.git] / lib / util.c
1 /*
2  * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18 #include "util.h"
19 #include <ctype.h>
20 #include <errno.h>
21 #include <limits.h>
22 #include <pthread.h>
23 #include <stdarg.h>
24 #include <stdint.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <sys/stat.h>
29 #include <unistd.h>
30 #include "bitmap.h"
31 #include "byte-order.h"
32 #include "coverage.h"
33 #include "ovs-thread.h"
34 #include "vlog.h"
35 #ifdef HAVE_PTHREAD_SET_NAME_NP
36 #include <pthread_np.h>
37 #endif
38
39 VLOG_DEFINE_THIS_MODULE(util);
40
41 COVERAGE_DEFINE(util_xalloc);
42
43 /* argv[0] without directory names. */
44 const char *program_name;
45
46 /* Name for the currently running thread or process, for log messages, process
47  * listings, and debuggers. */
48 DEFINE_PER_THREAD_MALLOCED_DATA(char *, subprogram_name);
49
50 /* --version option output. */
51 static char *program_version;
52
53 /* Buffer used by ovs_strerror() and ovs_format_message(). */
54 DEFINE_STATIC_PER_THREAD_DATA(struct { char s[128]; },
55                               strerror_buffer,
56                               { "" });
57
58 static char *xreadlink(const char *filename);
59
60 void
61 ovs_assert_failure(const char *where, const char *function,
62                    const char *condition)
63 {
64     /* Prevent an infinite loop (or stack overflow) in case VLOG_ABORT happens
65      * to trigger an assertion failure of its own. */
66     static int reentry = 0;
67
68     switch (reentry++) {
69     case 0:
70         VLOG_ABORT("%s: assertion %s failed in %s()",
71                    where, condition, function);
72         OVS_NOT_REACHED();
73
74     case 1:
75         fprintf(stderr, "%s: assertion %s failed in %s()",
76                 where, condition, function);
77         abort();
78
79     default:
80         abort();
81     }
82 }
83
84 void
85 out_of_memory(void)
86 {
87     ovs_abort(0, "virtual memory exhausted");
88 }
89
90 void *
91 xcalloc(size_t count, size_t size)
92 {
93     void *p = count && size ? calloc(count, size) : malloc(1);
94     COVERAGE_INC(util_xalloc);
95     if (p == NULL) {
96         out_of_memory();
97     }
98     return p;
99 }
100
101 void *
102 xzalloc(size_t size)
103 {
104     return xcalloc(1, size);
105 }
106
107 void *
108 xmalloc(size_t size)
109 {
110     void *p = malloc(size ? size : 1);
111     COVERAGE_INC(util_xalloc);
112     if (p == NULL) {
113         out_of_memory();
114     }
115     return p;
116 }
117
118 void *
119 xrealloc(void *p, size_t size)
120 {
121     p = realloc(p, size ? size : 1);
122     COVERAGE_INC(util_xalloc);
123     if (p == NULL) {
124         out_of_memory();
125     }
126     return p;
127 }
128
129 void *
130 xmemdup(const void *p_, size_t size)
131 {
132     void *p = xmalloc(size);
133     memcpy(p, p_, size);
134     return p;
135 }
136
137 char *
138 xmemdup0(const char *p_, size_t length)
139 {
140     char *p = xmalloc(length + 1);
141     memcpy(p, p_, length);
142     p[length] = '\0';
143     return p;
144 }
145
146 char *
147 xstrdup(const char *s)
148 {
149     return xmemdup0(s, strlen(s));
150 }
151
152 char *
153 xvasprintf(const char *format, va_list args)
154 {
155     va_list args2;
156     size_t needed;
157     char *s;
158
159     va_copy(args2, args);
160     needed = vsnprintf(NULL, 0, format, args);
161
162     s = xmalloc(needed + 1);
163
164     vsnprintf(s, needed + 1, format, args2);
165     va_end(args2);
166
167     return s;
168 }
169
170 void *
171 x2nrealloc(void *p, size_t *n, size_t s)
172 {
173     *n = *n == 0 ? 1 : 2 * *n;
174     return xrealloc(p, *n * s);
175 }
176
177 char *
178 xasprintf(const char *format, ...)
179 {
180     va_list args;
181     char *s;
182
183     va_start(args, format);
184     s = xvasprintf(format, args);
185     va_end(args);
186
187     return s;
188 }
189
190 /* Similar to strlcpy() from OpenBSD, but it never reads more than 'size - 1'
191  * bytes from 'src' and doesn't return anything. */
192 void
193 ovs_strlcpy(char *dst, const char *src, size_t size)
194 {
195     if (size > 0) {
196         size_t len = strnlen(src, size - 1);
197         memcpy(dst, src, len);
198         dst[len] = '\0';
199     }
200 }
201
202 /* Copies 'src' to 'dst'.  Reads no more than 'size - 1' bytes from 'src'.
203  * Always null-terminates 'dst' (if 'size' is nonzero), and writes a zero byte
204  * to every otherwise unused byte in 'dst'.
205  *
206  * Except for performance, the following call:
207  *     ovs_strzcpy(dst, src, size);
208  * is equivalent to these two calls:
209  *     memset(dst, '\0', size);
210  *     ovs_strlcpy(dst, src, size);
211  *
212  * (Thus, ovs_strzcpy() is similar to strncpy() without some of the pitfalls.)
213  */
214 void
215 ovs_strzcpy(char *dst, const char *src, size_t size)
216 {
217     if (size > 0) {
218         size_t len = strnlen(src, size - 1);
219         memcpy(dst, src, len);
220         memset(dst + len, '\0', size - len);
221     }
222 }
223
224 /* Prints 'format' on stderr, formatting it like printf() does.  If 'err_no' is
225  * nonzero, then it is formatted with ovs_retval_to_string() and appended to
226  * the message inside parentheses.  Then, terminates with abort().
227  *
228  * This function is preferred to ovs_fatal() in a situation where it would make
229  * sense for a monitoring process to restart the daemon.
230  *
231  * 'format' should not end with a new-line, because this function will add one
232  * itself. */
233 void
234 ovs_abort(int err_no, const char *format, ...)
235 {
236     va_list args;
237
238     va_start(args, format);
239     ovs_abort_valist(err_no, format, args);
240 }
241
242 /* Same as ovs_abort() except that the arguments are supplied as a va_list. */
243 void
244 ovs_abort_valist(int err_no, const char *format, va_list args)
245 {
246     ovs_error_valist(err_no, format, args);
247     abort();
248 }
249
250 /* Prints 'format' on stderr, formatting it like printf() does.  If 'err_no' is
251  * nonzero, then it is formatted with ovs_retval_to_string() and appended to
252  * the message inside parentheses.  Then, terminates with EXIT_FAILURE.
253  *
254  * 'format' should not end with a new-line, because this function will add one
255  * itself. */
256 void
257 ovs_fatal(int err_no, const char *format, ...)
258 {
259     va_list args;
260
261     va_start(args, format);
262     ovs_fatal_valist(err_no, format, args);
263 }
264
265 /* Same as ovs_fatal() except that the arguments are supplied as a va_list. */
266 void
267 ovs_fatal_valist(int err_no, const char *format, va_list args)
268 {
269     ovs_error_valist(err_no, format, args);
270     exit(EXIT_FAILURE);
271 }
272
273 /* Prints 'format' on stderr, formatting it like printf() does.  If 'err_no' is
274  * nonzero, then it is formatted with ovs_retval_to_string() and appended to
275  * the message inside parentheses.
276  *
277  * 'format' should not end with a new-line, because this function will add one
278  * itself. */
279 void
280 ovs_error(int err_no, const char *format, ...)
281 {
282     va_list args;
283
284     va_start(args, format);
285     ovs_error_valist(err_no, format, args);
286     va_end(args);
287 }
288
289 /* Same as ovs_error() except that the arguments are supplied as a va_list. */
290 void
291 ovs_error_valist(int err_no, const char *format, va_list args)
292 {
293     const char *subprogram_name = get_subprogram_name();
294     int save_errno = errno;
295
296     if (subprogram_name[0]) {
297         fprintf(stderr, "%s(%s): ", program_name, subprogram_name);
298     } else {
299         fprintf(stderr, "%s: ", program_name);
300     }
301
302     vfprintf(stderr, format, args);
303     if (err_no != 0) {
304         fprintf(stderr, " (%s)", ovs_retval_to_string(err_no));
305     }
306     putc('\n', stderr);
307
308     errno = save_errno;
309 }
310
311 /* Many OVS functions return an int which is one of:
312  * - 0: no error yet
313  * - >0: errno value
314  * - EOF: end of file (not necessarily an error; depends on the function called)
315  *
316  * Returns the appropriate human-readable string. The caller must copy the
317  * string if it wants to hold onto it, as the storage may be overwritten on
318  * subsequent function calls.
319  */
320 const char *
321 ovs_retval_to_string(int retval)
322 {
323     return (!retval ? ""
324             : retval == EOF ? "End of file"
325             : ovs_strerror(retval));
326 }
327
328 /* This function returns the string describing the error number in 'error'
329  * for POSIX platforms.  For Windows, this function can be used for C library
330  * calls.  For socket calls that are also used in Windows, use sock_strerror()
331  * instead.  For WINAPI calls, look at ovs_lasterror_to_string(). */
332 const char *
333 ovs_strerror(int error)
334 {
335     enum { BUFSIZE = sizeof strerror_buffer_get()->s };
336     int save_errno;
337     char *buffer;
338     char *s;
339
340     save_errno = errno;
341     buffer = strerror_buffer_get()->s;
342
343 #if STRERROR_R_CHAR_P
344     /* GNU style strerror_r() might return an immutable static string, or it
345      * might write and return 'buffer', but in either case we can pass the
346      * returned string directly to the caller. */
347     s = strerror_r(error, buffer, BUFSIZE);
348 #else  /* strerror_r() returns an int. */
349     s = buffer;
350     if (strerror_r(error, buffer, BUFSIZE)) {
351         /* strerror_r() is only allowed to fail on ERANGE (because the buffer
352          * is too short).  We don't check the actual failure reason because
353          * POSIX requires strerror_r() to return the error but old glibc
354          * (before 2.13) returns -1 and sets errno. */
355         snprintf(buffer, BUFSIZE, "Unknown error %d", error);
356     }
357 #endif
358
359     errno = save_errno;
360
361     return s;
362 }
363
364 /* Sets global "program_name" and "program_version" variables.  Should
365  * be called at the beginning of main() with "argv[0]" as the argument
366  * to 'argv0'.
367  *
368  * 'version' should contain the version of the caller's program.  If 'version'
369  * is the same as the VERSION #define, the caller is assumed to be part of Open
370  * vSwitch.  Otherwise, it is assumed to be an external program linking against
371  * the Open vSwitch libraries.
372  *
373  * The 'date' and 'time' arguments should likely be called with
374  * "__DATE__" and "__TIME__" to use the time the binary was built.
375  * Alternatively, the "set_program_name" macro may be called to do this
376  * automatically.
377  */
378 void
379 set_program_name__(const char *argv0, const char *version, const char *date,
380                    const char *time)
381 {
382 #ifdef _WIN32
383     char *basename;
384     size_t max_len = strlen(argv0) + 1;
385
386     if (program_name) {
387         return;
388     }
389     basename = xmalloc(max_len);
390     _splitpath_s(argv0, NULL, 0, NULL, 0, basename, max_len, NULL, 0);
391     assert_single_threaded();
392     program_name = basename;
393 #else
394     const char *slash = strrchr(argv0, '/');
395     assert_single_threaded();
396     program_name = slash ? slash + 1 : argv0;
397 #endif
398
399     free(program_version);
400
401     if (!strcmp(version, VERSION)) {
402         program_version = xasprintf("%s (Open vSwitch) "VERSION"\n"
403                                     "Compiled %s %s\n",
404                                     program_name, date, time);
405     } else {
406         program_version = xasprintf("%s %s\n"
407                                     "Open vSwitch Library "VERSION"\n"
408                                     "Compiled %s %s\n",
409                                     program_name, version, date, time);
410     }
411 }
412
413 /* Returns the name of the currently running thread or process. */
414 const char *
415 get_subprogram_name(void)
416 {
417     const char *name = subprogram_name_get();
418     return name ? name : "";
419 }
420
421 /* Sets the formatted value of 'format' as the name of the currently running
422  * thread or process.  (This appears in log messages and may also be visible in
423  * system process listings and debuggers.) */
424 void
425 set_subprogram_name(const char *format, ...)
426 {
427     char *pname;
428
429     if (format) {
430         va_list args;
431
432         va_start(args, format);
433         pname = xvasprintf(format, args);
434         va_end(args);
435     } else {
436         pname = xstrdup(program_name);
437     }
438
439     free(subprogram_name_set(pname));
440
441 #if HAVE_GLIBC_PTHREAD_SETNAME_NP
442     pthread_setname_np(pthread_self(), pname);
443 #elif HAVE_NETBSD_PTHREAD_SETNAME_NP
444     pthread_setname_np(pthread_self(), "%s", pname);
445 #elif HAVE_PTHREAD_SET_NAME_NP
446     pthread_set_name_np(pthread_self(), pname);
447 #endif
448 }
449
450 /* Returns a pointer to a string describing the program version.  The
451  * caller must not modify or free the returned string.
452  */
453 const char *
454 get_program_version(void)
455 {
456     return program_version;
457 }
458
459 /* Print the version information for the program.  */
460 void
461 ovs_print_version(uint8_t min_ofp, uint8_t max_ofp)
462 {
463     printf("%s", program_version);
464     if (min_ofp || max_ofp) {
465         printf("OpenFlow versions %#x:%#x\n", min_ofp, max_ofp);
466     }
467 }
468
469 /* Writes the 'size' bytes in 'buf' to 'stream' as hex bytes arranged 16 per
470  * line.  Numeric offsets are also included, starting at 'ofs' for the first
471  * byte in 'buf'.  If 'ascii' is true then the corresponding ASCII characters
472  * are also rendered alongside. */
473 void
474 ovs_hex_dump(FILE *stream, const void *buf_, size_t size,
475              uintptr_t ofs, bool ascii)
476 {
477   const uint8_t *buf = buf_;
478   const size_t per_line = 16; /* Maximum bytes per line. */
479
480   while (size > 0)
481     {
482       size_t start, end, n;
483       size_t i;
484
485       /* Number of bytes on this line. */
486       start = ofs % per_line;
487       end = per_line;
488       if (end - start > size)
489         end = start + size;
490       n = end - start;
491
492       /* Print line. */
493       fprintf(stream, "%08"PRIxMAX"  ", (uintmax_t) ROUND_DOWN(ofs, per_line));
494       for (i = 0; i < start; i++)
495         fprintf(stream, "   ");
496       for (; i < end; i++)
497         fprintf(stream, "%02x%c",
498                 buf[i - start], i == per_line / 2 - 1? '-' : ' ');
499       if (ascii)
500         {
501           for (; i < per_line; i++)
502             fprintf(stream, "   ");
503           fprintf(stream, "|");
504           for (i = 0; i < start; i++)
505             fprintf(stream, " ");
506           for (; i < end; i++) {
507               int c = buf[i - start];
508               putc(c >= 32 && c < 127 ? c : '.', stream);
509           }
510           for (; i < per_line; i++)
511             fprintf(stream, " ");
512           fprintf(stream, "|");
513         }
514       fprintf(stream, "\n");
515
516       ofs += n;
517       buf += n;
518       size -= n;
519     }
520 }
521
522 bool
523 str_to_int(const char *s, int base, int *i)
524 {
525     long long ll;
526     bool ok = str_to_llong(s, base, &ll);
527     *i = ll;
528     return ok;
529 }
530
531 bool
532 str_to_long(const char *s, int base, long *li)
533 {
534     long long ll;
535     bool ok = str_to_llong(s, base, &ll);
536     *li = ll;
537     return ok;
538 }
539
540 bool
541 str_to_llong(const char *s, int base, long long *x)
542 {
543     int save_errno = errno;
544     char *tail;
545     errno = 0;
546     *x = strtoll(s, &tail, base);
547     if (errno == EINVAL || errno == ERANGE || tail == s || *tail != '\0') {
548         errno = save_errno;
549         *x = 0;
550         return false;
551     } else {
552         errno = save_errno;
553         return true;
554     }
555 }
556
557 /* Converts floating-point string 's' into a double.  If successful, stores
558  * the double in '*d' and returns true; on failure, stores 0 in '*d' and
559  * returns false.
560  *
561  * Underflow (e.g. "1e-9999") is not considered an error, but overflow
562  * (e.g. "1e9999)" is. */
563 bool
564 str_to_double(const char *s, double *d)
565 {
566     int save_errno = errno;
567     char *tail;
568     errno = 0;
569     *d = strtod(s, &tail);
570     if (errno == EINVAL || (errno == ERANGE && *d != 0)
571         || tail == s || *tail != '\0') {
572         errno = save_errno;
573         *d = 0;
574         return false;
575     } else {
576         errno = save_errno;
577         return true;
578     }
579 }
580
581 /* Returns the value of 'c' as a hexadecimal digit. */
582 int
583 hexit_value(int c)
584 {
585     switch (c) {
586     case '0': case '1': case '2': case '3': case '4':
587     case '5': case '6': case '7': case '8': case '9':
588         return c - '0';
589
590     case 'a': case 'A':
591         return 0xa;
592
593     case 'b': case 'B':
594         return 0xb;
595
596     case 'c': case 'C':
597         return 0xc;
598
599     case 'd': case 'D':
600         return 0xd;
601
602     case 'e': case 'E':
603         return 0xe;
604
605     case 'f': case 'F':
606         return 0xf;
607
608     default:
609         return -1;
610     }
611 }
612
613 /* Returns the integer value of the 'n' hexadecimal digits starting at 's', or
614  * UINT_MAX if one of those "digits" is not really a hex digit.  If 'ok' is
615  * nonnull, '*ok' is set to true if the conversion succeeds or to false if a
616  * non-hex digit is detected. */
617 unsigned int
618 hexits_value(const char *s, size_t n, bool *ok)
619 {
620     unsigned int value;
621     size_t i;
622
623     value = 0;
624     for (i = 0; i < n; i++) {
625         int hexit = hexit_value(s[i]);
626         if (hexit < 0) {
627             if (ok) {
628                 *ok = false;
629             }
630             return UINT_MAX;
631         }
632         value = (value << 4) + hexit;
633     }
634     if (ok) {
635         *ok = true;
636     }
637     return value;
638 }
639
640 /* Returns the current working directory as a malloc()'d string, or a null
641  * pointer if the current working directory cannot be determined. */
642 char *
643 get_cwd(void)
644 {
645     long int path_max;
646     size_t size;
647
648     /* Get maximum path length or at least a reasonable estimate. */
649     path_max = pathconf(".", _PC_PATH_MAX);
650     size = (path_max < 0 ? 1024
651             : path_max > 10240 ? 10240
652             : path_max);
653
654     /* Get current working directory. */
655     for (;;) {
656         char *buf = xmalloc(size);
657         if (getcwd(buf, size)) {
658             return xrealloc(buf, strlen(buf) + 1);
659         } else {
660             int error = errno;
661             free(buf);
662             if (error != ERANGE) {
663                 VLOG_WARN("getcwd failed (%s)", ovs_strerror(error));
664                 return NULL;
665             }
666             size *= 2;
667         }
668     }
669 }
670
671 static char *
672 all_slashes_name(const char *s)
673 {
674     return xstrdup(s[0] == '/' && s[1] == '/' && s[2] != '/' ? "//"
675                    : s[0] == '/' ? "/"
676                    : ".");
677 }
678
679 /* Returns the directory name portion of 'file_name' as a malloc()'d string,
680  * similar to the POSIX dirname() function but thread-safe. */
681 char *
682 dir_name(const char *file_name)
683 {
684     size_t len = strlen(file_name);
685     while (len > 0 && file_name[len - 1] == '/') {
686         len--;
687     }
688     while (len > 0 && file_name[len - 1] != '/') {
689         len--;
690     }
691     while (len > 0 && file_name[len - 1] == '/') {
692         len--;
693     }
694     return len ? xmemdup0(file_name, len) : all_slashes_name(file_name);
695 }
696
697 /* Returns the file name portion of 'file_name' as a malloc()'d string,
698  * similar to the POSIX basename() function but thread-safe. */
699 char *
700 base_name(const char *file_name)
701 {
702     size_t end, start;
703
704     end = strlen(file_name);
705     while (end > 0 && file_name[end - 1] == '/') {
706         end--;
707     }
708
709     if (!end) {
710         return all_slashes_name(file_name);
711     }
712
713     start = end;
714     while (start > 0 && file_name[start - 1] != '/') {
715         start--;
716     }
717
718     return xmemdup0(file_name + start, end - start);
719 }
720
721 /* If 'file_name' starts with '/', returns a copy of 'file_name'.  Otherwise,
722  * returns an absolute path to 'file_name' considering it relative to 'dir',
723  * which itself must be absolute.  'dir' may be null or the empty string, in
724  * which case the current working directory is used.
725  *
726  * Returns a null pointer if 'dir' is null and getcwd() fails. */
727 char *
728 abs_file_name(const char *dir, const char *file_name)
729 {
730     if (file_name[0] == '/') {
731         return xstrdup(file_name);
732     } else if (dir && dir[0]) {
733         char *separator = dir[strlen(dir) - 1] == '/' ? "" : "/";
734         return xasprintf("%s%s%s", dir, separator, file_name);
735     } else {
736         char *cwd = get_cwd();
737         if (cwd) {
738             char *abs_name = xasprintf("%s/%s", cwd, file_name);
739             free(cwd);
740             return abs_name;
741         } else {
742             return NULL;
743         }
744     }
745 }
746
747 /* Like readlink(), but returns the link name as a null-terminated string in
748  * allocated memory that the caller must eventually free (with free()).
749  * Returns NULL on error, in which case errno is set appropriately. */
750 static char *
751 xreadlink(const char *filename)
752 {
753     size_t size;
754
755     for (size = 64; ; size *= 2) {
756         char *buf = xmalloc(size);
757         ssize_t retval = readlink(filename, buf, size);
758         int error = errno;
759
760         if (retval >= 0 && retval < size) {
761             buf[retval] = '\0';
762             return buf;
763         }
764
765         free(buf);
766         if (retval < 0) {
767             errno = error;
768             return NULL;
769         }
770     }
771 }
772
773 /* Returns a version of 'filename' with symlinks in the final component
774  * dereferenced.  This differs from realpath() in that:
775  *
776  *     - 'filename' need not exist.
777  *
778  *     - If 'filename' does exist as a symlink, its referent need not exist.
779  *
780  *     - Only symlinks in the final component of 'filename' are dereferenced.
781  *
782  * For Windows platform, this function returns a string that has the same
783  * value as the passed string.
784  *
785  * The caller must eventually free the returned string (with free()). */
786 char *
787 follow_symlinks(const char *filename)
788 {
789 #ifndef _WIN32
790     struct stat s;
791     char *fn;
792     int i;
793
794     fn = xstrdup(filename);
795     for (i = 0; i < 10; i++) {
796         char *linkname;
797         char *next_fn;
798
799         if (lstat(fn, &s) != 0 || !S_ISLNK(s.st_mode)) {
800             return fn;
801         }
802
803         linkname = xreadlink(fn);
804         if (!linkname) {
805             VLOG_WARN("%s: readlink failed (%s)",
806                       filename, ovs_strerror(errno));
807             return fn;
808         }
809
810         if (linkname[0] == '/') {
811             /* Target of symlink is absolute so use it raw. */
812             next_fn = linkname;
813         } else {
814             /* Target of symlink is relative so add to 'fn''s directory. */
815             char *dir = dir_name(fn);
816
817             if (!strcmp(dir, ".")) {
818                 next_fn = linkname;
819             } else {
820                 char *separator = dir[strlen(dir) - 1] == '/' ? "" : "/";
821                 next_fn = xasprintf("%s%s%s", dir, separator, linkname);
822                 free(linkname);
823             }
824
825             free(dir);
826         }
827
828         free(fn);
829         fn = next_fn;
830     }
831
832     VLOG_WARN("%s: too many levels of symlinks", filename);
833     free(fn);
834 #endif
835     return xstrdup(filename);
836 }
837
838 /* Pass a value to this function if it is marked with
839  * __attribute__((warn_unused_result)) and you genuinely want to ignore
840  * its return value.  (Note that every scalar type can be implicitly
841  * converted to bool.) */
842 void ignore(bool x OVS_UNUSED) { }
843
844 /* Returns an appropriate delimiter for inserting just before the 0-based item
845  * 'index' in a list that has 'total' items in it. */
846 const char *
847 english_list_delimiter(size_t index, size_t total)
848 {
849     return (index == 0 ? ""
850             : index < total - 1 ? ", "
851             : total > 2 ? ", and "
852             : " and ");
853 }
854
855 /* Returns the number of trailing 0-bits in 'n'.  Undefined if 'n' == 0. */
856 #if __GNUC__ >= 4
857 /* Defined inline in util.h. */
858 #else
859 /* Returns the number of trailing 0-bits in 'n'.  Undefined if 'n' == 0. */
860 int
861 raw_ctz(uint64_t n)
862 {
863     uint64_t k;
864     int count = 63;
865
866 #define CTZ_STEP(X)                             \
867     k = n << (X);                               \
868     if (k) {                                    \
869         count -= X;                             \
870         n = k;                                  \
871     }
872     CTZ_STEP(32);
873     CTZ_STEP(16);
874     CTZ_STEP(8);
875     CTZ_STEP(4);
876     CTZ_STEP(2);
877     CTZ_STEP(1);
878 #undef CTZ_STEP
879
880     return count;
881 }
882
883 /* Returns the number of leading 0-bits in 'n'.  Undefined if 'n' == 0. */
884 int
885 raw_clz64(uint64_t n)
886 {
887     uint64_t k;
888     int count = 63;
889
890 #define CLZ_STEP(X)                             \
891     k = n >> (X);                               \
892     if (k) {                                    \
893         count -= X;                             \
894         n = k;                                  \
895     }
896     CLZ_STEP(32);
897     CLZ_STEP(16);
898     CLZ_STEP(8);
899     CLZ_STEP(4);
900     CLZ_STEP(2);
901     CLZ_STEP(1);
902 #undef CLZ_STEP
903
904     return count;
905 }
906 #endif
907
908 #if NEED_COUNT_1BITS_8
909 #define INIT1(X)                                \
910     ((((X) & (1 << 0)) != 0) +                  \
911      (((X) & (1 << 1)) != 0) +                  \
912      (((X) & (1 << 2)) != 0) +                  \
913      (((X) & (1 << 3)) != 0) +                  \
914      (((X) & (1 << 4)) != 0) +                  \
915      (((X) & (1 << 5)) != 0) +                  \
916      (((X) & (1 << 6)) != 0) +                  \
917      (((X) & (1 << 7)) != 0))
918 #define INIT2(X)   INIT1(X),  INIT1((X) +  1)
919 #define INIT4(X)   INIT2(X),  INIT2((X) +  2)
920 #define INIT8(X)   INIT4(X),  INIT4((X) +  4)
921 #define INIT16(X)  INIT8(X),  INIT8((X) +  8)
922 #define INIT32(X) INIT16(X), INIT16((X) + 16)
923 #define INIT64(X) INIT32(X), INIT32((X) + 32)
924
925 const uint8_t count_1bits_8[256] = {
926     INIT64(0), INIT64(64), INIT64(128), INIT64(192)
927 };
928 #endif
929
930 /* Returns true if the 'n' bytes starting at 'p' are zeros. */
931 bool
932 is_all_zeros(const uint8_t *p, size_t n)
933 {
934     size_t i;
935
936     for (i = 0; i < n; i++) {
937         if (p[i] != 0x00) {
938             return false;
939         }
940     }
941     return true;
942 }
943
944 /* Returns true if the 'n' bytes starting at 'p' are 0xff. */
945 bool
946 is_all_ones(const uint8_t *p, size_t n)
947 {
948     size_t i;
949
950     for (i = 0; i < n; i++) {
951         if (p[i] != 0xff) {
952             return false;
953         }
954     }
955     return true;
956 }
957
958 /* Copies 'n_bits' bits starting from bit 'src_ofs' in 'src' to the 'n_bits'
959  * starting from bit 'dst_ofs' in 'dst'.  'src' is 'src_len' bytes long and
960  * 'dst' is 'dst_len' bytes long.
961  *
962  * If you consider all of 'src' to be a single unsigned integer in network byte
963  * order, then bit N is the bit with value 2**N.  That is, bit 0 is the bit
964  * with value 1 in src[src_len - 1], bit 1 is the bit with value 2, bit 2 is
965  * the bit with value 4, ..., bit 8 is the bit with value 1 in src[src_len -
966  * 2], and so on.  Similarly for 'dst'.
967  *
968  * Required invariants:
969  *   src_ofs + n_bits <= src_len * 8
970  *   dst_ofs + n_bits <= dst_len * 8
971  *   'src' and 'dst' must not overlap.
972  */
973 void
974 bitwise_copy(const void *src_, unsigned int src_len, unsigned int src_ofs,
975              void *dst_, unsigned int dst_len, unsigned int dst_ofs,
976              unsigned int n_bits)
977 {
978     const uint8_t *src = src_;
979     uint8_t *dst = dst_;
980
981     src += src_len - (src_ofs / 8 + 1);
982     src_ofs %= 8;
983
984     dst += dst_len - (dst_ofs / 8 + 1);
985     dst_ofs %= 8;
986
987     if (src_ofs == 0 && dst_ofs == 0) {
988         unsigned int n_bytes = n_bits / 8;
989         if (n_bytes) {
990             dst -= n_bytes - 1;
991             src -= n_bytes - 1;
992             memcpy(dst, src, n_bytes);
993
994             n_bits %= 8;
995             src--;
996             dst--;
997         }
998         if (n_bits) {
999             uint8_t mask = (1 << n_bits) - 1;
1000             *dst = (*dst & ~mask) | (*src & mask);
1001         }
1002     } else {
1003         while (n_bits > 0) {
1004             unsigned int max_copy = 8 - MAX(src_ofs, dst_ofs);
1005             unsigned int chunk = MIN(n_bits, max_copy);
1006             uint8_t mask = ((1 << chunk) - 1) << dst_ofs;
1007
1008             *dst &= ~mask;
1009             *dst |= ((*src >> src_ofs) << dst_ofs) & mask;
1010
1011             src_ofs += chunk;
1012             if (src_ofs == 8) {
1013                 src--;
1014                 src_ofs = 0;
1015             }
1016             dst_ofs += chunk;
1017             if (dst_ofs == 8) {
1018                 dst--;
1019                 dst_ofs = 0;
1020             }
1021             n_bits -= chunk;
1022         }
1023     }
1024 }
1025
1026 /* Zeros the 'n_bits' bits starting from bit 'dst_ofs' in 'dst'.  'dst' is
1027  * 'dst_len' bytes long.
1028  *
1029  * If you consider all of 'dst' to be a single unsigned integer in network byte
1030  * order, then bit N is the bit with value 2**N.  That is, bit 0 is the bit
1031  * with value 1 in dst[dst_len - 1], bit 1 is the bit with value 2, bit 2 is
1032  * the bit with value 4, ..., bit 8 is the bit with value 1 in dst[dst_len -
1033  * 2], and so on.
1034  *
1035  * Required invariant:
1036  *   dst_ofs + n_bits <= dst_len * 8
1037  */
1038 void
1039 bitwise_zero(void *dst_, unsigned int dst_len, unsigned dst_ofs,
1040              unsigned int n_bits)
1041 {
1042     uint8_t *dst = dst_;
1043
1044     if (!n_bits) {
1045         return;
1046     }
1047
1048     dst += dst_len - (dst_ofs / 8 + 1);
1049     dst_ofs %= 8;
1050
1051     if (dst_ofs) {
1052         unsigned int chunk = MIN(n_bits, 8 - dst_ofs);
1053
1054         *dst &= ~(((1 << chunk) - 1) << dst_ofs);
1055
1056         n_bits -= chunk;
1057         if (!n_bits) {
1058             return;
1059         }
1060
1061         dst--;
1062     }
1063
1064     while (n_bits >= 8) {
1065         *dst-- = 0;
1066         n_bits -= 8;
1067     }
1068
1069     if (n_bits) {
1070         *dst &= ~((1 << n_bits) - 1);
1071     }
1072 }
1073
1074 /* Sets to 1 all of the 'n_bits' bits starting from bit 'dst_ofs' in 'dst'.
1075  * 'dst' is 'dst_len' bytes long.
1076  *
1077  * If you consider all of 'dst' to be a single unsigned integer in network byte
1078  * order, then bit N is the bit with value 2**N.  That is, bit 0 is the bit
1079  * with value 1 in dst[dst_len - 1], bit 1 is the bit with value 2, bit 2 is
1080  * the bit with value 4, ..., bit 8 is the bit with value 1 in dst[dst_len -
1081  * 2], and so on.
1082  *
1083  * Required invariant:
1084  *   dst_ofs + n_bits <= dst_len * 8
1085  */
1086 void
1087 bitwise_one(void *dst_, unsigned int dst_len, unsigned dst_ofs,
1088             unsigned int n_bits)
1089 {
1090     uint8_t *dst = dst_;
1091
1092     if (!n_bits) {
1093         return;
1094     }
1095
1096     dst += dst_len - (dst_ofs / 8 + 1);
1097     dst_ofs %= 8;
1098
1099     if (dst_ofs) {
1100         unsigned int chunk = MIN(n_bits, 8 - dst_ofs);
1101
1102         *dst |= ((1 << chunk) - 1) << dst_ofs;
1103
1104         n_bits -= chunk;
1105         if (!n_bits) {
1106             return;
1107         }
1108
1109         dst--;
1110     }
1111
1112     while (n_bits >= 8) {
1113         *dst-- = 0xff;
1114         n_bits -= 8;
1115     }
1116
1117     if (n_bits) {
1118         *dst |= (1 << n_bits) - 1;
1119     }
1120 }
1121
1122 /* Scans the 'n_bits' bits starting from bit 'dst_ofs' in 'dst' for 1-bits.
1123  * Returns false if any 1-bits are found, otherwise true.  'dst' is 'dst_len'
1124  * bytes long.
1125  *
1126  * If you consider all of 'dst' to be a single unsigned integer in network byte
1127  * order, then bit N is the bit with value 2**N.  That is, bit 0 is the bit
1128  * with value 1 in dst[dst_len - 1], bit 1 is the bit with value 2, bit 2 is
1129  * the bit with value 4, ..., bit 8 is the bit with value 1 in dst[dst_len -
1130  * 2], and so on.
1131  *
1132  * Required invariant:
1133  *   dst_ofs + n_bits <= dst_len * 8
1134  */
1135 bool
1136 bitwise_is_all_zeros(const void *p_, unsigned int len, unsigned int ofs,
1137                      unsigned int n_bits)
1138 {
1139     const uint8_t *p = p_;
1140
1141     if (!n_bits) {
1142         return true;
1143     }
1144
1145     p += len - (ofs / 8 + 1);
1146     ofs %= 8;
1147
1148     if (ofs) {
1149         unsigned int chunk = MIN(n_bits, 8 - ofs);
1150
1151         if (*p & (((1 << chunk) - 1) << ofs)) {
1152             return false;
1153         }
1154
1155         n_bits -= chunk;
1156         if (!n_bits) {
1157             return true;
1158         }
1159
1160         p--;
1161     }
1162
1163     while (n_bits >= 8) {
1164         if (*p) {
1165             return false;
1166         }
1167         n_bits -= 8;
1168         p--;
1169     }
1170
1171     if (n_bits && *p & ((1 << n_bits) - 1)) {
1172         return false;
1173     }
1174
1175     return true;
1176 }
1177
1178 /* Copies the 'n_bits' low-order bits of 'value' into the 'n_bits' bits
1179  * starting at bit 'dst_ofs' in 'dst', which is 'dst_len' bytes long.
1180  *
1181  * If you consider all of 'dst' to be a single unsigned integer in network byte
1182  * order, then bit N is the bit with value 2**N.  That is, bit 0 is the bit
1183  * with value 1 in dst[dst_len - 1], bit 1 is the bit with value 2, bit 2 is
1184  * the bit with value 4, ..., bit 8 is the bit with value 1 in dst[dst_len -
1185  * 2], and so on.
1186  *
1187  * Required invariants:
1188  *   dst_ofs + n_bits <= dst_len * 8
1189  *   n_bits <= 64
1190  */
1191 void
1192 bitwise_put(uint64_t value,
1193             void *dst, unsigned int dst_len, unsigned int dst_ofs,
1194             unsigned int n_bits)
1195 {
1196     ovs_be64 n_value = htonll(value);
1197     bitwise_copy(&n_value, sizeof n_value, 0,
1198                  dst, dst_len, dst_ofs,
1199                  n_bits);
1200 }
1201
1202 /* Returns the value of the 'n_bits' bits starting at bit 'src_ofs' in 'src',
1203  * which is 'src_len' bytes long.
1204  *
1205  * If you consider all of 'src' to be a single unsigned integer in network byte
1206  * order, then bit N is the bit with value 2**N.  That is, bit 0 is the bit
1207  * with value 1 in src[src_len - 1], bit 1 is the bit with value 2, bit 2 is
1208  * the bit with value 4, ..., bit 8 is the bit with value 1 in src[src_len -
1209  * 2], and so on.
1210  *
1211  * Required invariants:
1212  *   src_ofs + n_bits <= src_len * 8
1213  *   n_bits <= 64
1214  */
1215 uint64_t
1216 bitwise_get(const void *src, unsigned int src_len,
1217             unsigned int src_ofs, unsigned int n_bits)
1218 {
1219     ovs_be64 value = htonll(0);
1220
1221     bitwise_copy(src, src_len, src_ofs,
1222                  &value, sizeof value, 0,
1223                  n_bits);
1224     return ntohll(value);
1225 }
1226 \f
1227 /* ovs_scan */
1228
1229 struct scan_spec {
1230     unsigned int width;
1231     enum {
1232         SCAN_DISCARD,
1233         SCAN_CHAR,
1234         SCAN_SHORT,
1235         SCAN_INT,
1236         SCAN_LONG,
1237         SCAN_LLONG,
1238         SCAN_INTMAX_T,
1239         SCAN_PTRDIFF_T,
1240         SCAN_SIZE_T
1241     } type;
1242 };
1243
1244 static const char *
1245 skip_spaces(const char *s)
1246 {
1247     while (isspace((unsigned char) *s)) {
1248         s++;
1249     }
1250     return s;
1251 }
1252
1253 static const char *
1254 scan_int(const char *s, const struct scan_spec *spec, int base, va_list *args)
1255 {
1256     const char *start = s;
1257     uintmax_t value;
1258     bool negative;
1259     int n_digits;
1260
1261     negative = *s == '-';
1262     s += *s == '-' || *s == '+';
1263
1264     if ((!base || base == 16) && *s == '0' && (s[1] == 'x' || s[1] == 'X')) {
1265         base = 16;
1266         s += 2;
1267     } else if (!base) {
1268         base = *s == '0' ? 8 : 10;
1269     }
1270
1271     if (s - start >= spec->width) {
1272         return NULL;
1273     }
1274
1275     value = 0;
1276     n_digits = 0;
1277     while (s - start < spec->width) {
1278         int digit = hexit_value(*s);
1279
1280         if (digit < 0 || digit >= base) {
1281             break;
1282         }
1283         value = value * base + digit;
1284         n_digits++;
1285         s++;
1286     }
1287     if (!n_digits) {
1288         return NULL;
1289     }
1290
1291     if (negative) {
1292         value = -value;
1293     }
1294
1295     switch (spec->type) {
1296     case SCAN_DISCARD:
1297         break;
1298     case SCAN_CHAR:
1299         *va_arg(*args, char *) = value;
1300         break;
1301     case SCAN_SHORT:
1302         *va_arg(*args, short int *) = value;
1303         break;
1304     case SCAN_INT:
1305         *va_arg(*args, int *) = value;
1306         break;
1307     case SCAN_LONG:
1308         *va_arg(*args, long int *) = value;
1309         break;
1310     case SCAN_LLONG:
1311         *va_arg(*args, long long int *) = value;
1312         break;
1313     case SCAN_INTMAX_T:
1314         *va_arg(*args, intmax_t *) = value;
1315         break;
1316     case SCAN_PTRDIFF_T:
1317         *va_arg(*args, ptrdiff_t *) = value;
1318         break;
1319     case SCAN_SIZE_T:
1320         *va_arg(*args, size_t *) = value;
1321         break;
1322     }
1323     return s;
1324 }
1325
1326 static const char *
1327 skip_digits(const char *s)
1328 {
1329     while (*s >= '0' && *s <= '9') {
1330         s++;
1331     }
1332     return s;
1333 }
1334
1335 static const char *
1336 scan_float(const char *s, const struct scan_spec *spec, va_list *args)
1337 {
1338     const char *start = s;
1339     long double value;
1340     char *tail;
1341     char *copy;
1342     bool ok;
1343
1344     s += *s == '+' || *s == '-';
1345     s = skip_digits(s);
1346     if (*s == '.') {
1347         s = skip_digits(s + 1);
1348     }
1349     if (*s == 'e' || *s == 'E') {
1350         s++;
1351         s += *s == '+' || *s == '-';
1352         s = skip_digits(s);
1353     }
1354
1355     if (s - start > spec->width) {
1356         s = start + spec->width;
1357     }
1358
1359     copy = xmemdup0(start, s - start);
1360     value = strtold(copy, &tail);
1361     ok = *tail == '\0';
1362     free(copy);
1363     if (!ok) {
1364         return NULL;
1365     }
1366
1367     switch (spec->type) {
1368     case SCAN_DISCARD:
1369         break;
1370     case SCAN_INT:
1371         *va_arg(*args, float *) = value;
1372         break;
1373     case SCAN_LONG:
1374         *va_arg(*args, double *) = value;
1375         break;
1376     case SCAN_LLONG:
1377         *va_arg(*args, long double *) = value;
1378         break;
1379
1380     case SCAN_CHAR:
1381     case SCAN_SHORT:
1382     case SCAN_INTMAX_T:
1383     case SCAN_PTRDIFF_T:
1384     case SCAN_SIZE_T:
1385         OVS_NOT_REACHED();
1386     }
1387     return s;
1388 }
1389
1390 static void
1391 scan_output_string(const struct scan_spec *spec,
1392                    const char *s, size_t n,
1393                    va_list *args)
1394 {
1395     if (spec->type != SCAN_DISCARD) {
1396         char *out = va_arg(*args, char *);
1397         memcpy(out, s, n);
1398         out[n] = '\0';
1399     }
1400 }
1401
1402 static const char *
1403 scan_string(const char *s, const struct scan_spec *spec, va_list *args)
1404 {
1405     size_t n;
1406
1407     for (n = 0; n < spec->width; n++) {
1408         if (!s[n] || isspace((unsigned char) s[n])) {
1409             break;
1410         }
1411     }
1412     if (!n) {
1413         return NULL;
1414     }
1415
1416     scan_output_string(spec, s, n, args);
1417     return s + n;
1418 }
1419
1420 static const char *
1421 parse_scanset(const char *p_, unsigned long *set, bool *complemented)
1422 {
1423     const uint8_t *p = (const uint8_t *) p_;
1424
1425     *complemented = *p == '^';
1426     p += *complemented;
1427
1428     if (*p == ']') {
1429         bitmap_set1(set, ']');
1430         p++;
1431     }
1432
1433     while (*p && *p != ']') {
1434         if (p[1] == '-' && p[2] != ']' && p[2] > *p) {
1435             bitmap_set_multiple(set, *p, p[2] - *p + 1, true);
1436             p += 3;
1437         } else {
1438             bitmap_set1(set, *p++);
1439         }
1440     }
1441     if (*p == ']') {
1442         p++;
1443     }
1444     return (const char *) p;
1445 }
1446
1447 static const char *
1448 scan_set(const char *s, const struct scan_spec *spec, const char **pp,
1449          va_list *args)
1450 {
1451     unsigned long set[BITMAP_N_LONGS(UCHAR_MAX + 1)];
1452     bool complemented;
1453     unsigned int n;
1454
1455     /* Parse the scan set. */
1456     memset(set, 0, sizeof set);
1457     *pp = parse_scanset(*pp, set, &complemented);
1458
1459     /* Parse the data. */
1460     n = 0;
1461     while (s[n]
1462            && bitmap_is_set(set, (unsigned char) s[n]) == !complemented
1463            && n < spec->width) {
1464         n++;
1465     }
1466     if (!n) {
1467         return NULL;
1468     }
1469     scan_output_string(spec, s, n, args);
1470     return s + n;
1471 }
1472
1473 static const char *
1474 scan_chars(const char *s, const struct scan_spec *spec, va_list *args)
1475 {
1476     unsigned int n = spec->width == UINT_MAX ? 1 : spec->width;
1477
1478     if (strlen(s) < n) {
1479         return NULL;
1480     }
1481     if (spec->type != SCAN_DISCARD) {
1482         memcpy(va_arg(*args, char *), s, n);
1483     }
1484     return s + n;
1485 }
1486
1487 /* This is an implementation of the standard sscanf() function, with the
1488  * following exceptions:
1489  *
1490  *   - It returns true if the entire format was successfully scanned and
1491  *     converted, false if any conversion failed.
1492  *
1493  *   - The standard doesn't define sscanf() behavior when an out-of-range value
1494  *     is scanned, e.g. if a "%"PRIi8 conversion scans "-1" or "0x1ff".  Some
1495  *     implementations consider this an error and stop scanning.  This
1496  *     implementation never considers an out-of-range value an error; instead,
1497  *     it stores the least-significant bits of the converted value in the
1498  *     destination, e.g. the value 255 for both examples earlier.
1499  *
1500  *   - Only single-byte characters are supported, that is, the 'l' modifier
1501  *     on %s, %[, and %c is not supported.  The GNU extension 'a' modifier is
1502  *     also not supported.
1503  *
1504  *   - %p is not supported.
1505  */
1506 bool
1507 ovs_scan(const char *s, const char *format, ...)
1508 {
1509     const char *const start = s;
1510     bool ok = false;
1511     const char *p;
1512     va_list args;
1513
1514     va_start(args, format);
1515     p = format;
1516     while (*p != '\0') {
1517         struct scan_spec spec;
1518         unsigned char c = *p++;
1519         bool discard;
1520
1521         if (isspace(c)) {
1522             s = skip_spaces(s);
1523             continue;
1524         } else if (c != '%') {
1525             if (*s != c) {
1526                 goto exit;
1527             }
1528             s++;
1529             continue;
1530         } else if (*p == '%') {
1531             if (*s++ != '%') {
1532                 goto exit;
1533             }
1534             p++;
1535             continue;
1536         }
1537
1538         /* Parse '*' flag. */
1539         discard = *p == '*';
1540         p += discard;
1541
1542         /* Parse field width. */
1543         spec.width = 0;
1544         while (*p >= '0' && *p <= '9') {
1545             spec.width = spec.width * 10 + (*p++ - '0');
1546         }
1547         if (spec.width == 0) {
1548             spec.width = UINT_MAX;
1549         }
1550
1551         /* Parse type modifier. */
1552         switch (*p) {
1553         case 'h':
1554             if (p[1] == 'h') {
1555                 spec.type = SCAN_CHAR;
1556                 p += 2;
1557             } else {
1558                 spec.type = SCAN_SHORT;
1559                 p++;
1560             }
1561             break;
1562
1563         case 'j':
1564             spec.type = SCAN_INTMAX_T;
1565             p++;
1566             break;
1567
1568         case 'l':
1569             if (p[1] == 'l') {
1570                 spec.type = SCAN_LLONG;
1571                 p += 2;
1572             } else {
1573                 spec.type = SCAN_LONG;
1574                 p++;
1575             }
1576             break;
1577
1578         case 'L':
1579         case 'q':
1580             spec.type = SCAN_LLONG;
1581             p++;
1582             break;
1583
1584         case 't':
1585             spec.type = SCAN_PTRDIFF_T;
1586             p++;
1587             break;
1588
1589         case 'z':
1590             spec.type = SCAN_SIZE_T;
1591             p++;
1592             break;
1593
1594         default:
1595             spec.type = SCAN_INT;
1596             break;
1597         }
1598
1599         if (discard) {
1600             spec.type = SCAN_DISCARD;
1601         }
1602
1603         c = *p++;
1604         if (c != 'c' && c != 'n' && c != '[') {
1605             s = skip_spaces(s);
1606         }
1607         switch (c) {
1608         case 'd':
1609             s = scan_int(s, &spec, 10, &args);
1610             break;
1611
1612         case 'i':
1613             s = scan_int(s, &spec, 0, &args);
1614             break;
1615
1616         case 'o':
1617             s = scan_int(s, &spec, 8, &args);
1618             break;
1619
1620         case 'u':
1621             s = scan_int(s, &spec, 10, &args);
1622             break;
1623
1624         case 'x':
1625         case 'X':
1626             s = scan_int(s, &spec, 16, &args);
1627             break;
1628
1629         case 'e':
1630         case 'f':
1631         case 'g':
1632         case 'E':
1633         case 'G':
1634             s = scan_float(s, &spec, &args);
1635             break;
1636
1637         case 's':
1638             s = scan_string(s, &spec, &args);
1639             break;
1640
1641         case '[':
1642             s = scan_set(s, &spec, &p, &args);
1643             break;
1644
1645         case 'c':
1646             s = scan_chars(s, &spec, &args);
1647             break;
1648
1649         case 'n':
1650             if (spec.type != SCAN_DISCARD) {
1651                 *va_arg(args, int *) = s - start;
1652             }
1653             break;
1654         }
1655
1656         if (!s) {
1657             goto exit;
1658         }
1659     }
1660     ok = true;
1661
1662 exit:
1663     va_end(args);
1664     return ok;
1665 }
1666
1667 #ifdef _WIN32
1668 \f
1669 char *
1670 ovs_format_message(int error)
1671 {
1672     enum { BUFSIZE = sizeof strerror_buffer_get()->s };
1673     char *buffer = strerror_buffer_get()->s;
1674
1675     FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
1676                   NULL, error, 0, buffer, BUFSIZE, NULL);
1677     return buffer;
1678 }
1679
1680 /* Returns a null-terminated string that explains the last error.
1681  * Use this function to get the error string for WINAPI calls. */
1682 char *
1683 ovs_lasterror_to_string(void)
1684 {
1685     return ovs_format_message(GetLastError());
1686 }
1687 #endif