rconn: Be pickier about what constitutes a successful connection.
[sliver-openvswitch.git] / lib / util.c
1 /* Copyright (c) 2008 The Board of Trustees of The Leland Stanford
2  * Junior University
3  * 
4  * We are making the OpenFlow specification and associated documentation
5  * (Software) available for public use and benefit with the expectation
6  * that others will use, modify and enhance the Software and contribute
7  * those enhancements back to the community. However, since we would
8  * like to make the Software available for broadest use, with as few
9  * restrictions as possible permission is hereby granted, free of
10  * charge, to any person obtaining a copy of this Software to deal in
11  * the Software under the copyrights without restriction, including
12  * without limitation the rights to use, copy, modify, merge, publish,
13  * distribute, sublicense, and/or sell copies of the Software, and to
14  * permit persons to whom the Software is furnished to do so, subject to
15  * the following conditions:
16  * 
17  * The above copyright notice and this permission notice shall be
18  * included in all copies or substantial portions of the Software.
19  * 
20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
24  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
25  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
26  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27  * SOFTWARE.
28  * 
29  * The name and trademarks of copyright holder(s) may NOT be used in
30  * advertising or publicity pertaining to the Software or any
31  * derivatives without specific, written prior permission.
32  */
33
34 #include <config.h>
35 #include "util.h"
36 #include <errno.h>
37 #include <stdarg.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41
42 const char *program_name;
43
44 void
45 out_of_memory(void) 
46 {
47     ofp_fatal(0, "virtual memory exhausted");
48 }
49
50 void *
51 xcalloc(size_t count, size_t size) 
52 {
53     void *p = count && size ? calloc(count, size) : malloc(1);
54     if (p == NULL) {
55         out_of_memory();
56     }
57     return p;
58 }
59
60 void *
61 xmalloc(size_t size) 
62 {
63     void *p = malloc(size ? size : 1);
64     if (p == NULL) {
65         out_of_memory();
66     }
67     return p;
68 }
69
70 void *
71 xrealloc(void *p, size_t size) 
72 {
73     p = realloc(p, size ? size : 1);
74     if (p == NULL) {
75         out_of_memory();
76     }
77     return p;
78 }
79
80 void *
81 xmemdup(const void *p_, size_t size)
82 {
83     void *p = xmalloc(size);
84     memcpy(p, p_, size);
85     return p;
86 }
87
88 char *
89 xmemdup0(const char *p_, size_t length)
90 {
91     char *p = xmalloc(length + 1);
92     memcpy(p, p_, length);
93     p[length] = '\0';
94     return p;
95 }
96
97 char *
98 xstrdup(const char *s) 
99 {
100     return xmemdup0(s, strlen(s));
101 }
102
103 char *
104 xasprintf(const char *format, ...)
105 {
106     va_list args;
107     size_t needed;
108     char *s;
109
110     va_start(args, format);
111     needed = vsnprintf(NULL, 0, format, args);
112     va_end(args);
113
114     s = xmalloc(needed + 1);
115
116     va_start(args, format);
117     vsnprintf(s, needed + 1, format, args);
118     va_end(args);
119
120     return s;
121 }
122
123 void
124 ofp_fatal(int err_no, const char *format, ...)
125 {
126     va_list args;
127
128     fprintf(stderr, "%s: ", program_name);
129     va_start(args, format);
130     vfprintf(stderr, format, args);
131     va_end(args);
132     if (err_no != 0)
133         fprintf(stderr, " (%s)", strerror(err_no));
134     putc('\n', stderr);
135
136     exit(EXIT_FAILURE);
137 }
138
139 void
140 ofp_error(int err_no, const char *format, ...)
141 {
142     int save_errno = errno;
143     va_list args;
144
145     fprintf(stderr, "%s: ", program_name);
146     va_start(args, format);
147     vfprintf(stderr, format, args);
148     va_end(args);
149     if (err_no != 0)
150         fprintf(stderr, " (%s)", strerror(err_no));
151     putc('\n', stderr);
152
153     errno = save_errno;
154 }
155
156 /* Sets program_name based on 'argv0'.  Should be called at the beginning of
157  * main(), as "set_program_name(argv[0]);".  */
158 void set_program_name(const char *argv0)
159 {
160     const char *slash = strrchr(argv0, '/');
161     program_name = slash ? slash + 1 : argv0;
162 }
163
164 /* Writes the 'size' bytes in 'buf' to 'stream' as hex bytes arranged 16 per
165  * line.  Numeric offsets are also included, starting at 'ofs' for the first
166  * byte in 'buf'.  If 'ascii' is true then the corresponding ASCII characters
167  * are also rendered alongside. */
168 void
169 ofp_hex_dump(FILE *stream, const void *buf_, size_t size,
170              uintptr_t ofs, bool ascii)
171 {
172   const uint8_t *buf = buf_;
173   const size_t per_line = 16; /* Maximum bytes per line. */
174
175   while (size > 0)
176     {
177       size_t start, end, n;
178       size_t i;
179
180       /* Number of bytes on this line. */
181       start = ofs % per_line;
182       end = per_line;
183       if (end - start > size)
184         end = start + size;
185       n = end - start;
186
187       /* Print line. */
188       fprintf(stream, "%08jx  ", (uintmax_t) ROUND_DOWN(ofs, per_line));
189       for (i = 0; i < start; i++)
190         fprintf(stream, "   ");
191       for (; i < end; i++)
192         fprintf(stream, "%02hhx%c",
193                 buf[i - start], i == per_line / 2 - 1? '-' : ' ');
194       if (ascii)
195         {
196           for (; i < per_line; i++)
197             fprintf(stream, "   ");
198           fprintf(stream, "|");
199           for (i = 0; i < start; i++)
200             fprintf(stream, " ");
201           for (; i < end; i++) {
202               int c = buf[i - start];
203               putc(c >= 32 && c < 127 ? c : '.', stream);
204           }
205           for (; i < per_line; i++)
206             fprintf(stream, " ");
207           fprintf(stream, "|");
208         }
209       fprintf(stream, "\n");
210
211       ofs += n;
212       buf += n;
213       size -= n;
214     }
215 }