1 /* Main routine of bgpd.
2 Copyright (C) 1996, 97, 98, 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 "vector.h"
24 #include "vty.h"
25 #include "command.h"
26 #include "getopt.h"
27 #include "thread.h"
28 #include <lib/version.h>
29 #include "memory.h"
30 #include "prefix.h"
31 #include "log.h"
32 #include "privs.h"
33 #include "sigevent.h"
34 #include "zclient.h"
35 #include "routemap.h"
36 #include "filter.h"
37 #include "plist.h"
38 #include "stream.h"
39 #include "vrf.h"
40 #include "workqueue.h"
41
42 #include "bgpd/bgpd.h"
43 #include "bgpd/bgp_attr.h"
44 #include "bgpd/bgp_mplsvpn.h"
45 #include "bgpd/bgp_aspath.h"
46 #include "bgpd/bgp_dump.h"
47 #include "bgpd/bgp_route.h"
48 #include "bgpd/bgp_nexthop.h"
49 #include "bgpd/bgp_regex.h"
50 #include "bgpd/bgp_clist.h"
51 #include "bgpd/bgp_debug.h"
52 #include "bgpd/bgp_filter.h"
53 #include "bgpd/bgp_zebra.h"
54
55 /* bgpd options, we use GNU getopt library. */
56 static const struct option longopts[] =
57 {
58 { "daemon", no_argument, NULL, 'd'},
59 { "config_file", required_argument, NULL, 'f'},
60 { "pid_file", required_argument, NULL, 'i'},
61 { "socket", required_argument, NULL, 'z'},
62 { "bgp_port", required_argument, NULL, 'p'},
63 { "listenon", required_argument, NULL, 'l'},
64 { "vty_addr", required_argument, NULL, 'A'},
65 { "vty_port", required_argument, NULL, 'P'},
66 { "retain", no_argument, NULL, 'r'},
67 { "no_kernel", no_argument, NULL, 'n'},
68 { "user", required_argument, NULL, 'u'},
69 { "group", required_argument, NULL, 'g'},
70 { "skip_runas", no_argument, NULL, 'S'},
71 { "version", no_argument, NULL, 'v'},
72 { "dryrun", no_argument, NULL, 'C'},
73 { "help", no_argument, NULL, 'h'},
74 { 0 }
75 };
76
77 /* signal definitions */
78 void sighup (void);
79 void sigint (void);
80 void sigusr1 (void);
81
82 static void bgp_exit (int);
83
84 static struct quagga_signal_t bgp_signals[] =
85 {
86 {
87 .signal = SIGHUP,
88 .handler = &sighup,
89 },
90 {
91 .signal = SIGUSR1,
92 .handler = &sigusr1,
93 },
94 {
95 .signal = SIGINT,
96 .handler = &sigint,
97 },
98 {
99 .signal = SIGTERM,
100 .handler = &sigint,
101 },
102 };
103
104 /* Configuration file and directory. */
105 char config_default[] = SYSCONFDIR BGP_DEFAULT_CONFIG;
106
107 /* Route retain mode flag. */
108 static int retain_mode = 0;
109
110 /* Manually specified configuration file name. */
111 char *config_file = NULL;
112
113 /* Process ID saved for use by init system */
114 static const char *pid_file = PATH_BGPD_PID;
115
116 /* VTY port number and address. */
117 int vty_port = BGP_VTY_PORT;
118 char *vty_addr = NULL;
119
120 /* privileges */
121 static zebra_capabilities_t _caps_p [] =
122 {
123 ZCAP_BIND,
124 ZCAP_NET_RAW,
125 ZCAP_NET_ADMIN,
126 };
127
128 struct zebra_privs_t bgpd_privs =
129 {
130 #if defined(QUAGGA_USER) && defined(QUAGGA_GROUP)
131 .user = QUAGGA_USER,
132 .group = QUAGGA_GROUP,
133 #endif
134 #ifdef VTY_GROUP
135 .vty_group = VTY_GROUP,
136 #endif
137 .caps_p = _caps_p,
138 .cap_num_p = array_size(_caps_p),
139 .cap_num_i = 0,
140 };
141
142 /* Help information display. */
143 static void
usage(char * progname,int status)144 usage (char *progname, int status)
145 {
146 if (status != 0)
147 fprintf (stderr, "Try `%s --help' for more information.\n", progname);
148 else
149 {
150 printf ("Usage : %s [OPTION...]\n\n\
151 Daemon which manages kernel routing table management and \
152 redistribution between different routing protocols.\n\n\
153 -d, --daemon Runs in daemon mode\n\
154 -f, --config_file Set configuration file name\n\
155 -i, --pid_file Set process identifier file name\n\
156 -z, --socket Set path of zebra socket\n\
157 -p, --bgp_port Set bgp protocol's port number\n\
158 -l, --listenon Listen on specified address (implies -n)\n\
159 -A, --vty_addr Set vty's bind address\n\
160 -P, --vty_port Set vty's port number\n\
161 -r, --retain When program terminates, retain added route by bgpd.\n\
162 -n, --no_kernel Do not install route to kernel.\n\
163 -u, --user User to run as\n\
164 -g, --group Group to run as\n\
165 -S, --skip_runas Skip user and group run as\n\
166 -v, --version Print program version\n\
167 -C, --dryrun Check configuration for validity and exit\n\
168 -h, --help Display this help and exit\n\
169 \n\
170 Report bugs to %s\n", progname, ZEBRA_BUG_ADDRESS);
171 }
172
173 exit (status);
174 }
175
176 /* SIGHUP handler. */
177 void
sighup(void)178 sighup (void)
179 {
180 zlog (NULL, LOG_INFO, "SIGHUP received");
181
182 /* Terminate all thread. */
183 bgp_terminate ();
184 bgp_reset ();
185 zlog_info ("bgpd restarting!");
186
187 /* Reload config file. */
188 vty_read_config (config_file, config_default);
189
190 /* Create VTY's socket */
191 vty_serv_sock (vty_addr, vty_port, BGP_VTYSH_PATH);
192
193 /* Try to return to normal operation. */
194 }
195
196 /* SIGINT handler. */
197 void
sigint(void)198 sigint (void)
199 {
200 zlog_notice ("Terminating on signal");
201
202 if (! retain_mode)
203 {
204 bgp_terminate ();
205 if (bgpd_privs.user) /* NULL if skip_runas flag set */
206 zprivs_terminate (&bgpd_privs);
207 }
208
209 bgp_exit (0);
210 }
211
212 /* SIGUSR1 handler. */
213 void
sigusr1(void)214 sigusr1 (void)
215 {
216 zlog_rotate (NULL);
217 }
218
219 /*
220 Try to free up allocations we know about so that diagnostic tools such as
221 valgrind are able to better illuminate leaks.
222
223 Zebra route removal and protocol teardown are not meant to be done here.
224 For example, "retain_mode" may be set.
225 */
226 static void
bgp_exit(int status)227 bgp_exit (int status)
228 {
229 struct bgp *bgp;
230 struct listnode *node, *nnode;
231 int *socket;
232 struct interface *ifp;
233
234 /* it only makes sense for this to be called on a clean exit */
235 assert (status == 0);
236
237 /* reverse bgp_master_init */
238 for (ALL_LIST_ELEMENTS (bm->bgp, node, nnode, bgp))
239 bgp_delete (bgp);
240 list_free (bm->bgp);
241 bm->bgp = NULL;
242
243 /*
244 * bgp_delete can re-allocate the process queues after they were
245 * deleted in bgp_terminate. delete them again.
246 *
247 * It might be better to ensure the RIBs (including static routes)
248 * are cleared by bgp_terminate() during its call to bgp_cleanup_routes(),
249 * which currently only deletes the kernel routes.
250 */
251 if (bm->process_main_queue)
252 {
253 work_queue_free (bm->process_main_queue);
254 bm->process_main_queue = NULL;
255 }
256 if (bm->process_rsclient_queue)
257 {
258 work_queue_free (bm->process_rsclient_queue);
259 bm->process_rsclient_queue = NULL;
260 }
261
262 /* reverse bgp_master_init */
263 for (ALL_LIST_ELEMENTS_RO(bm->listen_sockets, node, socket))
264 {
265 if (close ((int)(long)socket) == -1)
266 zlog_err ("close (%d): %s", (int)(long)socket, safe_strerror (errno));
267 }
268 list_delete (bm->listen_sockets);
269
270 /* reverse bgp_zebra_init/if_init */
271 if (retain_mode)
272 if_add_hook (IF_DELETE_HOOK, NULL);
273 for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
274 {
275 struct listnode *c_node, *c_nnode;
276 struct connected *c;
277
278 for (ALL_LIST_ELEMENTS (ifp->connected, c_node, c_nnode, c))
279 bgp_connected_delete (c);
280 }
281
282 /* reverse bgp_attr_init */
283 bgp_attr_finish ();
284
285 /* reverse bgp_dump_init */
286 bgp_dump_finish ();
287
288 /* reverse bgp_route_init */
289 bgp_route_finish ();
290
291 /* reverse bgp_route_map_init/route_map_init */
292 route_map_finish ();
293
294 /* reverse access_list_init */
295 access_list_add_hook (NULL);
296 access_list_delete_hook (NULL);
297 access_list_reset ();
298
299 /* reverse bgp_filter_init */
300 as_list_add_hook (NULL);
301 as_list_delete_hook (NULL);
302 bgp_filter_reset ();
303
304 /* reverse prefix_list_init */
305 prefix_list_add_hook (NULL);
306 prefix_list_delete_hook (NULL);
307 prefix_list_reset ();
308
309 /* reverse community_list_init */
310 community_list_terminate (bgp_clist);
311
312 vrf_terminate ();
313 cmd_terminate ();
314 vty_terminate ();
315 bgp_address_destroy();
316 bgp_scan_destroy();
317 bgp_zebra_destroy();
318 if (bgp_nexthop_buf)
319 stream_free (bgp_nexthop_buf);
320 if (bgp_ifindices_buf)
321 stream_free (bgp_ifindices_buf);
322
323 /* reverse bgp_scan_init */
324 bgp_scan_finish ();
325
326 /* reverse bgp_master_init */
327 if (bm->master)
328 thread_master_free (bm->master);
329
330 if (zlog_default)
331 closezlog (zlog_default);
332
333 if (CONF_BGP_DEBUG (normal, NORMAL))
334 log_memstats_stderr ("bgpd");
335
336 exit (status);
337 }
338
339 /* Main routine of bgpd. Treatment of argument and start bgp finite
340 state machine is handled at here. */
341 int
main(int argc,char ** argv)342 main (int argc, char **argv)
343 {
344 char *p;
345 int opt;
346 int daemon_mode = 0;
347 int dryrun = 0;
348 char *progname;
349 int tmp_port;
350 int skip_runas = 0;
351
352 /* Set umask before anything for security */
353 umask (0027);
354
355 /* Preserve name of myself. */
356 progname = ((p = strrchr (argv[0], '/')) ? ++p : argv[0]);
357
358 zlog_default = openzlog (progname, ZLOG_BGP,
359 LOG_CONS|LOG_NDELAY|LOG_PID, LOG_DAEMON);
360
361 /* BGP master init. */
362 bgp_master_init ();
363
364 /* Command line argument treatment. */
365 while (1)
366 {
367 opt = getopt_long (argc, argv, "df:i:z:hp:l:A:P:rnu:g:vCS", longopts, 0);
368
369 if (opt == EOF)
370 break;
371
372 switch (opt)
373 {
374 case 0:
375 break;
376 case 'd':
377 daemon_mode = 1;
378 break;
379 case 'f':
380 config_file = optarg;
381 break;
382 case 'i':
383 pid_file = optarg;
384 break;
385 case 'z':
386 zclient_serv_path_set (optarg);
387 break;
388 case 'p':
389 tmp_port = atoi (optarg);
390 if (tmp_port <= 0 || tmp_port > 0xffff)
391 bm->port = BGP_PORT_DEFAULT;
392 else
393 bm->port = tmp_port;
394 break;
395 case 'A':
396 vty_addr = optarg;
397 break;
398 case 'P':
399 /* Deal with atoi() returning 0 on failure, and bgpd not
400 listening on bgp port... */
401 if (strcmp(optarg, "0") == 0)
402 {
403 vty_port = 0;
404 break;
405 }
406 vty_port = atoi (optarg);
407 if (vty_port <= 0 || vty_port > 0xffff)
408 vty_port = BGP_VTY_PORT;
409 break;
410 case 'r':
411 retain_mode = 1;
412 break;
413 case 'l':
414 bm->address = optarg;
415 /* listenon implies -n */
416 case 'n':
417 bgp_option_set (BGP_OPT_NO_FIB);
418 break;
419 case 'u':
420 bgpd_privs.user = optarg;
421 break;
422 case 'g':
423 bgpd_privs.group = optarg;
424 break;
425 case 'S': /* skip run as = override bgpd_privs */
426 skip_runas = 1;
427 break;
428 case 'v':
429 print_version (progname);
430 exit (0);
431 break;
432 case 'C':
433 dryrun = 1;
434 break;
435 case 'h':
436 usage (progname, 0);
437 break;
438 default:
439 usage (progname, 1);
440 break;
441 }
442 }
443
444 /* Initializations. */
445 srandom (time (NULL));
446 signal_init (bm->master, array_size(bgp_signals), bgp_signals);
447 if (skip_runas)
448 memset (&bgpd_privs, 0, sizeof (bgpd_privs));
449 zprivs_init (&bgpd_privs);
450 cmd_init (1);
451 vty_init (bm->master);
452 memory_init ();
453 vrf_init ();
454
455 /* BGP related initialization. */
456 bgp_init ();
457
458 /* Parse config file. */
459 vty_read_config (config_file, config_default);
460
461 /* Start execution only if not in dry-run mode */
462 if(dryrun)
463 return(0);
464
465 /* Turn into daemon if daemon_mode is set. */
466 if (daemon_mode && daemon (0, 0) < 0)
467 {
468 zlog_err("BGPd daemon failed: %s", strerror(errno));
469 return (1);
470 }
471
472
473 /* Process ID file creation. */
474 pid_output (pid_file);
475
476 /* Make bgp vty socket. */
477 vty_serv_sock (vty_addr, vty_port, BGP_VTYSH_PATH);
478
479 /* Print banner. */
480 zlog_notice ("BGPd %s starting: vty@%d, bgp@%s:%d pid %d", QUAGGA_VERSION,
481 vty_port,
482 (bm->address ? bm->address : "<all>"),
483 bm->port,
484 getpid ());
485
486 /* Start finite state machine, here we go! */
487 thread_main (bm->master);
488
489 /* Not reached. */
490 return (0);
491 }
492