netflow: Back-out optimization that could lead to infinite loop
[sliver-openvswitch.git] / lib / util.c
1 /*
2  * Copyright (c) 2008, 2009, 2010 Nicira Networks.
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 <errno.h>
20 #include <stdarg.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <unistd.h>
25 #include "coverage.h"
26 #include "vlog.h"
27
28 VLOG_DEFINE_THIS_MODULE(util)
29
30 const char *program_name;
31
32 void
33 out_of_memory(void)
34 {
35     ovs_fatal(0, "virtual memory exhausted");
36 }
37
38 void *
39 xcalloc(size_t count, size_t size)
40 {
41     void *p = count && size ? calloc(count, size) : malloc(1);
42     COVERAGE_INC(util_xalloc);
43     if (p == NULL) {
44         out_of_memory();
45     }
46     return p;
47 }
48
49 void *
50 xzalloc(size_t size)
51 {
52     return xcalloc(1, size);
53 }
54
55 void *
56 xmalloc(size_t size)
57 {
58     void *p = malloc(size ? size : 1);
59     COVERAGE_INC(util_xalloc);
60     if (p == NULL) {
61         out_of_memory();
62     }
63     return p;
64 }
65
66 void *
67 xrealloc(void *p, size_t size)
68 {
69     p = realloc(p, size ? size : 1);
70     COVERAGE_INC(util_xalloc);
71     if (p == NULL) {
72         out_of_memory();
73     }
74     return p;
75 }
76
77 void *
78 xmemdup(const void *p_, size_t size)
79 {
80     void *p = xmalloc(size);
81     memcpy(p, p_, size);
82     return p;
83 }
84
85 char *
86 xmemdup0(const char *p_, size_t length)
87 {
88     char *p = xmalloc(length + 1);
89     memcpy(p, p_, length);
90     p[length] = '\0';
91     return p;
92 }
93
94 char *
95 xstrdup(const char *s)
96 {
97     return xmemdup0(s, strlen(s));
98 }
99
100 char *
101 xvasprintf(const char *format, va_list args)
102 {
103     va_list args2;
104     size_t needed;
105     char *s;
106
107     va_copy(args2, args);
108     needed = vsnprintf(NULL, 0, format, args);
109
110     s = xmalloc(needed + 1);
111
112     vsnprintf(s, needed + 1, format, args2);
113     va_end(args2);
114
115     return s;
116 }
117
118 void *
119 x2nrealloc(void *p, size_t *n, size_t s)
120 {
121     *n = *n == 0 ? 1 : 2 * *n;
122     return xrealloc(p, *n * s);
123 }
124
125 char *
126 xasprintf(const char *format, ...)
127 {
128     va_list args;
129     char *s;
130
131     va_start(args, format);
132     s = xvasprintf(format, args);
133     va_end(args);
134
135     return s;
136 }
137
138 void
139 ovs_strlcpy(char *dst, const char *src, size_t size)
140 {
141     if (size > 0) {
142         size_t n = strlen(src);
143         size_t n_copy = MIN(n, size - 1);
144         memcpy(dst, src, n_copy);
145         dst[n_copy] = '\0';
146     }
147 }
148
149 void
150 ovs_fatal(int err_no, const char *format, ...)
151 {
152     va_list args;
153
154     fprintf(stderr, "%s: ", program_name);
155     va_start(args, format);
156     vfprintf(stderr, format, args);
157     va_end(args);
158     if (err_no != 0)
159         fprintf(stderr, " (%s)",
160                 err_no == EOF ? "end of file" : strerror(err_no));
161     putc('\n', stderr);
162
163     exit(EXIT_FAILURE);
164 }
165
166 void
167 ovs_error(int err_no, const char *format, ...)
168 {
169     int save_errno = errno;
170     va_list args;
171
172     fprintf(stderr, "%s: ", program_name);
173     va_start(args, format);
174     vfprintf(stderr, format, args);
175     va_end(args);
176     if (err_no != 0) {
177         fprintf(stderr, " (%s)",
178                 err_no == EOF ? "end of file" : strerror(err_no));
179     }
180     putc('\n', stderr);
181
182     errno = save_errno;
183 }
184
185 /* Sets program_name based on 'argv0'.  Should be called at the beginning of
186  * main(), as "set_program_name(argv[0]);".  */
187 void set_program_name(const char *argv0)
188 {
189     const char *slash = strrchr(argv0, '/');
190     program_name = slash ? slash + 1 : argv0;
191 }
192
193 /* Print the version information for the program.  */
194 void
195 ovs_print_version(char *date, char *time,
196                   uint8_t min_ofp, uint8_t max_ofp)
197 {
198     printf("%s (Open vSwitch) "VERSION BUILDNR"\n", program_name);
199     printf("Compiled %s %s\n", date, time);
200     if (min_ofp || max_ofp) {
201         printf("OpenFlow versions %#x:%#x\n", min_ofp, max_ofp);
202     }
203 }
204
205 /* Writes the 'size' bytes in 'buf' to 'stream' as hex bytes arranged 16 per
206  * line.  Numeric offsets are also included, starting at 'ofs' for the first
207  * byte in 'buf'.  If 'ascii' is true then the corresponding ASCII characters
208  * are also rendered alongside. */
209 void
210 ovs_hex_dump(FILE *stream, const void *buf_, size_t size,
211              uintptr_t ofs, bool ascii)
212 {
213   const uint8_t *buf = buf_;
214   const size_t per_line = 16; /* Maximum bytes per line. */
215
216   while (size > 0)
217     {
218       size_t start, end, n;
219       size_t i;
220
221       /* Number of bytes on this line. */
222       start = ofs % per_line;
223       end = per_line;
224       if (end - start > size)
225         end = start + size;
226       n = end - start;
227
228       /* Print line. */
229       fprintf(stream, "%08jx  ", (uintmax_t) ROUND_DOWN(ofs, per_line));
230       for (i = 0; i < start; i++)
231         fprintf(stream, "   ");
232       for (; i < end; i++)
233         fprintf(stream, "%02hhx%c",
234                 buf[i - start], i == per_line / 2 - 1? '-' : ' ');
235       if (ascii)
236         {
237           for (; i < per_line; i++)
238             fprintf(stream, "   ");
239           fprintf(stream, "|");
240           for (i = 0; i < start; i++)
241             fprintf(stream, " ");
242           for (; i < end; i++) {
243               int c = buf[i - start];
244               putc(c >= 32 && c < 127 ? c : '.', stream);
245           }
246           for (; i < per_line; i++)
247             fprintf(stream, " ");
248           fprintf(stream, "|");
249         }
250       fprintf(stream, "\n");
251
252       ofs += n;
253       buf += n;
254       size -= n;
255     }
256 }
257
258 bool
259 str_to_int(const char *s, int base, int *i)
260 {
261     long long ll;
262     bool ok = str_to_llong(s, base, &ll);
263     *i = ll;
264     return ok;
265 }
266
267 bool
268 str_to_long(const char *s, int base, long *li)
269 {
270     long long ll;
271     bool ok = str_to_llong(s, base, &ll);
272     *li = ll;
273     return ok;
274 }
275
276 bool
277 str_to_llong(const char *s, int base, long long *x)
278 {
279     int save_errno = errno;
280     char *tail;
281     errno = 0;
282     *x = strtoll(s, &tail, base);
283     if (errno == EINVAL || errno == ERANGE || tail == s || *tail != '\0') {
284         errno = save_errno;
285         *x = 0;
286         return false;
287     } else {
288         errno = save_errno;
289         return true;
290     }
291 }
292
293 bool
294 str_to_uint(const char *s, int base, unsigned int *u)
295 {
296     return str_to_int(s, base, (int *) u);
297 }
298
299 bool
300 str_to_ulong(const char *s, int base, unsigned long *ul)
301 {
302     return str_to_long(s, base, (long *) ul);
303 }
304
305 bool
306 str_to_ullong(const char *s, int base, unsigned long long *ull)
307 {
308     return str_to_llong(s, base, (long long *) ull);
309 }
310
311 /* Converts floating-point string 's' into a double.  If successful, stores
312  * the double in '*d' and returns true; on failure, stores 0 in '*d' and
313  * returns false.
314  *
315  * Underflow (e.g. "1e-9999") is not considered an error, but overflow
316  * (e.g. "1e9999)" is. */
317 bool
318 str_to_double(const char *s, double *d)
319 {
320     int save_errno = errno;
321     char *tail;
322     errno = 0;
323     *d = strtod(s, &tail);
324     if (errno == EINVAL || (errno == ERANGE && *d != 0)
325         || tail == s || *tail != '\0') {
326         errno = save_errno;
327         *d = 0;
328         return false;
329     } else {
330         errno = save_errno;
331         return true;
332     }
333 }
334
335 /* Returns the value of 'c' as a hexadecimal digit. */
336 int
337 hexit_value(int c)
338 {
339     switch (c) {
340     case '0': case '1': case '2': case '3': case '4':
341     case '5': case '6': case '7': case '8': case '9':
342         return c - '0';
343
344     case 'a': case 'A':
345         return 0xa;
346
347     case 'b': case 'B':
348         return 0xb;
349
350     case 'c': case 'C':
351         return 0xc;
352
353     case 'd': case 'D':
354         return 0xd;
355
356     case 'e': case 'E':
357         return 0xe;
358
359     case 'f': case 'F':
360         return 0xf;
361     }
362
363     NOT_REACHED();
364 }
365
366 /* Returns the current working directory as a malloc()'d string, or a null
367  * pointer if the current working directory cannot be determined. */
368 char *
369 get_cwd(void)
370 {
371     long int path_max;
372     size_t size;
373
374     /* Get maximum path length or at least a reasonable estimate. */
375     path_max = pathconf(".", _PC_PATH_MAX);
376     size = (path_max < 0 ? 1024
377             : path_max > 10240 ? 10240
378             : path_max);
379
380     /* Get current working directory. */
381     for (;;) {
382         char *buf = xmalloc(size);
383         if (getcwd(buf, size)) {
384             return xrealloc(buf, strlen(buf) + 1);
385         } else {
386             int error = errno;
387             free(buf);
388             if (error != ERANGE) {
389                 VLOG_WARN("getcwd failed (%s)", strerror(error));
390                 return NULL;
391             }
392             size *= 2;
393         }
394     }
395 }
396
397 /* Returns the directory name portion of 'file_name' as a malloc()'d string,
398  * similar to the POSIX dirname() function but thread-safe. */
399 char *
400 dir_name(const char *file_name)
401 {
402     size_t len = strlen(file_name);
403     while (len > 0 && file_name[len - 1] == '/') {
404         len--;
405     }
406     while (len > 0 && file_name[len - 1] != '/') {
407         len--;
408     }
409     while (len > 0 && file_name[len - 1] == '/') {
410         len--;
411     }
412     if (!len) {
413         return xstrdup((file_name[0] == '/'
414                         && file_name[1] == '/'
415                         && file_name[2] != '/') ? "//"
416                        : file_name[0] == '/' ? "/"
417                        : ".");
418     } else {
419         return xmemdup0(file_name, len);
420     }
421 }
422
423 /* If 'file_name' starts with '/', returns a copy of 'file_name'.  Otherwise,
424  * returns an absolute path to 'file_name' considering it relative to 'dir',
425  * which itself must be absolute.  'dir' may be null or the empty string, in
426  * which case the current working directory is used.
427  *
428  * Returns a null pointer if 'dir' is null and getcwd() fails. */
429 char *
430 abs_file_name(const char *dir, const char *file_name)
431 {
432     if (file_name[0] == '/') {
433         return xstrdup(file_name);
434     } else if (dir && dir[0]) {
435         char *separator = dir[strlen(dir) - 1] == '/' ? "" : "/";
436         return xasprintf("%s%s%s", dir, separator, file_name);
437     } else {
438         char *cwd = get_cwd();
439         if (cwd) {
440             char *abs_name = xasprintf("%s/%s", cwd, file_name);
441             free(cwd);
442             return abs_name;
443         } else {
444             return NULL;
445         }
446     }
447 }
448
449
450 /* Pass a value to this function if it is marked with
451  * __attribute__((warn_unused_result)) and you genuinely want to ignore
452  * its return value.  (Note that every scalar type can be implicitly
453  * converted to bool.) */
454 void ignore(bool x OVS_UNUSED) { }