1: /* dnsmasq is Copyright (c) 2000-2022 Simon Kelley
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
5: the Free Software Foundation; version 2 dated June, 1991, or
6: (at your option) version 3 dated 29 June, 2007.
7:
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.
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/>.
15: */
16:
17: #include "dnsmasq.h"
18:
19: static int order(char *qdomain, size_t qlen, struct server *serv);
20: static int order_qsort(const void *a, const void *b);
21: static int order_servers(struct server *s, struct server *s2);
22:
23: /* If the server is USE_RESOLV or LITERAL_ADDRES, it lives on the local_domains chain. */
24: #define SERV_IS_LOCAL (SERV_USE_RESOLV | SERV_LITERAL_ADDRESS)
25:
26: void build_server_array(void)
27: {
28: struct server *serv;
29: int count = 0;
30:
31: for (serv = daemon->servers; serv; serv = serv->next)
32: #ifdef HAVE_LOOP
33: if (!(serv->flags & SERV_LOOP))
34: #endif
35: {
36: count++;
37: if (serv->flags & SERV_WILDCARD)
38: daemon->server_has_wildcard = 1;
39: }
40:
41: for (serv = daemon->local_domains; serv; serv = serv->next)
42: {
43: count++;
44: if (serv->flags & SERV_WILDCARD)
45: daemon->server_has_wildcard = 1;
46: }
47:
48: daemon->serverarraysz = count;
49:
50: if (count > daemon->serverarrayhwm)
51: {
52: struct server **new;
53:
54: count += 10; /* A few extra without re-allocating. */
55:
56: if ((new = whine_malloc(count * sizeof(struct server *))))
57: {
58: if (daemon->serverarray)
59: free(daemon->serverarray);
60:
61: daemon->serverarray = new;
62: daemon->serverarrayhwm = count;
63: }
64: }
65:
66: count = 0;
67:
68: for (serv = daemon->servers; serv; serv = serv->next)
69: #ifdef HAVE_LOOP
70: if (!(serv->flags & SERV_LOOP))
71: #endif
72: {
73: daemon->serverarray[count] = serv;
74: serv->serial = count;
75: serv->last_server = -1;
76: count++;
77: }
78:
79: for (serv = daemon->local_domains; serv; serv = serv->next, count++)
80: daemon->serverarray[count] = serv;
81:
82: qsort(daemon->serverarray, daemon->serverarraysz, sizeof(struct server *), order_qsort);
83:
84: /* servers need the location in the array to find all the whole
85: set of equivalent servers from a pointer to a single one. */
86: for (count = 0; count < daemon->serverarraysz; count++)
87: if (!(daemon->serverarray[count]->flags & SERV_IS_LOCAL))
88: daemon->serverarray[count]->arrayposn = count;
89: }
90:
91: /* we're looking for the server whose domain is the longest exact match
92: to the RH end of qdomain, or a local address if the flags match.
93: Add '.' to the LHS of the query string so
94: server=/.example.com/ works.
95:
96: A flag of F_SERVER returns an upstream server only.
97: A flag of F_DNSSECOK returns a DNSSEC capable server only and
98: also disables NODOTS servers from consideration.
99: A flag of F_DOMAINSRV returns a domain-specific server only.
100: A flag of F_CONFIG returns anything that generates a local
101: reply of IPv4 or IPV6.
102: return 0 if nothing found, 1 otherwise.
103: */
104: int lookup_domain(char *domain, int flags, int *lowout, int *highout)
105: {
106: int rc, crop_query, nodots;
107: ssize_t qlen;
108: int try, high, low = 0;
109: int nlow = 0, nhigh = 0;
110: char *cp, *qdomain = domain;
111:
112: /* may be no configured servers. */
113: if (daemon->serverarraysz == 0)
114: return 0;
115:
116: /* find query length and presence of '.' */
117: for (cp = qdomain, nodots = 1, qlen = 0; *cp; qlen++, cp++)
118: if (*cp == '.')
119: nodots = 0;
120:
121: /* Handle empty name, and searches for DNSSEC queries without
122: diverting to NODOTS servers. */
123: if (qlen == 0 || flags & F_DNSSECOK)
124: nodots = 0;
125:
126: /* Search shorter and shorter RHS substrings for a match */
127: while (qlen >= 0)
128: {
129: /* Note that when we chop off a label, all the possible matches
130: MUST be at a larger index than the nearest failing match with one more
131: character, since the array is sorted longest to smallest. Hence
132: we don't reset low to zero here, we can go further below and crop the
133: search string to the size of the largest remaining server
134: when this match fails. */
135: high = daemon->serverarraysz;
136: crop_query = 1;
137:
138: /* binary search */
139: while (1)
140: {
141: try = (low + high)/2;
142:
143: if ((rc = order(qdomain, qlen, daemon->serverarray[try])) == 0)
144: break;
145:
146: if (rc < 0)
147: {
148: if (high == try)
149: {
150: /* qdomain is longer or same length as longest domain, and try == 0
151: crop the query to the longest domain. */
152: crop_query = qlen - daemon->serverarray[try]->domain_len;
153: break;
154: }
155: high = try;
156: }
157: else
158: {
159: if (low == try)
160: {
161: /* try now points to the last domain that sorts before the query, so
162: we know that a substring of the query shorter than it is required to match, so
163: find the largest domain that's shorter than try. Note that just going to
164: try+1 is not optimal, consider searching bbb in (aaa,ccc,bb). try will point
165: to aaa, since ccc sorts after bbb, but the first domain that has a chance to
166: match is bb. So find the length of the first domain later than try which is
167: is shorter than it.
168: There's a nasty edge case when qdomain sorts before _any_ of the
169: server domains, where try _doesn't point_ to the last domain that sorts
170: before the query, since no such domain exists. In that case, the loop
171: exits via the rc < 0 && high == try path above and this code is
172: not executed. */
173: ssize_t len, old = daemon->serverarray[try]->domain_len;
174: while (++try != daemon->serverarraysz)
175: {
176: if (old != (len = daemon->serverarray[try]->domain_len))
177: {
178: crop_query = qlen - len;
179: break;
180: }
181: }
182: break;
183: }
184: low = try;
185: }
186: };
187:
188: if (rc == 0)
189: {
190: int found = 1;
191:
192: if (daemon->server_has_wildcard)
193: {
194: /* if we have example.com and *example.com we need to check against *example.com,
195: but the binary search may have found either. Use the fact that example.com is sorted before *example.com
196: We favour example.com in the case that both match (ie www.example.com) */
197: while (try != 0 && order(qdomain, qlen, daemon->serverarray[try-1]) == 0)
198: try--;
199:
200: if (!(qdomain == domain || *qdomain == 0 || *(qdomain-1) == '.'))
201: {
202: while (try < daemon->serverarraysz-1 && order(qdomain, qlen, daemon->serverarray[try+1]) == 0)
203: try++;
204:
205: if (!(daemon->serverarray[try]->flags & SERV_WILDCARD))
206: found = 0;
207: }
208: }
209:
210: if (found && filter_servers(try, flags, &nlow, &nhigh))
211: /* We have a match, but it may only be (say) an IPv6 address, and
212: if the query wasn't for an AAAA record, it's no good, and we need
213: to continue generalising */
214: {
215: /* We've matched a setting which says to use servers without a domain.
216: Continue the search with empty query. We set the F_SERVER flag
217: so that --address=/#/... doesn't match. */
218: if (daemon->serverarray[nlow]->flags & SERV_USE_RESOLV)
219: {
220: crop_query = qlen;
221: flags |= F_SERVER;
222: }
223: else
224: break;
225: }
226: }
227:
228: /* crop_query must be at least one always. */
229: if (crop_query == 0)
230: crop_query = 1;
231:
232: /* strip chars off the query based on the largest possible remaining match,
233: then continue to the start of the next label unless we have a wildcard
234: domain somewhere, in which case we have to go one at a time. */
235: qlen -= crop_query;
236: qdomain += crop_query;
237: if (!daemon->server_has_wildcard)
238: while (qlen > 0 && (*(qdomain-1) != '.'))
239: qlen--, qdomain++;
240: }
241:
242: /* domain has no dots, and we have at least one server configured to handle such,
243: These servers always sort to the very end of the array.
244: A configured server eg server=/lan/ will take precdence. */
245: if (nodots &&
246: (daemon->serverarray[daemon->serverarraysz-1]->flags & SERV_FOR_NODOTS) &&
247: (nlow == nhigh || daemon->serverarray[nlow]->domain_len == 0))
248: filter_servers(daemon->serverarraysz-1, flags, &nlow, &nhigh);
249:
250: if (lowout)
251: *lowout = nlow;
252:
253: if (highout)
254: *highout = nhigh;
255:
256: /* qlen == -1 when we failed to match even an empty query, if there are no default servers. */
257: if (nlow == nhigh || qlen == -1)
258: return 0;
259:
260: return 1;
261: }
262:
263: /* Return first server in group of equivalent servers; this is the "master" record. */
264: int server_samegroup(struct server *a, struct server *b)
265: {
266: return order_servers(a, b) == 0;
267: }
268:
269: int filter_servers(int seed, int flags, int *lowout, int *highout)
270: {
271: int nlow = seed, nhigh = seed;
272: int i;
273:
274: /* expand nlow and nhigh to cover all the records with the same domain
275: nlow is the first, nhigh - 1 is the last. nlow=nhigh means no servers,
276: which can happen below. */
277: while (nlow > 0 && order_servers(daemon->serverarray[nlow-1], daemon->serverarray[nlow]) == 0)
278: nlow--;
279:
280: while (nhigh < daemon->serverarraysz-1 && order_servers(daemon->serverarray[nhigh], daemon->serverarray[nhigh+1]) == 0)
281: nhigh++;
282:
283: nhigh++;
284:
285: #define SERV_LOCAL_ADDRESS (SERV_6ADDR | SERV_4ADDR | SERV_ALL_ZEROS)
286:
287: if (flags & F_CONFIG)
288: {
289: /* We're just lookin for any matches that return an RR. */
290: for (i = nlow; i < nhigh; i++)
291: if (daemon->serverarray[i]->flags & SERV_LOCAL_ADDRESS)
292: break;
293:
294: /* failed, return failure. */
295: if (i == nhigh)
296: nhigh = nlow;
297: }
298: else
299: {
300: /* Now the servers are on order between low and high, in the order
301: IPv6 addr, IPv4 addr, return zero for both, resolvconf servers, send upstream, no-data return.
302:
303: See which of those match our query in that priority order and narrow (low, high) */
304:
305: for (i = nlow; i < nhigh && (daemon->serverarray[i]->flags & SERV_6ADDR); i++);
306:
307: if (!(flags & F_SERVER) && i != nlow && (flags & F_IPV6))
308: nhigh = i;
309: else
310: {
311: nlow = i;
312:
313: for (i = nlow; i < nhigh && (daemon->serverarray[i]->flags & SERV_4ADDR); i++);
314:
315: if (!(flags & F_SERVER) && i != nlow && (flags & F_IPV4))
316: nhigh = i;
317: else
318: {
319: nlow = i;
320:
321: for (i = nlow; i < nhigh && (daemon->serverarray[i]->flags & SERV_ALL_ZEROS); i++);
322:
323: if (!(flags & F_SERVER) && i != nlow && (flags & (F_IPV4 | F_IPV6)))
324: nhigh = i;
325: else
326: {
327: nlow = i;
328:
329: /* Short to resolv.conf servers */
330: for (i = nlow; i < nhigh && (daemon->serverarray[i]->flags & SERV_USE_RESOLV); i++);
331:
332: if (i != nlow)
333: nhigh = i;
334: else
335: {
336: /* now look for a server */
337: for (i = nlow; i < nhigh && !(daemon->serverarray[i]->flags & SERV_LITERAL_ADDRESS); i++);
338:
339: if (i != nlow)
340: {
341: /* If we want a server that can do DNSSEC, and this one can't,
342: return nothing, similarly if were looking only for a server
343: for a particular domain. */
344: if ((flags & F_DNSSECOK) && !(daemon->serverarray[nlow]->flags & SERV_DO_DNSSEC))
345: nlow = nhigh;
346: else if ((flags & F_DOMAINSRV) && daemon->serverarray[nlow]->domain_len == 0)
347: nlow = nhigh;
348: else
349: nhigh = i;
350: }
351: else
352: {
353: /* --local=/domain/, only return if we don't need a server. */
354: if (flags & (F_DNSSECOK | F_DOMAINSRV | F_SERVER))
355: nhigh = i;
356: }
357: }
358: }
359: }
360: }
361: }
362:
363: *lowout = nlow;
364: *highout = nhigh;
365:
366: return (nlow != nhigh);
367: }
368:
369: int is_local_answer(time_t now, int first, char *name)
370: {
371: int flags = 0;
372: int rc = 0;
373:
374: if ((flags = daemon->serverarray[first]->flags) & SERV_LITERAL_ADDRESS)
375: {
376: if (flags & SERV_4ADDR)
377: rc = F_IPV4;
378: else if (flags & SERV_6ADDR)
379: rc = F_IPV6;
380: else if (flags & SERV_ALL_ZEROS)
381: rc = F_IPV4 | F_IPV6;
382: else
383: {
384: /* argument first is the first struct server which matches the query type;
385: now roll back to the server which is just the same domain, to check if that
386: provides an answer of a different type. */
387:
388: for (;first > 0 && order_servers(daemon->serverarray[first-1], daemon->serverarray[first]) == 0; first--);
389:
390: if ((daemon->serverarray[first]->flags & SERV_LOCAL_ADDRESS) ||
391: check_for_local_domain(name, now))
392: rc = F_NOERR;
393: else
394: rc = F_NXDOMAIN;
395: }
396: }
397:
398: return rc;
399: }
400:
401: size_t make_local_answer(int flags, int gotname, size_t size, struct dns_header *header, char *name, char *limit, int first, int last, int ede)
402: {
403: int trunc = 0, anscount = 0;
404: unsigned char *p;
405: int start;
406: union all_addr addr;
407:
408: if (flags & (F_NXDOMAIN | F_NOERR))
409: log_query(flags | gotname | F_NEG | F_CONFIG | F_FORWARD, name, NULL, NULL, 0);
410:
411: setup_reply(header, flags, ede);
412:
413: if (!(p = skip_questions(header, size)))
414: return 0;
415:
416: if (flags & gotname & F_IPV4)
417: for (start = first; start != last; start++)
418: {
419: struct serv_addr4 *srv = (struct serv_addr4 *)daemon->serverarray[start];
420:
421: if (srv->flags & SERV_ALL_ZEROS)
422: memset(&addr, 0, sizeof(addr));
423: else
424: addr.addr4 = srv->addr;
425:
426: if (add_resource_record(header, limit, &trunc, sizeof(struct dns_header), &p, daemon->local_ttl, NULL, T_A, C_IN, "4", &addr))
427: anscount++;
428: log_query((flags | F_CONFIG | F_FORWARD) & ~F_IPV6, name, (union all_addr *)&addr, NULL, 0);
429: }
430:
431: if (flags & gotname & F_IPV6)
432: for (start = first; start != last; start++)
433: {
434: struct serv_addr6 *srv = (struct serv_addr6 *)daemon->serverarray[start];
435:
436: if (srv->flags & SERV_ALL_ZEROS)
437: memset(&addr, 0, sizeof(addr));
438: else
439: addr.addr6 = srv->addr;
440:
441: if (add_resource_record(header, limit, &trunc, sizeof(struct dns_header), &p, daemon->local_ttl, NULL, T_AAAA, C_IN, "6", &addr))
442: anscount++;
443: log_query((flags | F_CONFIG | F_FORWARD) & ~F_IPV4, name, (union all_addr *)&addr, NULL, 0);
444: }
445:
446: if (trunc)
447: header->hb3 |= HB3_TC;
448: header->ancount = htons(anscount);
449:
450: return p - (unsigned char *)header;
451: }
452:
453: #ifdef HAVE_DNSSEC
454: int dnssec_server(struct server *server, char *keyname, int *firstp, int *lastp)
455: {
456: int first, last, index;
457:
458: /* Find server to send DNSSEC query to. This will normally be the
459: same as for the original query, but may be another if
460: servers for domains are involved. */
461: if (!lookup_domain(keyname, F_DNSSECOK, &first, &last))
462: return -1;
463:
464: for (index = first; index != last; index++)
465: if (daemon->serverarray[index] == server)
466: break;
467:
468: /* No match to server used for original query.
469: Use newly looked up set. */
470: if (index == last)
471: index = daemon->serverarray[first]->last_server == -1 ?
472: first : daemon->serverarray[first]->last_server;
473:
474: if (firstp)
475: *firstp = first;
476:
477: if (lastp)
478: *lastp = last;
479:
480: return index;
481: }
482: #endif
483:
484: /* order by size, then by dictionary order */
485: static int order(char *qdomain, size_t qlen, struct server *serv)
486: {
487: size_t dlen = 0;
488:
489: /* servers for dotless names always sort last
490: searched for name is never dotless. */
491: if (serv->flags & SERV_FOR_NODOTS)
492: return -1;
493:
494: dlen = serv->domain_len;
495:
496: if (qlen < dlen)
497: return 1;
498:
499: if (qlen > dlen)
500: return -1;
501:
502: return hostname_order(qdomain, serv->domain);
503: }
504:
505: static int order_servers(struct server *s1, struct server *s2)
506: {
507: int rc;
508:
509: /* need full comparison of dotless servers in
510: order_qsort() and filter_servers() */
511:
512: if (s1->flags & SERV_FOR_NODOTS)
513: return (s2->flags & SERV_FOR_NODOTS) ? 0 : 1;
514:
515: if ((rc = order(s1->domain, s1->domain_len, s2)) != 0)
516: return rc;
517:
518: /* For identical domains, sort wildcard ones first */
519: if (s1->flags & SERV_WILDCARD)
520: return (s2->flags & SERV_WILDCARD) ? 0 : 1;
521:
522: return (s2->flags & SERV_WILDCARD) ? -1 : 0;
523: }
524:
525: static int order_qsort(const void *a, const void *b)
526: {
527: int rc;
528:
529: struct server *s1 = *((struct server **)a);
530: struct server *s2 = *((struct server **)b);
531:
532: rc = order_servers(s1, s2);
533:
534: /* Sort all literal NODATA and local IPV4 or IPV6 responses together,
535: in a very specific order. We flip the SERV_LITERAL_ADDRESS bit
536: so the order is IPv6 literal, IPv4 literal, all-zero literal,
537: unqualified servers, upstream server, NXDOMAIN literal. */
538: if (rc == 0)
539: rc = ((s2->flags & (SERV_LITERAL_ADDRESS | SERV_4ADDR | SERV_6ADDR | SERV_USE_RESOLV | SERV_ALL_ZEROS)) ^ SERV_LITERAL_ADDRESS) -
540: ((s1->flags & (SERV_LITERAL_ADDRESS | SERV_4ADDR | SERV_6ADDR | SERV_USE_RESOLV | SERV_ALL_ZEROS)) ^ SERV_LITERAL_ADDRESS);
541:
542: /* Finally, order by appearance in /etc/resolv.conf etc, for --strict-order */
543: if (rc == 0)
544: if (!(s1->flags & SERV_LITERAL_ADDRESS))
545: rc = s1->serial - s2->serial;
546:
547: return rc;
548: }
549:
550:
551: /* When loading large numbers of server=.... lines during startup,
552: there's no possibility that there will be server records that can be reused, but
553: searching a long list for each server added grows as O(n^2) and slows things down.
554: This flag is set only if is known there may be free server records that can be reused.
555: There's a call to mark_servers(0) in read_opts() to reset the flag before
556: main config read. */
557:
558: static int maybe_free_servers = 0;
559:
560: /* Must be called before add_update_server() to set daemon->servers_tail */
561: void mark_servers(int flag)
562: {
563: struct server *serv, *next, **up;
564:
565: maybe_free_servers = !!flag;
566:
567: daemon->servers_tail = NULL;
568:
569: /* mark everything with argument flag */
570: for (serv = daemon->servers; serv; serv = serv->next)
571: {
572: if (serv->flags & flag)
573: serv->flags |= SERV_MARK;
574: else
575: serv->flags &= ~SERV_MARK;
576:
577: daemon->servers_tail = serv;
578: }
579:
580: /* --address etc is different: since they are expected to be
581: 1) numerous and 2) not reloaded often. We just delete
582: and recreate. */
583: if (flag)
584: for (serv = daemon->local_domains, up = &daemon->local_domains; serv; serv = next)
585: {
586: next = serv->next;
587:
588: if (serv->flags & flag)
589: {
590: *up = next;
591: free(serv->domain);
592: free(serv);
593: }
594: else
595: up = &serv->next;
596: }
597: }
598:
599: void cleanup_servers(void)
600: {
601: struct server *serv, *tmp, **up;
602:
603: /* unlink and free anything still marked. */
604: for (serv = daemon->servers, up = &daemon->servers, daemon->servers_tail = NULL; serv; serv = tmp)
605: {
606: tmp = serv->next;
607: if (serv->flags & SERV_MARK)
608: {
609: server_gone(serv);
610: *up = serv->next;
611: free(serv->domain);
612: free(serv);
613: }
614: else
615: {
616: up = &serv->next;
617: daemon->servers_tail = serv;
618: }
619: }
620: }
621:
622: int add_update_server(int flags,
623: union mysockaddr *addr,
624: union mysockaddr *source_addr,
625: const char *interface,
626: const char *domain,
627: union all_addr *local_addr)
628: {
629: struct server *serv = NULL;
630: char *alloc_domain;
631:
632: if (!domain)
633: domain = "";
634:
635: /* .domain == domain, for historical reasons. */
636: if (*domain == '.')
637: while (*domain == '.') domain++;
638: else if (*domain == '*')
639: {
640: domain++;
641: if (*domain != 0)
642: flags |= SERV_WILDCARD;
643: }
644:
645: if (*domain == 0)
646: alloc_domain = whine_malloc(1);
647: else
648: alloc_domain = canonicalise((char *)domain, NULL);
649:
650: if (!alloc_domain)
651: return 0;
652:
653: if (flags & SERV_IS_LOCAL)
654: {
655: size_t size;
656:
657: if (flags & SERV_6ADDR)
658: size = sizeof(struct serv_addr6);
659: else if (flags & SERV_4ADDR)
660: size = sizeof(struct serv_addr4);
661: else
662: size = sizeof(struct serv_local);
663:
664: if (!(serv = whine_malloc(size)))
665: {
666: free(alloc_domain);
667: return 0;
668: }
669:
670: serv->next = daemon->local_domains;
671: daemon->local_domains = serv;
672:
673: if (flags & SERV_4ADDR)
674: ((struct serv_addr4*)serv)->addr = local_addr->addr4;
675:
676: if (flags & SERV_6ADDR)
677: ((struct serv_addr6*)serv)->addr = local_addr->addr6;
678: }
679: else
680: {
681: /* Upstream servers. See if there is a suitable candidate, if so unmark
682: and move to the end of the list, for order. The entry found may already
683: be at the end. */
684: struct server **up, *tmp;
685:
686: serv = NULL;
687:
688: if (maybe_free_servers)
689: for (serv = daemon->servers, up = &daemon->servers; serv; serv = tmp)
690: {
691: tmp = serv->next;
692: if ((serv->flags & SERV_MARK) &&
693: hostname_isequal(alloc_domain, serv->domain))
694: {
695: /* Need to move down? */
696: if (serv->next)
697: {
698: *up = serv->next;
699: daemon->servers_tail->next = serv;
700: daemon->servers_tail = serv;
701: serv->next = NULL;
702: }
703: break;
704: }
705: else
706: up = &serv->next;
707: }
708:
709: if (serv)
710: {
711: free(alloc_domain);
712: alloc_domain = serv->domain;
713: }
714: else
715: {
716: if (!(serv = whine_malloc(sizeof(struct server))))
717: {
718: free(alloc_domain);
719: return 0;
720: }
721:
722: memset(serv, 0, sizeof(struct server));
723:
724: /* Add to the end of the chain, for order */
725: if (daemon->servers_tail)
726: daemon->servers_tail->next = serv;
727: else
728: daemon->servers = serv;
729: daemon->servers_tail = serv;
730: }
731:
732: #ifdef HAVE_LOOP
733: serv->uid = rand32();
734: #endif
735:
736: if (interface)
737: safe_strncpy(serv->interface, interface, sizeof(serv->interface));
738: if (addr)
739: serv->addr = *addr;
740: if (source_addr)
741: serv->source_addr = *source_addr;
742: }
743:
744: serv->flags = flags;
745: serv->domain = alloc_domain;
746: serv->domain_len = strlen(alloc_domain);
747:
748: return 1;
749: }
750:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to domain-match.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dnsmasq / src