2e8968528b62d4087a1590b3b67fb551b5989bb0
[exim.git] / src / src / ip.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* Functions for doing things with sockets. With the advent of IPv6 this has
9 got messier, so that it's worth pulling out the code into separate functions
10 that other parts of Exim can call, especially as there are now several
11 different places in the code where sockets are used. */
12
13
14 #include "exim.h"
15
16
17 /*************************************************
18 *             Create a socket                    *
19 *************************************************/
20
21 /* Socket creation happens in a number of places so it's packaged here for
22 convenience.
23
24 Arguments:
25   type       SOCK_DGRAM or SOCK_STREAM
26   af         AF_INET or AF_INET6
27
28 Returns:     socket number or -1 on failure
29 */
30
31 int
32 ip_socket(int type, int af)
33 {
34 int sock = socket(af, type, 0);
35 if (sock < 0)
36   log_write(0, LOG_MAIN, "IPv%c socket creation failed: %s",
37     (af == AF_INET6)? '6':'4', strerror(errno));
38 return sock;
39 }
40
41
42
43
44 #if HAVE_IPV6
45 /*************************************************
46 *      Convert printing address to numeric       *
47 *************************************************/
48
49 /* This function converts the textual form of an IP address into a numeric form
50 in an appropriate structure in an IPv6 environment. The getaddrinfo() function
51 can (apparently) handle more complicated addresses (e.g. those containing
52 scopes) than inet_pton() in some environments. We use hints to tell it that the
53 input must be a numeric address.
54
55 However, apparently some operating systems (or libraries) don't support
56 getaddrinfo(), so there is a build-time option to revert to inet_pton() (which
57 does not support scopes).
58
59 Arguments:
60   address     textual form of the address
61   addr        where to copy back the answer
62
63 Returns:      nothing - failure provokes a panic-die
64 */
65
66 static void
67 ip_addrinfo(const uschar *address, struct sockaddr_in6 *saddr)
68 {
69 #ifdef IPV6_USE_INET_PTON
70
71   if (inet_pton(AF_INET6, CCS address, &saddr->sin6_addr) != 1)
72     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
73       "IP address", address);
74   saddr->sin6_family = AF_INET6;
75
76 #else
77
78   int rc;
79   struct addrinfo hints, *res;
80   memset(&hints, 0, sizeof(hints));
81   hints.ai_family = AF_INET6;
82   hints.ai_socktype = SOCK_STREAM;
83   hints.ai_flags = AI_NUMERICHOST;
84   if ((rc = getaddrinfo(CCS address, NULL, &hints, &res)) != 0 || res == NULL)
85     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
86       "IP address: %s", address,
87       (rc == 0)? "NULL result returned" : gai_strerror(rc));
88   memcpy(saddr, res->ai_addr, res->ai_addrlen);
89   freeaddrinfo(res);
90
91 #endif
92 }
93 #endif  /* HAVE_IPV6 */
94
95
96 /*************************************************
97 *         Bind socket to interface and port      *
98 *************************************************/
99
100 int
101 ip_addr(void * sin_, int af, const uschar * address, int port)
102 {
103 union sockaddr_46 * sin = sin_;
104 memset(sin, 0, sizeof(*sin));
105
106 /* Setup code when using an IPv6 socket. The wildcard address is ":", to
107 ensure an IPv6 socket is used. */
108
109 #if HAVE_IPV6
110 if (af == AF_INET6)
111   {
112   if (address[0] == ':' && address[1] == 0)
113     {
114     sin->v6.sin6_family = AF_INET6;
115     sin->v6.sin6_addr = in6addr_any;
116     }
117   else
118     ip_addrinfo(address, &sin->v6);  /* Panic-dies on error */
119   sin->v6.sin6_port = htons(port);
120   return sizeof(sin->v6);
121   }
122 else
123 #else     /* HAVE_IPv6 */
124 af = af;  /* Avoid compiler warning */
125 #endif    /* HAVE_IPV6 */
126
127 /* Setup code when using IPv4 socket. The wildcard address is "". */
128
129   {
130   sin->v4.sin_family = AF_INET;
131   sin->v4.sin_port = htons(port);
132   sin->v4.sin_addr.s_addr = address[0] == 0
133     ? (S_ADDR_TYPE)INADDR_ANY
134     : (S_ADDR_TYPE)inet_addr(CS address);
135   return sizeof(sin->v4);
136   }
137 }
138
139
140
141 /* This function binds a socket to a local interface address and port. For a
142 wildcard IPv6 bind, the address is ":".
143
144 Arguments:
145   sock           the socket
146   af             AF_INET or AF_INET6 - the socket type
147   address        the IP address, in text form
148   port           the IP port (host order)
149
150 Returns:         the result of bind()
151 */
152
153 int
154 ip_bind(int sock, int af, uschar *address, int port)
155 {
156 union sockaddr_46 sin;
157 int s_len = ip_addr(&sin, af, address, port);
158 return bind(sock, (struct sockaddr *)&sin, s_len);
159 }
160
161
162
163 /*************************************************
164 *************************************************/
165
166 #ifdef EXIM_TFO_PROBE
167 void
168 tfo_probe(void)
169 {
170 # ifdef TCP_FASTOPEN
171 int sock, backlog = 5;
172
173 if (  (sock = socket(SOCK_STREAM, AF_INET, 0)) < 0
174    && setsockopt(sock, IPPROTO_TCP, TCP_FASTOPEN, &backlog, sizeof(backlog))
175    )
176   tcp_fastopen_ok = TRUE;
177 close(sock);
178 # endif
179 }
180 #endif
181
182
183 /*************************************************
184 *        Connect socket to remote host           *
185 *************************************************/
186
187 /* This function connects a socket to a remote address and port. The socket may
188 or may not have previously been bound to a local interface. The socket is not
189 closed, even in cases of error. It is expected that the calling function, which
190 created the socket, will be the one that closes it.
191
192 Arguments:
193   sock        the socket
194   af          AF_INET6 or AF_INET for the socket type
195   address     the remote address, in text form
196   port        the remote port
197   timeout     a timeout (zero for indefinite timeout)
198   fastopen_blob    non-null iff TCP_FASTOPEN can be used; may indicate early-data to
199                 be sent in SYN segment
200
201 Returns:      0 on success; -1 on failure, with errno set
202 */
203
204 int
205 ip_connect(int sock, int af, const uschar *address, int port, int timeout,
206   const blob * fastopen_blob)
207 {
208 struct sockaddr_in s_in4;
209 struct sockaddr *s_ptr;
210 int s_len, rc, save_errno;
211
212 /* For an IPv6 address, use an IPv6 sockaddr structure. */
213
214 #if HAVE_IPV6
215 struct sockaddr_in6 s_in6;
216 if (af == AF_INET6)
217   {
218   memset(&s_in6, 0, sizeof(s_in6));
219   ip_addrinfo(address, &s_in6);   /* Panic-dies on error */
220   s_in6.sin6_port = htons(port);
221   s_ptr = (struct sockaddr *)&s_in6;
222   s_len = sizeof(s_in6);
223   }
224 else
225 #else     /* HAVE_IPV6 */
226 af = af;  /* Avoid compiler warning */
227 #endif    /* HAVE_IPV6 */
228
229 /* For an IPv4 address, use an IPv4 sockaddr structure, even on a system with
230 IPv6 support. */
231
232   {
233   memset(&s_in4, 0, sizeof(s_in4));
234   s_in4.sin_family = AF_INET;
235   s_in4.sin_port = htons(port);
236   s_in4.sin_addr.s_addr = (S_ADDR_TYPE)inet_addr(CCS address);
237   s_ptr = (struct sockaddr *)&s_in4;
238   s_len = sizeof(s_in4);
239   }
240
241 /* If no connection timeout is set, just call connect() without setting a
242 timer, thereby allowing the inbuilt OS timeout to operate. */
243
244 callout_address = string_sprintf("[%s]:%d", address, port);
245 sigalrm_seen = FALSE;
246 if (timeout > 0) alarm(timeout);
247
248 #if defined(TCP_FASTOPEN) && defined(MSG_FASTOPEN)
249 /* TCP Fast Open, if the system has a cookie from a previous call to
250 this peer, can send data in the SYN packet.  The peer can send data
251 before it gets our ACK of its SYN,ACK - the latter is useful for
252 the SMTP banner.  Other (than SMTP) cases of TCP connections can
253 possibly use the data-on-syn, so support that too.  */
254
255 if (fastopen_blob && tcp_fastopen_ok)
256   {
257   if ((rc = sendto(sock, fastopen_blob->data, fastopen_blob->len,
258                     MSG_FASTOPEN | MSG_DONTWAIT, s_ptr, s_len)) >= 0)
259         /* seen for with-data, experimental TFO option, with-cookie case */
260         /* seen for with-data, proper TFO opt, with-cookie case */
261     {
262     DEBUG(D_transport|D_v)
263       debug_printf("non-TFO mode connection attempt to %s, %lu data\n",
264         address, (unsigned long)fastopen_blob->len);
265     tcp_out_fastopen = fastopen_blob->len > 0 ?  2 : 1;
266     }
267   else if (errno == EINPROGRESS)        /* expected if we had no cookie for peer */
268         /* seen for no-data, proper TFO option, both cookie-request and with-cookie cases */
269         /*  apparently no visibility of the diffference at this point */
270         /* seen for with-data, proper TFO opt, cookie-req */
271         /*   with netwk delay, post-conn tcp_info sees unacked 1 for R, 2 for C; code in smtp_out.c */
272         /* ? older Experimental TFO option behaviour ? */
273     {                                   /* queue unsent data */
274     DEBUG(D_transport|D_v) debug_printf("TFO mode sendto, %s data: EINPROGRESS\n",
275       fastopen_blob->len > 0 ? "with"  : "no");
276     if (!fastopen_blob->data)
277       {
278       tcp_out_fastopen = 1;             /* we tried; unknown if useful yet */
279       rc = 0;
280       }
281     else
282       rc = send(sock, fastopen_blob->data, fastopen_blob->len, 0);
283     }
284   else if(errno == EOPNOTSUPP)
285     {
286     DEBUG(D_transport)
287       debug_printf("Tried TCP Fast Open but apparently not enabled by sysctl\n");
288     goto legacy_connect;
289     }
290   }
291 else
292 #endif
293   {
294 legacy_connect:
295   DEBUG(D_transport|D_v) if (fastopen_blob)
296     debug_printf("non-TFO mode connection attempt to %s, %lu data\n",
297       address, (unsigned long)fastopen_blob->len);
298   if ((rc = connect(sock, s_ptr, s_len)) >= 0)
299     if (  fastopen_blob && fastopen_blob->data && fastopen_blob->len
300        && send(sock, fastopen_blob->data, fastopen_blob->len, 0) < 0)
301         rc = -1;
302   }
303
304 save_errno = errno;
305 alarm(0);
306
307 /* There is a testing facility for simulating a connection timeout, as I
308 can't think of any other way of doing this. It converts a connection refused
309 into a timeout if the timeout is set to 999999. */
310
311 if (running_in_test_harness  && save_errno == ECONNREFUSED && timeout == 999999)
312   {
313   rc = -1;
314   save_errno = EINTR;
315   sigalrm_seen = TRUE;
316   }
317
318 /* Success */
319
320 if (rc >= 0)
321   return 0;
322
323 /* A failure whose error code is "Interrupted system call" is in fact
324 an externally applied timeout if the signal handler has been run. */
325
326 errno = save_errno == EINTR && sigalrm_seen ? ETIMEDOUT : save_errno;
327 return -1;
328 }
329
330
331
332 /*************************************************
333 *    Create connected socket to remote host      *
334 *************************************************/
335
336 /* Create a socket and connect to host (name or number, ipv6 ok)
337    at one of port-range.
338
339 Arguments:
340   type          SOCK_DGRAM or SOCK_STREAM
341   af            AF_INET6 or AF_INET for the socket type
342   address       the remote address, in text form
343   portlo,porthi the remote port range
344   timeout       a timeout
345   connhost      if not NULL, host_item to be filled in with connection details
346   errstr        pointer for allocated string on error
347   fastopen_blob with SOCK_STREAM, if non-null, request TCP Fast Open.
348                 Additionally, optional early-data to send
349
350 Return:
351   socket fd, or -1 on failure (having allocated an error string)
352 */
353 int
354 ip_connectedsocket(int type, const uschar * hostname, int portlo, int porthi,
355       int timeout, host_item * connhost, uschar ** errstr, const blob * fastopen_blob)
356 {
357 int namelen, port;
358 host_item shost;
359 host_item *h;
360 int af = 0, fd, fd4 = -1, fd6 = -1;
361
362 shost.next = NULL;
363 shost.address = NULL;
364 shost.port = portlo;
365 shost.mx = -1;
366
367 namelen = Ustrlen(hostname);
368
369 /* Anything enclosed in [] must be an IP address. */
370
371 if (hostname[0] == '[' &&
372     hostname[namelen - 1] == ']')
373   {
374   uschar * host = string_copyn(hostname+1, namelen-2);
375   if (string_is_ip_address(host, NULL) == 0)
376     {
377     *errstr = string_sprintf("malformed IP address \"%s\"", hostname);
378     return -1;
379     }
380   shost.name = shost.address = host;
381   }
382
383 /* Otherwise check for an unadorned IP address */
384
385 else if (string_is_ip_address(hostname, NULL) != 0)
386   shost.name = shost.address = string_copyn(hostname, namelen);
387
388 /* Otherwise lookup IP address(es) from the name */
389
390 else
391   {
392   shost.name = string_copyn(hostname, namelen);
393   if (host_find_byname(&shost, NULL, HOST_FIND_QUALIFY_SINGLE,
394       NULL, FALSE) != HOST_FOUND)
395     {
396     *errstr = string_sprintf("no IP address found for host %s", shost.name);
397     return -1;
398     }
399   }
400
401 /* Try to connect to the server - test each IP till one works */
402
403 for (h = &shost; h; h = h->next)
404   {
405   fd = Ustrchr(h->address, ':') != 0
406     ? fd6 < 0 ? (fd6 = ip_socket(type, af = AF_INET6)) : fd6
407     : fd4 < 0 ? (fd4 = ip_socket(type, af = AF_INET )) : fd4;
408
409   if (fd < 0)
410     {
411     *errstr = string_sprintf("failed to create socket: %s", strerror(errno));
412     goto bad;
413     }
414
415   for(port = portlo; port <= porthi; port++)
416     if (ip_connect(fd, af, h->address, port, timeout, fastopen_blob) == 0)
417       {
418       if (fd != fd6) close(fd6);
419       if (fd != fd4) close(fd4);
420       if (connhost)
421         {
422         h->port = port;
423         *connhost = *h;
424         connhost->next = NULL;
425         }
426       return fd;
427       }
428   }
429
430 *errstr = string_sprintf("failed to connect to any address for %s: %s",
431   hostname, strerror(errno));
432
433 bad:
434   close(fd4); close(fd6); return -1;
435 }
436
437
438 /*XXX TFO? */
439 int
440 ip_tcpsocket(const uschar * hostport, uschar ** errstr, int tmo)
441 {
442 int scan;
443 uschar hostname[256];
444 unsigned int portlow, porthigh;
445
446 /* extract host and port part */
447 scan = sscanf(CS hostport, "%255s %u-%u", hostname, &portlow, &porthigh);
448 if (scan != 3)
449   {
450   if (scan != 2)
451     {
452     *errstr = string_sprintf("invalid socket '%s'", hostport);
453     return -1;
454     }
455   porthigh = portlow;
456   }
457
458 return ip_connectedsocket(SOCK_STREAM, hostname, portlow, porthigh,
459                           tmo, NULL, errstr, NULL);
460 }
461
462 int
463 ip_unixsocket(const uschar * path, uschar ** errstr)
464 {
465 int sock;
466 struct sockaddr_un server;
467
468 if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
469   {
470   *errstr = US"can't open UNIX socket.";
471   return -1;
472   }
473
474 callout_address = string_copy(path);
475 server.sun_family = AF_UNIX;
476 Ustrncpy(server.sun_path, path, sizeof(server.sun_path)-1);
477 server.sun_path[sizeof(server.sun_path)-1] = '\0';
478 if (connect(sock, (struct sockaddr *) &server, sizeof(server)) < 0)
479   {
480   int err = errno;
481   (void)close(sock);
482   *errstr = string_sprintf("unable to connect to UNIX socket (%s): %s",
483                 path, strerror(err));
484   return -1;
485   }
486 return sock;
487 }
488
489 int
490 ip_streamsocket(const uschar * spec, uschar ** errstr, int tmo)
491 {
492 return *spec == '/'
493   ? ip_unixsocket(spec, errstr) : ip_tcpsocket(spec, errstr, tmo);
494 }
495
496 /*************************************************
497 *         Set keepalive on a socket              *
498 *************************************************/
499
500 /* Can be called for both incoming and outgoing sockets.
501
502 Arguments:
503   sock       the socket
504   address    the remote host address, for failure logging
505   torf       true for outgoing connection, false for incoming
506
507 Returns:     nothing
508 */
509
510 void
511 ip_keepalive(int sock, const uschar *address, BOOL torf)
512 {
513 int fodder = 1;
514 if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
515     US (&fodder), sizeof(fodder)) != 0)
516   log_write(0, LOG_MAIN, "setsockopt(SO_KEEPALIVE) on connection %s %s "
517     "failed: %s", torf? "to":"from", address, strerror(errno));
518 }
519
520
521
522 /*************************************************
523 *         Receive from a socket with timeout     *
524 *************************************************/
525
526 /*
527 Arguments:
528   fd          the file descriptor
529   timeout     the timeout, seconds
530 Returns:      TRUE => ready for i/o
531               FALSE => timed out, or other error
532 */
533 BOOL
534 fd_ready(int fd, int timeout)
535 {
536 fd_set select_inset;
537 time_t start_recv = time(NULL);
538 int time_left = timeout;
539 int rc;
540
541 if (time_left <= 0)
542   {
543   errno = ETIMEDOUT;
544   return FALSE;
545   }
546 /* Wait until the socket is ready */
547
548 do
549   {
550   struct timeval tv = { .tv_sec = time_left, .tv_usec = 0 };
551   FD_ZERO (&select_inset);
552   FD_SET (fd, &select_inset);
553
554   /*DEBUG(D_transport) debug_printf("waiting for data on fd\n");*/
555   rc = select(fd + 1, (SELECT_ARG2_TYPE *)&select_inset, NULL, NULL, &tv);
556
557   /* If some interrupt arrived, just retry. We presume this to be rare,
558   but it can happen (e.g. the SIGUSR1 signal sent by exiwhat causes
559   select() to exit).
560
561   Aug 2004: Somebody set up a cron job that ran exiwhat every 2 minutes, making
562   the interrupt not at all rare. Since the timeout is typically more than 2
563   minutes, the effect was to block the timeout completely. To prevent this
564   happening again, we do an explicit time test and adjust the timeout
565   accordingly */
566
567   if (rc < 0 && errno == EINTR)
568     {
569     DEBUG(D_transport) debug_printf("EINTR while waiting for socket data\n");
570
571     /* Watch out, 'continue' jumps to the condition, not to the loops top */
572     time_left = timeout - (time(NULL) - start_recv);
573     if (time_left > 0) continue;
574     }
575
576   if (rc <= 0)
577     {
578     errno = ETIMEDOUT;
579     return FALSE;
580     }
581
582   /* Checking the FD_ISSET is not enough, if we're interrupted, the
583   select_inset may still contain the 'input'. */
584   }
585 while (rc < 0 || !FD_ISSET(fd, &select_inset));
586 return TRUE;
587 }
588
589 /* The timeout is implemented using select(), and we loop to cover select()
590 getting interrupted, and the possibility of select() returning with a positive
591 result but no ready descriptor. Is this in fact possible?
592
593 Arguments:
594   sock        the socket
595   buffer      to read into
596   bufsize     the buffer size
597   timeout     the timeout
598
599 Returns:      > 0 => that much data read
600               <= 0 on error or EOF; errno set - zero for EOF
601 */
602
603 int
604 ip_recv(int sock, uschar *buffer, int buffsize, int timeout)
605 {
606 int rc;
607
608 if (!fd_ready(sock, timeout))
609   return -1;
610
611 /* The socket is ready, read from it (via TLS if it's active). On EOF (i.e.
612 close down of the connection), set errno to zero; otherwise leave it alone. */
613
614 #ifdef SUPPORT_TLS
615 if (tls_out.active == sock)
616   rc = tls_read(FALSE, buffer, buffsize);
617 else if (tls_in.active == sock)
618   rc = tls_read(TRUE, buffer, buffsize);
619 else
620 #endif
621   rc = recv(sock, buffer, buffsize, 0);
622
623 if (rc > 0) return rc;
624 if (rc == 0) errno = 0;
625 return -1;
626 }
627
628
629
630
631 /*************************************************
632 *    Lookup address family of potential socket   *
633 *************************************************/
634
635 /* Given a file-descriptor, check to see if it's a socket and, if so,
636 return the address family; detects IPv4 vs IPv6.  If not a socket then
637 return -1.
638
639 The value 0 is typically AF_UNSPEC, which should not be seen on a connected
640 fd.  If the return is -1, the errno will be from getsockname(); probably
641 ENOTSOCK or ECONNRESET.
642
643 Arguments:     socket-or-not fd
644 Returns:       address family or -1
645 */
646
647 int
648 ip_get_address_family(int fd)
649 {
650 struct sockaddr_storage ss;
651 socklen_t sslen = sizeof(ss);
652
653 if (getsockname(fd, (struct sockaddr *) &ss, &sslen) < 0)
654   return -1;
655
656 return (int) ss.ss_family;
657 }
658
659
660
661
662 /*************************************************
663 *       Lookup DSCP settings for a socket        *
664 *************************************************/
665
666 struct dscp_name_tableentry {
667   const uschar *name;
668   int value;
669 };
670 /* Keep both of these tables sorted! */
671 static struct dscp_name_tableentry dscp_table[] = {
672 #ifdef IPTOS_DSCP_AF11
673     { CUS"af11", IPTOS_DSCP_AF11 },
674     { CUS"af12", IPTOS_DSCP_AF12 },
675     { CUS"af13", IPTOS_DSCP_AF13 },
676     { CUS"af21", IPTOS_DSCP_AF21 },
677     { CUS"af22", IPTOS_DSCP_AF22 },
678     { CUS"af23", IPTOS_DSCP_AF23 },
679     { CUS"af31", IPTOS_DSCP_AF31 },
680     { CUS"af32", IPTOS_DSCP_AF32 },
681     { CUS"af33", IPTOS_DSCP_AF33 },
682     { CUS"af41", IPTOS_DSCP_AF41 },
683     { CUS"af42", IPTOS_DSCP_AF42 },
684     { CUS"af43", IPTOS_DSCP_AF43 },
685     { CUS"ef", IPTOS_DSCP_EF },
686 #endif
687 #ifdef IPTOS_LOWCOST
688     { CUS"lowcost", IPTOS_LOWCOST },
689 #endif
690     { CUS"lowdelay", IPTOS_LOWDELAY },
691 #ifdef IPTOS_MINCOST
692     { CUS"mincost", IPTOS_MINCOST },
693 #endif
694     { CUS"reliability", IPTOS_RELIABILITY },
695     { CUS"throughput", IPTOS_THROUGHPUT }
696 };
697 static int dscp_table_size =
698   sizeof(dscp_table) / sizeof(struct dscp_name_tableentry);
699
700 /* DSCP values change by protocol family, and so do the options used for
701 setsockopt(); this utility does all the lookups.  It takes an unexpanded
702 option string, expands it, strips off affix whitespace, then checks if it's
703 a number.  If all of what's left is a number, then that's how the option will
704 be parsed and success/failure is a range check.  If it's not all a number,
705 then it must be a supported keyword.
706
707 Arguments:
708   dscp_name   a string, so far unvalidated
709   af          address_family in use
710   level       setsockopt level to use
711   optname     setsockopt name to use
712   dscp_value  value for dscp_name
713
714 Returns: TRUE if okay to setsockopt(), else FALSE
715
716 *level and *optname may be set even if FALSE is returned
717 */
718
719 BOOL
720 dscp_lookup(const uschar *dscp_name, int af,
721     int *level, int *optname, int *dscp_value)
722 {
723 uschar *dscp_lookup, *p;
724 int first, last;
725 long rawlong;
726
727 if (af == AF_INET)
728   {
729   *level = IPPROTO_IP;
730   *optname = IP_TOS;
731   }
732 #if HAVE_IPV6 && defined(IPV6_TCLASS)
733 else if (af == AF_INET6)
734   {
735   *level = IPPROTO_IPV6;
736   *optname = IPV6_TCLASS;
737   }
738 #endif
739 else
740   {
741   DEBUG(D_transport)
742     debug_printf("Unhandled address family %d in dscp_lookup()\n", af);
743   return FALSE;
744   }
745 if (!dscp_name)
746   {
747   DEBUG(D_transport)
748     debug_printf("[empty DSCP]\n");
749   return FALSE;
750   }
751 dscp_lookup = expand_string(US dscp_name);
752 if (dscp_lookup == NULL || *dscp_lookup == '\0')
753   return FALSE;
754
755 p = dscp_lookup + Ustrlen(dscp_lookup) - 1;
756 while (isspace(*p)) *p-- = '\0';
757 while (isspace(*dscp_lookup) && dscp_lookup < p) dscp_lookup++;
758 if (*dscp_lookup == '\0')
759   return FALSE;
760
761 rawlong = Ustrtol(dscp_lookup, &p, 0);
762 if (p != dscp_lookup && *p == '\0')
763   {
764   /* We have six bits available, which will end up shifted to fit in 0xFC mask.
765   RFC 2597 defines the values unshifted. */
766   if (rawlong < 0 || rawlong > 0x3F)
767     {
768     DEBUG(D_transport)
769       debug_printf("DSCP value %ld out of range, ignored.\n", rawlong);
770     return FALSE;
771     }
772   *dscp_value = rawlong << 2;
773   return TRUE;
774   }
775
776 first = 0;
777 last = dscp_table_size;
778 while (last > first)
779   {
780   int middle = (first + last)/2;
781   int c = Ustrcmp(dscp_lookup, dscp_table[middle].name);
782   if (c == 0)
783     {
784     *dscp_value = dscp_table[middle].value;
785     return TRUE;
786     }
787   else if (c > 0)
788     first = middle + 1;
789   else
790     last = middle;
791   }
792 return FALSE;
793 }
794
795 void
796 dscp_list_to_stream(FILE *stream)
797 {
798 int i;
799 for (i=0; i < dscp_table_size; ++i)
800   fprintf(stream, "%s\n", dscp_table[i].name);
801 }
802
803
804 /* End of ip.c */
805 /* vi: aw ai sw=2
806 */