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