Annotation of embedaddon/quagga/bgpd/bgp_network.c, revision 1.1.1.1
1.1 misho 1: /* BGP network related fucntions
2: Copyright (C) 1999 Kunihiro Ishiguro
3:
4: This file is part of GNU Zebra.
5:
6: GNU Zebra is free software; you can redistribute it and/or modify it
7: under the terms of the GNU General Public License as published by the
8: Free Software Foundation; either version 2, or (at your option) any
9: later version.
10:
11: GNU Zebra is distributed in the hope that it will be useful, but
12: WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14: General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU Zebra; see the file COPYING. If not, write to the Free
18: Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19: 02111-1307, USA. */
20:
21: #include <zebra.h>
22:
23: #include "thread.h"
24: #include "sockunion.h"
25: #include "sockopt.h"
26: #include "memory.h"
27: #include "log.h"
28: #include "if.h"
29: #include "prefix.h"
30: #include "command.h"
31: #include "privs.h"
32: #include "linklist.h"
33: #include "network.h"
34:
35: #include "bgpd/bgpd.h"
36: #include "bgpd/bgp_fsm.h"
37: #include "bgpd/bgp_attr.h"
38: #include "bgpd/bgp_debug.h"
39: #include "bgpd/bgp_network.h"
40:
41: extern struct zebra_privs_t bgpd_privs;
42:
43: /* BGP listening socket. */
44: struct bgp_listener
45: {
46: int fd;
47: union sockunion su;
48: struct thread *thread;
49: };
50:
51: /*
52: * Set MD5 key for the socket, for the given IPv4 peer address.
53: * If the password is NULL or zero-length, the option will be disabled.
54: */
55: static int
56: bgp_md5_set_socket (int socket, union sockunion *su, const char *password)
57: {
58: int ret = -1;
59: int en = ENOSYS;
60:
61: assert (socket >= 0);
62:
63: #if HAVE_DECL_TCP_MD5SIG
64: ret = sockopt_tcp_signature (socket, su, password);
65: en = errno;
66: #endif /* HAVE_TCP_MD5SIG */
67:
68: if (ret < 0)
69: zlog (NULL, LOG_WARNING, "can't set TCP_MD5SIG option on socket %d: %s",
70: socket, safe_strerror (en));
71:
72: return ret;
73: }
74:
75: /* Helper for bgp_connect */
76: static int
77: bgp_md5_set_connect (int socket, union sockunion *su, const char *password)
78: {
79: int ret = -1;
80:
81: #if HAVE_DECL_TCP_MD5SIG
82: if ( bgpd_privs.change (ZPRIVS_RAISE) )
83: {
84: zlog_err ("%s: could not raise privs", __func__);
85: return ret;
86: }
87:
88: ret = bgp_md5_set_socket (socket, su, password);
89:
90: if (bgpd_privs.change (ZPRIVS_LOWER) )
91: zlog_err ("%s: could not lower privs", __func__);
92: #endif /* HAVE_TCP_MD5SIG */
93:
94: return ret;
95: }
96:
97: int
98: bgp_md5_set (struct peer *peer)
99: {
100: struct listnode *node;
101: int ret = 0;
102: struct bgp_listener *listener;
103:
104: if ( bgpd_privs.change (ZPRIVS_RAISE) )
105: {
106: zlog_err ("%s: could not raise privs", __func__);
107: return -1;
108: }
109:
110: /* Just set the password on the listen socket(s). Outbound connections
111: * are taken care of in bgp_connect() below.
112: */
113: for (ALL_LIST_ELEMENTS_RO(bm->listen_sockets, node, listener))
114: if (listener->su.sa.sa_family == peer->su.sa.sa_family)
115: {
116: ret = bgp_md5_set_socket (listener->fd, &peer->su, peer->password);
117: break;
118: }
119:
120: if (bgpd_privs.change (ZPRIVS_LOWER) )
121: zlog_err ("%s: could not lower privs", __func__);
122:
123: return ret;
124: }
125:
126: /* Accept bgp connection. */
127: static int
128: bgp_accept (struct thread *thread)
129: {
130: int bgp_sock;
131: int accept_sock;
132: union sockunion su;
133: struct bgp_listener *listener = THREAD_ARG(thread);
134: struct peer *peer;
135: struct peer *peer1;
136: char buf[SU_ADDRSTRLEN];
137:
138: /* Register accept thread. */
139: accept_sock = THREAD_FD (thread);
140: if (accept_sock < 0)
141: {
142: zlog_err ("accept_sock is nevative value %d", accept_sock);
143: return -1;
144: }
145: listener->thread = thread_add_read (master, bgp_accept, listener, accept_sock);
146:
147: /* Accept client connection. */
148: bgp_sock = sockunion_accept (accept_sock, &su);
149: if (bgp_sock < 0)
150: {
151: zlog_err ("[Error] BGP socket accept failed (%s)", safe_strerror (errno));
152: return -1;
153: }
154: set_nonblocking (bgp_sock);
155:
156: if (BGP_DEBUG (events, EVENTS))
157: zlog_debug ("[Event] BGP connection from host %s", inet_sutop (&su, buf));
158:
159: /* Check remote IP address */
160: peer1 = peer_lookup (NULL, &su);
161: if (! peer1 || peer1->status == Idle)
162: {
163: if (BGP_DEBUG (events, EVENTS))
164: {
165: if (! peer1)
166: zlog_debug ("[Event] BGP connection IP address %s is not configured",
167: inet_sutop (&su, buf));
168: else
169: zlog_debug ("[Event] BGP connection IP address %s is Idle state",
170: inet_sutop (&su, buf));
171: }
172: close (bgp_sock);
173: return -1;
174: }
175:
176: /* In case of peer is EBGP, we should set TTL for this connection. */
177: if (peer_sort (peer1) == BGP_PEER_EBGP) {
178: sockopt_ttl (peer1->su.sa.sa_family, bgp_sock, peer1->ttl);
179: if (peer1->gtsm_hops)
180: sockopt_minttl (peer1->su.sa.sa_family, bgp_sock, MAXTTL + 1 - peer1->gtsm_hops);
181: }
182:
183: /* Make dummy peer until read Open packet. */
184: if (BGP_DEBUG (events, EVENTS))
185: zlog_debug ("[Event] Make dummy peer structure until read Open packet");
186:
187: {
188: char buf[SU_ADDRSTRLEN + 1];
189:
190: peer = peer_create_accept (peer1->bgp);
191: SET_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER);
192: peer->su = su;
193: peer->fd = bgp_sock;
194: peer->status = Active;
195: peer->local_id = peer1->local_id;
196: peer->v_holdtime = peer1->v_holdtime;
197: peer->v_keepalive = peer1->v_keepalive;
198:
199: /* Make peer's address string. */
200: sockunion2str (&su, buf, SU_ADDRSTRLEN);
201: peer->host = XSTRDUP (MTYPE_BGP_PEER_HOST, buf);
202: }
203:
204: BGP_EVENT_ADD (peer, TCP_connection_open);
205:
206: return 0;
207: }
208:
209: /* BGP socket bind. */
210: static int
211: bgp_bind (struct peer *peer)
212: {
213: #ifdef SO_BINDTODEVICE
214: int ret;
215: struct ifreq ifreq;
216:
217: if (! peer->ifname)
218: return 0;
219:
220: strncpy ((char *)&ifreq.ifr_name, peer->ifname, sizeof (ifreq.ifr_name));
221:
222: if ( bgpd_privs.change (ZPRIVS_RAISE) )
223: zlog_err ("bgp_bind: could not raise privs");
224:
225: ret = setsockopt (peer->fd, SOL_SOCKET, SO_BINDTODEVICE,
226: &ifreq, sizeof (ifreq));
227:
228: if (bgpd_privs.change (ZPRIVS_LOWER) )
229: zlog_err ("bgp_bind: could not lower privs");
230:
231: if (ret < 0)
232: {
233: zlog (peer->log, LOG_INFO, "bind to interface %s failed", peer->ifname);
234: return ret;
235: }
236: #endif /* SO_BINDTODEVICE */
237: return 0;
238: }
239:
240: static int
241: bgp_bind_address (int sock, struct in_addr *addr)
242: {
243: int ret;
244: struct sockaddr_in local;
245:
246: memset (&local, 0, sizeof (struct sockaddr_in));
247: local.sin_family = AF_INET;
248: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
249: local.sin_len = sizeof(struct sockaddr_in);
250: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
251: memcpy (&local.sin_addr, addr, sizeof (struct in_addr));
252:
253: if ( bgpd_privs.change (ZPRIVS_RAISE) )
254: zlog_err ("bgp_bind_address: could not raise privs");
255:
256: ret = bind (sock, (struct sockaddr *)&local, sizeof (struct sockaddr_in));
257: if (ret < 0)
258: ;
259:
260: if (bgpd_privs.change (ZPRIVS_LOWER) )
261: zlog_err ("bgp_bind_address: could not lower privs");
262:
263: return 0;
264: }
265:
266: static struct in_addr *
267: bgp_update_address (struct interface *ifp)
268: {
269: struct prefix_ipv4 *p;
270: struct connected *connected;
271: struct listnode *node;
272:
273: for (ALL_LIST_ELEMENTS_RO (ifp->connected, node, connected))
274: {
275: p = (struct prefix_ipv4 *) connected->address;
276:
277: if (p->family == AF_INET)
278: return &p->prefix;
279: }
280: return NULL;
281: }
282:
283: /* Update source selection. */
284: static void
285: bgp_update_source (struct peer *peer)
286: {
287: struct interface *ifp;
288: struct in_addr *addr;
289:
290: /* Source is specified with interface name. */
291: if (peer->update_if)
292: {
293: ifp = if_lookup_by_name (peer->update_if);
294: if (! ifp)
295: return;
296:
297: addr = bgp_update_address (ifp);
298: if (! addr)
299: return;
300:
301: bgp_bind_address (peer->fd, addr);
302: }
303:
304: /* Source is specified with IP address. */
305: if (peer->update_source)
306: sockunion_bind (peer->fd, peer->update_source, 0, peer->update_source);
307: }
308:
309: /* BGP try to connect to the peer. */
310: int
311: bgp_connect (struct peer *peer)
312: {
313: unsigned int ifindex = 0;
314:
315: /* Make socket for the peer. */
316: peer->fd = sockunion_socket (&peer->su);
317: if (peer->fd < 0)
318: return -1;
319:
320: /* If we can get socket for the peer, adjest TTL and make connection. */
321: if (peer_sort (peer) == BGP_PEER_EBGP) {
322: sockopt_ttl (peer->su.sa.sa_family, peer->fd, peer->ttl);
323: if (peer->gtsm_hops)
324: sockopt_minttl (peer->su.sa.sa_family, peer->fd, MAXTTL + 1 - peer->gtsm_hops);
325: }
326:
327: sockopt_reuseaddr (peer->fd);
328: sockopt_reuseport (peer->fd);
329:
330: #ifdef IPTOS_PREC_INTERNETCONTROL
331: if (sockunion_family (&peer->su) == AF_INET)
332: setsockopt_ipv4_tos (peer->fd, IPTOS_PREC_INTERNETCONTROL);
333: #endif
334:
335: if (peer->password)
336: bgp_md5_set_connect (peer->fd, &peer->su, peer->password);
337:
338: /* Bind socket. */
339: bgp_bind (peer);
340:
341: /* Update source bind. */
342: bgp_update_source (peer);
343:
344: #ifdef HAVE_IPV6
345: if (peer->ifname)
346: ifindex = if_nametoindex (peer->ifname);
347: #endif /* HAVE_IPV6 */
348:
349: if (BGP_DEBUG (events, EVENTS))
350: plog_debug (peer->log, "%s [Event] Connect start to %s fd %d",
351: peer->host, peer->host, peer->fd);
352:
353: /* Connect to the remote peer. */
354: return sockunion_connect (peer->fd, &peer->su, htons (peer->port), ifindex);
355: }
356:
357: /* After TCP connection is established. Get local address and port. */
358: void
359: bgp_getsockname (struct peer *peer)
360: {
361: if (peer->su_local)
362: {
363: sockunion_free (peer->su_local);
364: peer->su_local = NULL;
365: }
366:
367: if (peer->su_remote)
368: {
369: sockunion_free (peer->su_remote);
370: peer->su_remote = NULL;
371: }
372:
373: peer->su_local = sockunion_getsockname (peer->fd);
374: peer->su_remote = sockunion_getpeername (peer->fd);
375:
376: bgp_nexthop_set (peer->su_local, peer->su_remote, &peer->nexthop, peer);
377: }
378:
379:
380: static int
381: bgp_listener (int sock, struct sockaddr *sa, socklen_t salen)
382: {
383: struct bgp_listener *listener;
384: int ret, en;
385:
386: sockopt_reuseaddr (sock);
387: sockopt_reuseport (sock);
388:
389: #ifdef IPTOS_PREC_INTERNETCONTROL
390: if (sa->sa_family == AF_INET)
391: setsockopt_ipv4_tos (sock, IPTOS_PREC_INTERNETCONTROL);
392: #endif
393:
394: #ifdef IPV6_V6ONLY
395: /* Want only IPV6 on ipv6 socket (not mapped addresses) */
396: if (sa->sa_family == AF_INET6) {
397: int on = 1;
398: setsockopt (sock, IPPROTO_IPV6, IPV6_V6ONLY,
399: (void *) &on, sizeof (on));
400: }
401: #endif
402:
403: if (bgpd_privs.change (ZPRIVS_RAISE) )
404: zlog_err ("bgp_socket: could not raise privs");
405:
406: ret = bind (sock, sa, salen);
407: en = errno;
408: if (bgpd_privs.change (ZPRIVS_LOWER) )
409: zlog_err ("bgp_bind_address: could not lower privs");
410:
411: if (ret < 0)
412: {
413: zlog_err ("bind: %s", safe_strerror (en));
414: return ret;
415: }
416:
417: ret = listen (sock, 3);
418: if (ret < 0)
419: {
420: zlog_err ("listen: %s", safe_strerror (errno));
421: return ret;
422: }
423:
424: listener = XMALLOC (MTYPE_BGP_LISTENER, sizeof(*listener));
425: listener->fd = sock;
426: memcpy(&listener->su, sa, salen);
427: listener->thread = thread_add_read (master, bgp_accept, listener, sock);
428: listnode_add (bm->listen_sockets, listener);
429:
430: return 0;
431: }
432:
433: /* IPv6 supported version of BGP server socket setup. */
434: #if defined (HAVE_IPV6) && ! defined (NRL)
435: int
436: bgp_socket (unsigned short port, const char *address)
437: {
438: struct addrinfo *ainfo;
439: struct addrinfo *ainfo_save;
440: static const struct addrinfo req = {
441: .ai_family = AF_UNSPEC,
442: .ai_flags = AI_PASSIVE,
443: .ai_socktype = SOCK_STREAM,
444: };
445: int ret, count;
446: char port_str[BUFSIZ];
447:
448: snprintf (port_str, sizeof(port_str), "%d", port);
449: port_str[sizeof (port_str) - 1] = '\0';
450:
451: ret = getaddrinfo (address, port_str, &req, &ainfo_save);
452: if (ret != 0)
453: {
454: zlog_err ("getaddrinfo: %s", gai_strerror (ret));
455: return -1;
456: }
457:
458: count = 0;
459: for (ainfo = ainfo_save; ainfo; ainfo = ainfo->ai_next)
460: {
461: int sock;
462:
463: if (ainfo->ai_family != AF_INET && ainfo->ai_family != AF_INET6)
464: continue;
465:
466: sock = socket (ainfo->ai_family, ainfo->ai_socktype, ainfo->ai_protocol);
467: if (sock < 0)
468: {
469: zlog_err ("socket: %s", safe_strerror (errno));
470: continue;
471: }
472:
473: /* if we intend to implement ttl-security, this socket needs ttl=255 */
474: sockopt_ttl (ainfo->ai_family, sock, MAXTTL);
475:
476: ret = bgp_listener (sock, ainfo->ai_addr, ainfo->ai_addrlen);
477: if (ret == 0)
478: ++count;
479: else
480: close(sock);
481: }
482: freeaddrinfo (ainfo_save);
483: if (count == 0)
484: {
485: zlog_err ("%s: no usable addresses", __func__);
486: return -1;
487: }
488:
489: return 0;
490: }
491: #else
492: /* Traditional IPv4 only version. */
493: int
494: bgp_socket (unsigned short port, const char *address)
495: {
496: int sock;
497: int socklen;
498: struct sockaddr_in sin;
499: int ret, en;
500:
501: sock = socket (AF_INET, SOCK_STREAM, 0);
502: if (sock < 0)
503: {
504: zlog_err ("socket: %s", safe_strerror (errno));
505: return sock;
506: }
507:
508: /* if we intend to implement ttl-security, this socket needs ttl=255 */
509: sockopt_ttl (AF_INET, sock, MAXTTL);
510:
511: memset (&sin, 0, sizeof (struct sockaddr_in));
512: sin.sin_family = AF_INET;
513: sin.sin_port = htons (port);
514: socklen = sizeof (struct sockaddr_in);
515:
516: if (address && ((ret = inet_aton(address, &sin.sin_addr)) < 1))
517: {
518: zlog_err("bgp_socket: could not parse ip address %s: %s",
519: address, safe_strerror (errno));
520: return ret;
521: }
522: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
523: sin.sin_len = socklen;
524: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
525:
526: ret = bgp_listener (sock, (struct sockaddr *) &sin, socklen);
527: if (ret < 0)
528: {
529: close (sock);
530: return ret;
531: }
532: return sock;
533: }
534: #endif /* HAVE_IPV6 && !NRL */
535:
536: void
537: bgp_close (void)
538: {
539: struct listnode *node, *next;
540: struct bgp_listener *listener;
541:
542: for (ALL_LIST_ELEMENTS (bm->listen_sockets, node, next, listener))
543: {
544: thread_cancel (listener->thread);
545: close (listener->fd);
546: listnode_delete (bm->listen_sockets, listener);
547: XFREE (MTYPE_BGP_LISTENER, listener);
548: }
549: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>