]>
Commit | Line | Data |
---|---|---|
aff33962 | 1 | /* dnsmasq is Copyright (c) 2000-2015 Simon Kelley |
9e4abcb5 SK |
2 | |
3 | This program is free software; you can redistribute it and/or modify | |
4 | it under the terms of the GNU General Public License as published by | |
824af85b SK |
5 | the Free Software Foundation; version 2 dated June, 1991, or |
6 | (at your option) version 3 dated 29 June, 2007. | |
7 | ||
9e4abcb5 SK |
8 | This program is distributed in the hope that it will be useful, |
9 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | GNU General Public License for more details. | |
73a08a24 SK |
12 | |
13 | You should have received a copy of the GNU General Public License | |
14 | along with this program. If not, see <http://www.gnu.org/licenses/>. | |
9e4abcb5 SK |
15 | */ |
16 | ||
1a6bca81 | 17 | /* The SURF random number generator was taken from djbdns-1.05, by |
7622fc06 | 18 | Daniel J Bernstein, which is public domain. */ |
1a6bca81 SK |
19 | |
20 | ||
9e4abcb5 SK |
21 | #include "dnsmasq.h" |
22 | ||
5e9e0efb SK |
23 | #ifdef HAVE_BROKEN_RTC |
24 | #include <sys/times.h> | |
25 | #endif | |
26 | ||
572b41eb | 27 | #if defined(LOCALEDIR) || defined(HAVE_IDN) |
1f15b81d SK |
28 | #include <idna.h> |
29 | #endif | |
1a6bca81 | 30 | |
1a6bca81 SK |
31 | /* SURF random number generator */ |
32 | ||
572b41eb SK |
33 | static u32 seed[32]; |
34 | static u32 in[12]; | |
35 | static u32 out[8]; | |
6586e835 | 36 | static int outleft = 0; |
1a6bca81 SK |
37 | |
38 | void rand_init() | |
39 | { | |
40 | int fd = open(RANDFILE, O_RDONLY); | |
9e4abcb5 | 41 | |
1a6bca81 SK |
42 | if (fd == -1 || |
43 | !read_write(fd, (unsigned char *)&seed, sizeof(seed), 1) || | |
44 | !read_write(fd, (unsigned char *)&in, sizeof(in), 1)) | |
45 | die(_("failed to seed the random number generator: %s"), NULL, EC_MISC); | |
46 | ||
47 | close(fd); | |
48 | } | |
49 | ||
50 | #define ROTATE(x,b) (((x) << (b)) | ((x) >> (32 - (b)))) | |
51 | #define MUSH(i,b) x = t[i] += (((x ^ seed[i]) + sum) ^ ROTATE(x,b)); | |
9e4abcb5 | 52 | |
1a6bca81 SK |
53 | static void surf(void) |
54 | { | |
572b41eb | 55 | u32 t[12]; u32 x; u32 sum = 0; |
1a6bca81 SK |
56 | int r; int i; int loop; |
57 | ||
58 | for (i = 0;i < 12;++i) t[i] = in[i] ^ seed[12 + i]; | |
59 | for (i = 0;i < 8;++i) out[i] = seed[24 + i]; | |
60 | x = t[11]; | |
61 | for (loop = 0;loop < 2;++loop) { | |
62 | for (r = 0;r < 16;++r) { | |
63 | sum += 0x9e3779b9; | |
64 | MUSH(0,5) MUSH(1,7) MUSH(2,9) MUSH(3,13) | |
65 | MUSH(4,5) MUSH(5,7) MUSH(6,9) MUSH(7,13) | |
66 | MUSH(8,5) MUSH(9,7) MUSH(10,9) MUSH(11,13) | |
9e4abcb5 | 67 | } |
1a6bca81 SK |
68 | for (i = 0;i < 8;++i) out[i] ^= t[i + 4]; |
69 | } | |
70 | } | |
71 | ||
72 | unsigned short rand16(void) | |
6586e835 SK |
73 | { |
74 | if (!outleft) | |
75 | { | |
76 | if (!++in[0]) if (!++in[1]) if (!++in[2]) ++in[3]; | |
77 | surf(); | |
78 | outleft = 8; | |
79 | } | |
80 | ||
81 | return (unsigned short) out[--outleft]; | |
82 | } | |
83 | ||
b5ea1cc2 SK |
84 | u32 rand32(void) |
85 | { | |
86 | if (!outleft) | |
87 | { | |
88 | if (!++in[0]) if (!++in[1]) if (!++in[2]) ++in[3]; | |
89 | surf(); | |
90 | outleft = 8; | |
91 | } | |
92 | ||
93 | return out[--outleft]; | |
94 | } | |
95 | ||
6586e835 | 96 | u64 rand64(void) |
1a6bca81 SK |
97 | { |
98 | static int outleft = 0; | |
99 | ||
6586e835 SK |
100 | if (outleft < 2) |
101 | { | |
102 | if (!++in[0]) if (!++in[1]) if (!++in[2]) ++in[3]; | |
103 | surf(); | |
104 | outleft = 8; | |
105 | } | |
106 | ||
107 | outleft -= 2; | |
1a6bca81 | 108 | |
6586e835 | 109 | return (u64)out[outleft+1] + (((u64)out[outleft]) << 32); |
9e4abcb5 SK |
110 | } |
111 | ||
1f15b81d | 112 | static int check_name(char *in) |
9e4abcb5 | 113 | { |
1f15b81d | 114 | /* remove trailing . |
f6b7dc47 | 115 | also fail empty string and label > 63 chars */ |
1f15b81d | 116 | size_t dotgap = 0, l = strlen(in); |
9e4abcb5 | 117 | char c; |
5aabfc78 | 118 | int nowhite = 0; |
1f15b81d | 119 | |
f6b7dc47 | 120 | if (l == 0 || l > MAXDNAME) return 0; |
1f15b81d SK |
121 | |
122 | if (in[l-1] == '.') | |
a222641c | 123 | { |
1f15b81d | 124 | in[l-1] = 0; |
0fc2f313 | 125 | nowhite = 1; |
a222641c | 126 | } |
0fc2f313 | 127 | |
1f15b81d | 128 | for (; (c = *in); in++) |
3d8df260 SK |
129 | { |
130 | if (c == '.') | |
131 | dotgap = 0; | |
1f15b81d | 132 | else if (++dotgap > MAXLABEL) |
3d8df260 | 133 | return 0; |
572b41eb | 134 | else if (isascii((unsigned char)c) && iscntrl((unsigned char)c)) |
1f15b81d SK |
135 | /* iscntrl only gives expected results for ascii */ |
136 | return 0; | |
572b41eb SK |
137 | #if !defined(LOCALEDIR) && !defined(HAVE_IDN) |
138 | else if (!isascii((unsigned char)c)) | |
1f15b81d SK |
139 | return 0; |
140 | #endif | |
5aabfc78 SK |
141 | else if (c != ' ') |
142 | nowhite = 1; | |
3d8df260 | 143 | } |
1f15b81d SK |
144 | |
145 | if (!nowhite) | |
146 | return 0; | |
147 | ||
148 | return 1; | |
149 | } | |
150 | ||
151 | /* Hostnames have a more limited valid charset than domain names | |
152 | so check for legal char a-z A-Z 0-9 - _ | |
153 | Note that this may receive a FQDN, so only check the first label | |
154 | for the tighter criteria. */ | |
155 | int legal_hostname(char *name) | |
156 | { | |
157 | char c; | |
7abb69b5 | 158 | int first; |
1f15b81d SK |
159 | |
160 | if (!check_name(name)) | |
161 | return 0; | |
162 | ||
7abb69b5 | 163 | for (first = 1; (c = *name); name++, first = 0) |
1f15b81d SK |
164 | /* check for legal char a-z A-Z 0-9 - _ . */ |
165 | { | |
166 | if ((c >= 'A' && c <= 'Z') || | |
d859ca2f KM |
167 | (c >= 'a' && c <= 'z') || |
168 | (c >= '0' && c <= '9')) | |
1f15b81d | 169 | continue; |
7abb69b5 | 170 | |
d859ca2f | 171 | if (!first && (c == '-' || c == '_')) |
7abb69b5 | 172 | continue; |
d859ca2f | 173 | |
1f15b81d SK |
174 | /* end of hostname part */ |
175 | if (c == '.') | |
176 | return 1; | |
177 | ||
178 | return 0; | |
179 | } | |
180 | ||
181 | return 1; | |
182 | } | |
183 | ||
184 | char *canonicalise(char *in, int *nomem) | |
185 | { | |
186 | char *ret = NULL; | |
572b41eb | 187 | #if defined(LOCALEDIR) || defined(HAVE_IDN) |
1f15b81d SK |
188 | int rc; |
189 | #endif | |
190 | ||
191 | if (nomem) | |
192 | *nomem = 0; | |
193 | ||
194 | if (!check_name(in)) | |
195 | return NULL; | |
196 | ||
572b41eb | 197 | #if defined(LOCALEDIR) || defined(HAVE_IDN) |
1f15b81d SK |
198 | if ((rc = idna_to_ascii_lz(in, &ret, 0)) != IDNA_SUCCESS) |
199 | { | |
200 | if (ret) | |
201 | free(ret); | |
202 | ||
203 | if (nomem && (rc == IDNA_MALLOC_ERROR || rc == IDNA_DLOPEN_ERROR)) | |
204 | { | |
205 | my_syslog(LOG_ERR, _("failed to allocate memory")); | |
206 | *nomem = 1; | |
207 | } | |
208 | ||
209 | return NULL; | |
210 | } | |
211 | #else | |
212 | if ((ret = whine_malloc(strlen(in)+1))) | |
213 | strcpy(ret, in); | |
214 | else if (nomem) | |
215 | *nomem = 1; | |
216 | #endif | |
217 | ||
218 | return ret; | |
9e4abcb5 SK |
219 | } |
220 | ||
3d8df260 SK |
221 | unsigned char *do_rfc1035_name(unsigned char *p, char *sval) |
222 | { | |
223 | int j; | |
224 | ||
225 | while (sval && *sval) | |
226 | { | |
227 | unsigned char *cp = p++; | |
228 | for (j = 0; *sval && (*sval != '.'); sval++, j++) | |
cbe379ad SK |
229 | { |
230 | #ifdef HAVE_DNSSEC | |
231 | if (option_bool(OPT_DNSSEC_VALID) && *sval == NAME_ESCAPE) | |
b8f16556 | 232 | *p++ = (*(++sval))-1; |
cbe379ad SK |
233 | else |
234 | #endif | |
235 | *p++ = *sval; | |
236 | } | |
3d8df260 SK |
237 | *cp = j; |
238 | if (*sval) | |
239 | sval++; | |
240 | } | |
241 | return p; | |
242 | } | |
243 | ||
9e4abcb5 | 244 | /* for use during startup */ |
0a852541 | 245 | void *safe_malloc(size_t size) |
9e4abcb5 SK |
246 | { |
247 | void *ret = malloc(size); | |
248 | ||
249 | if (!ret) | |
5aabfc78 | 250 | die(_("could not get memory"), NULL, EC_NOMEM); |
9e4abcb5 SK |
251 | |
252 | return ret; | |
3d8df260 | 253 | } |
9e4abcb5 | 254 | |
1a6bca81 SK |
255 | void safe_pipe(int *fd, int read_noblock) |
256 | { | |
257 | if (pipe(fd) == -1 || | |
258 | !fix_fd(fd[1]) || | |
259 | (read_noblock && !fix_fd(fd[0]))) | |
260 | die(_("cannot create pipe: %s"), NULL, EC_MISC); | |
261 | } | |
262 | ||
5aabfc78 SK |
263 | void *whine_malloc(size_t size) |
264 | { | |
265 | void *ret = malloc(size); | |
266 | ||
267 | if (!ret) | |
268 | my_syslog(LOG_ERR, _("failed to allocate %d bytes"), (int) size); | |
269 | ||
270 | return ret; | |
271 | } | |
272 | ||
9e4abcb5 SK |
273 | int sockaddr_isequal(union mysockaddr *s1, union mysockaddr *s2) |
274 | { | |
275 | if (s1->sa.sa_family == s2->sa.sa_family) | |
276 | { | |
277 | if (s1->sa.sa_family == AF_INET && | |
278 | s1->in.sin_port == s2->in.sin_port && | |
5e9e0efb | 279 | s1->in.sin_addr.s_addr == s2->in.sin_addr.s_addr) |
9e4abcb5 SK |
280 | return 1; |
281 | #ifdef HAVE_IPV6 | |
282 | if (s1->sa.sa_family == AF_INET6 && | |
283 | s1->in6.sin6_port == s2->in6.sin6_port && | |
39341559 | 284 | s1->in6.sin6_scope_id == s2->in6.sin6_scope_id && |
5e9e0efb | 285 | IN6_ARE_ADDR_EQUAL(&s1->in6.sin6_addr, &s2->in6.sin6_addr)) |
9e4abcb5 SK |
286 | return 1; |
287 | #endif | |
288 | } | |
289 | return 0; | |
290 | } | |
291 | ||
292 | int sa_len(union mysockaddr *addr) | |
293 | { | |
294 | #ifdef HAVE_SOCKADDR_SA_LEN | |
295 | return addr->sa.sa_len; | |
296 | #else | |
297 | #ifdef HAVE_IPV6 | |
298 | if (addr->sa.sa_family == AF_INET6) | |
299 | return sizeof(addr->in6); | |
300 | else | |
301 | #endif | |
302 | return sizeof(addr->in); | |
303 | #endif | |
304 | } | |
305 | ||
306 | /* don't use strcasecmp and friends here - they may be messed up by LOCALE */ | |
c99df938 | 307 | int hostname_isequal(const char *a, const char *b) |
9e4abcb5 SK |
308 | { |
309 | unsigned int c1, c2; | |
310 | ||
311 | do { | |
3d8df260 SK |
312 | c1 = (unsigned char) *a++; |
313 | c2 = (unsigned char) *b++; | |
9e4abcb5 SK |
314 | |
315 | if (c1 >= 'A' && c1 <= 'Z') | |
316 | c1 += 'a' - 'A'; | |
317 | if (c2 >= 'A' && c2 <= 'Z') | |
318 | c2 += 'a' - 'A'; | |
319 | ||
320 | if (c1 != c2) | |
321 | return 0; | |
322 | } while (c1); | |
323 | ||
324 | return 1; | |
325 | } | |
326 | ||
5e9e0efb | 327 | time_t dnsmasq_time(void) |
44a2a316 SK |
328 | { |
329 | #ifdef HAVE_BROKEN_RTC | |
5e9e0efb SK |
330 | struct tms dummy; |
331 | static long tps = 0; | |
332 | ||
333 | if (tps == 0) | |
334 | tps = sysconf(_SC_CLK_TCK); | |
335 | ||
336 | return (time_t)(times(&dummy)/tps); | |
44a2a316 | 337 | #else |
44a2a316 SK |
338 | return time(NULL); |
339 | #endif | |
340 | } | |
a84fa1d0 | 341 | |
dc8a1b1b LPC |
342 | int netmask_length(struct in_addr mask) |
343 | { | |
344 | int zero_count = 0; | |
345 | ||
6d8e8ac0 SK |
346 | while (0x0 == (mask.s_addr & 0x1) && zero_count < 32) |
347 | { | |
348 | mask.s_addr >>= 1; | |
349 | zero_count++; | |
350 | } | |
351 | ||
dc8a1b1b LPC |
352 | return 32 - zero_count; |
353 | } | |
354 | ||
a84fa1d0 SK |
355 | int is_same_net(struct in_addr a, struct in_addr b, struct in_addr mask) |
356 | { | |
357 | return (a.s_addr & mask.s_addr) == (b.s_addr & mask.s_addr); | |
358 | } | |
fd9fa481 | 359 | |
c72daea8 SK |
360 | #ifdef HAVE_IPV6 |
361 | int is_same_net6(struct in6_addr *a, struct in6_addr *b, int prefixlen) | |
362 | { | |
363 | int pfbytes = prefixlen >> 3; | |
364 | int pfbits = prefixlen & 7; | |
365 | ||
366 | if (memcmp(&a->s6_addr, &b->s6_addr, pfbytes) != 0) | |
367 | return 0; | |
368 | ||
369 | if (pfbits == 0 || | |
c64b7f6a | 370 | (a->s6_addr[pfbytes] >> (8 - pfbits) == b->s6_addr[pfbytes] >> (8 - pfbits))) |
c72daea8 SK |
371 | return 1; |
372 | ||
373 | return 0; | |
374 | } | |
375 | ||
52b92f4d SK |
376 | /* return least signigicant 64 bits if IPv6 address */ |
377 | u64 addr6part(struct in6_addr *addr) | |
378 | { | |
379 | int i; | |
380 | u64 ret = 0; | |
381 | ||
382 | for (i = 8; i < 16; i++) | |
383 | ret = (ret << 8) + addr->s6_addr[i]; | |
384 | ||
385 | return ret; | |
386 | } | |
387 | ||
388 | void setaddr6part(struct in6_addr *addr, u64 host) | |
389 | { | |
390 | int i; | |
391 | ||
392 | for (i = 15; i >= 8; i--) | |
393 | { | |
394 | addr->s6_addr[i] = host; | |
395 | host = host >> 8; | |
396 | } | |
397 | } | |
398 | ||
c72daea8 SK |
399 | #endif |
400 | ||
401 | ||
3d8df260 SK |
402 | /* returns port number from address */ |
403 | int prettyprint_addr(union mysockaddr *addr, char *buf) | |
404 | { | |
405 | int port = 0; | |
406 | ||
407 | #ifdef HAVE_IPV6 | |
408 | if (addr->sa.sa_family == AF_INET) | |
409 | { | |
410 | inet_ntop(AF_INET, &addr->in.sin_addr, buf, ADDRSTRLEN); | |
411 | port = ntohs(addr->in.sin_port); | |
412 | } | |
413 | else if (addr->sa.sa_family == AF_INET6) | |
414 | { | |
7de060b0 | 415 | char name[IF_NAMESIZE]; |
3d8df260 | 416 | inet_ntop(AF_INET6, &addr->in6.sin6_addr, buf, ADDRSTRLEN); |
7de060b0 SK |
417 | if (addr->in6.sin6_scope_id != 0 && |
418 | if_indextoname(addr->in6.sin6_scope_id, name) && | |
419 | strlen(buf) + strlen(name) + 2 <= ADDRSTRLEN) | |
420 | { | |
421 | strcat(buf, "%"); | |
422 | strcat(buf, name); | |
423 | } | |
3d8df260 SK |
424 | port = ntohs(addr->in6.sin6_port); |
425 | } | |
426 | #else | |
427 | strcpy(buf, inet_ntoa(addr->in.sin_addr)); | |
428 | port = ntohs(addr->in.sin_port); | |
429 | #endif | |
430 | ||
431 | return port; | |
432 | } | |
433 | ||
0a852541 SK |
434 | void prettyprint_time(char *buf, unsigned int t) |
435 | { | |
436 | if (t == 0xffffffff) | |
b8187c80 | 437 | sprintf(buf, _("infinite")); |
0a852541 SK |
438 | else |
439 | { | |
440 | unsigned int x, p = 0; | |
3d8df260 SK |
441 | if ((x = t/86400)) |
442 | p += sprintf(&buf[p], "%dd", x); | |
443 | if ((x = (t/3600)%24)) | |
0a852541 SK |
444 | p += sprintf(&buf[p], "%dh", x); |
445 | if ((x = (t/60)%60)) | |
446 | p += sprintf(&buf[p], "%dm", x); | |
447 | if ((x = t%60)) | |
448 | p += sprintf(&buf[p], "%ds", x); | |
449 | } | |
450 | } | |
451 | ||
452 | ||
28866e95 SK |
453 | /* in may equal out, when maxlen may be -1 (No max len). |
454 | Return -1 for extraneous no-hex chars found. */ | |
cdeda28f SK |
455 | int parse_hex(char *in, unsigned char *out, int maxlen, |
456 | unsigned int *wildcard_mask, int *mac_type) | |
0a852541 SK |
457 | { |
458 | int mask = 0, i = 0; | |
459 | char *r; | |
cdeda28f SK |
460 | |
461 | if (mac_type) | |
462 | *mac_type = 0; | |
463 | ||
0a852541 SK |
464 | while (maxlen == -1 || i < maxlen) |
465 | { | |
9f7f3b12 | 466 | for (r = in; *r != 0 && *r != ':' && *r != '-' && *r != ' '; r++) |
572b41eb | 467 | if (*r != '*' && !isxdigit((unsigned char)*r)) |
28866e95 SK |
468 | return -1; |
469 | ||
0a852541 SK |
470 | if (*r == 0) |
471 | maxlen = i; | |
cdeda28f | 472 | |
0a852541 SK |
473 | if (r != in ) |
474 | { | |
cdeda28f SK |
475 | if (*r == '-' && i == 0 && mac_type) |
476 | { | |
477 | *r = 0; | |
478 | *mac_type = strtol(in, NULL, 16); | |
479 | mac_type = NULL; | |
480 | } | |
0a852541 | 481 | else |
cdeda28f SK |
482 | { |
483 | *r = 0; | |
cdeda28f | 484 | if (strcmp(in, "*") == 0) |
9f7f3b12 SK |
485 | { |
486 | mask = (mask << 1) | 1; | |
487 | i++; | |
488 | } | |
cdeda28f | 489 | else |
9f7f3b12 SK |
490 | { |
491 | int j, bytes = (1 + (r - in))/2; | |
492 | for (j = 0; j < bytes; j++) | |
493 | { | |
50db3492 | 494 | char sav = sav; |
9f7f3b12 SK |
495 | if (j < bytes - 1) |
496 | { | |
497 | sav = in[(j+1)*2]; | |
498 | in[(j+1)*2] = 0; | |
499 | } | |
500 | out[i] = strtol(&in[j*2], NULL, 16); | |
501 | mask = mask << 1; | |
502 | i++; | |
503 | if (j < bytes - 1) | |
504 | in[(j+1)*2] = sav; | |
505 | } | |
506 | } | |
cdeda28f | 507 | } |
0a852541 SK |
508 | } |
509 | in = r+1; | |
510 | } | |
511 | ||
512 | if (wildcard_mask) | |
513 | *wildcard_mask = mask; | |
514 | ||
515 | return i; | |
516 | } | |
5e9e0efb | 517 | |
7622fc06 | 518 | /* return 0 for no match, or (no matched octets) + 1 */ |
5e9e0efb SK |
519 | int memcmp_masked(unsigned char *a, unsigned char *b, int len, unsigned int mask) |
520 | { | |
7622fc06 SK |
521 | int i, count; |
522 | for (count = 1, i = len - 1; i >= 0; i--, mask = mask >> 1) | |
523 | if (!(mask & 1)) | |
524 | { | |
525 | if (a[i] == b[i]) | |
526 | count++; | |
527 | else | |
528 | return 0; | |
529 | } | |
530 | return count; | |
5e9e0efb SK |
531 | } |
532 | ||
533 | /* _note_ may copy buffer */ | |
534 | int expand_buf(struct iovec *iov, size_t size) | |
535 | { | |
536 | void *new; | |
537 | ||
824af85b | 538 | if (size <= (size_t)iov->iov_len) |
5e9e0efb SK |
539 | return 1; |
540 | ||
5aabfc78 | 541 | if (!(new = whine_malloc(size))) |
5e9e0efb SK |
542 | { |
543 | errno = ENOMEM; | |
544 | return 0; | |
545 | } | |
546 | ||
547 | if (iov->iov_base) | |
548 | { | |
549 | memcpy(new, iov->iov_base, iov->iov_len); | |
550 | free(iov->iov_base); | |
551 | } | |
552 | ||
553 | iov->iov_base = new; | |
554 | iov->iov_len = size; | |
555 | ||
556 | return 1; | |
557 | } | |
7cebd20f | 558 | |
5aabfc78 | 559 | char *print_mac(char *buff, unsigned char *mac, int len) |
7cebd20f | 560 | { |
5aabfc78 | 561 | char *p = buff; |
7cebd20f SK |
562 | int i; |
563 | ||
564 | if (len == 0) | |
565 | sprintf(p, "<null>"); | |
566 | else | |
567 | for (i = 0; i < len; i++) | |
568 | p += sprintf(p, "%.2x%s", mac[i], (i == len - 1) ? "" : ":"); | |
569 | ||
5aabfc78 | 570 | return buff; |
7cebd20f | 571 | } |
1697269c | 572 | |
ff841ebf SK |
573 | /* rc is return from sendto and friends. |
574 | Return 1 if we should retry. | |
575 | Set errno to zero if we succeeded. */ | |
576 | int retry_send(ssize_t rc) | |
5aabfc78 | 577 | { |
ff841ebf SK |
578 | static int retries = 0; |
579 | struct timespec waiter; | |
580 | ||
581 | if (rc != -1) | |
582 | { | |
583 | retries = 0; | |
584 | errno = 0; | |
585 | return 0; | |
586 | } | |
587 | ||
5782649a SK |
588 | /* Linux kernels can return EAGAIN in perpetuity when calling |
589 | sendmsg() and the relevant interface has gone. Here we loop | |
590 | retrying in EAGAIN for 1 second max, to avoid this hanging | |
591 | dnsmasq. */ | |
592 | ||
ff841ebf | 593 | if (errno == EAGAIN || errno == EWOULDBLOCK) |
5aabfc78 SK |
594 | { |
595 | waiter.tv_sec = 0; | |
596 | waiter.tv_nsec = 10000; | |
597 | nanosleep(&waiter, NULL); | |
5782649a SK |
598 | if (retries++ < 1000) |
599 | return 1; | |
5aabfc78 | 600 | } |
ff841ebf SK |
601 | |
602 | retries = 0; | |
603 | ||
604 | if (errno == EINTR) | |
605 | return 1; | |
606 | ||
607 | return 0; | |
5aabfc78 SK |
608 | } |
609 | ||
1697269c SK |
610 | int read_write(int fd, unsigned char *packet, int size, int rw) |
611 | { | |
612 | ssize_t n, done; | |
613 | ||
614 | for (done = 0; done < size; done += n) | |
615 | { | |
ff841ebf SK |
616 | do { |
617 | if (rw) | |
618 | n = read(fd, &packet[done], (size_t)(size - done)); | |
619 | else | |
620 | n = write(fd, &packet[done], (size_t)(size - done)); | |
621 | ||
622 | if (n == 0) | |
623 | return 0; | |
624 | ||
625 | } while (retry_send(n) || errno == ENOMEM || errno == ENOBUFS); | |
626 | ||
627 | if (errno != 0) | |
628 | return 0; | |
1697269c | 629 | } |
ff841ebf | 630 | |
1697269c SK |
631 | return 1; |
632 | } | |
1a6bca81 | 633 | |
49333cbd SK |
634 | /* Basically match a string value against a wildcard pattern. */ |
635 | int wildcard_match(const char* wildcard, const char* match) | |
636 | { | |
637 | while (*wildcard && *match) | |
638 | { | |
639 | if (*wildcard == '*') | |
640 | return 1; | |
641 | ||
642 | if (*wildcard != *match) | |
643 | return 0; | |
644 | ||
645 | ++wildcard; | |
646 | ++match; | |
647 | } | |
648 | ||
649 | return *wildcard == *match; | |
650 | } | |
70772c90 NJ |
651 | |
652 | /* The same but comparing a maximum of NUM characters, like strncmp. */ | |
653 | int wildcard_matchn(const char* wildcard, const char* match, int num) | |
654 | { | |
655 | while (*wildcard && *match && num) | |
656 | { | |
657 | if (*wildcard == '*') | |
658 | return 1; | |
659 | ||
660 | if (*wildcard != *match) | |
661 | return 0; | |
662 | ||
663 | ++wildcard; | |
664 | ++match; | |
665 | --num; | |
666 | } | |
667 | ||
668 | return (!num) || (*wildcard == *match); | |
669 | } |