Annotation of embedaddon/quagga/ospfd/ospf_apiserver.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Server side of OSPF API.
3: * Copyright (C) 2001, 2002 Ralph Keller
4: *
5: * This file is part of GNU Zebra.
6: *
7: * GNU Zebra is free software; you can redistribute it and/or modify
8: * it under the terms of the GNU General Public License as published
9: * by the Free Software Foundation; either version 2, or (at your
10: * option) any later version.
11: *
12: * GNU Zebra is distributed in the hope that it will be useful, but
13: * WITHOUT ANY WARRANTY; without even the implied warranty of
14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15: * General Public License for more details.
16: *
17: * You should have received a copy of the GNU General Public License
18: * along with GNU Zebra; see the file COPYING. If not, write to the
19: * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20: * Boston, MA 02111-1307, USA.
21: */
22:
23: #include <zebra.h>
24:
25: #ifdef SUPPORT_OSPF_API
26: #ifndef HAVE_OPAQUE_LSA
27: #error "Core Opaque-LSA module must be configured."
28: #endif /* HAVE_OPAQUE_LSA */
29:
30: #include "linklist.h"
31: #include "prefix.h"
32: #include "if.h"
33: #include "table.h"
34: #include "memory.h"
35: #include "command.h"
36: #include "vty.h"
37: #include "stream.h"
38: #include "log.h"
39: #include "thread.h"
40: #include "hash.h"
41: #include "sockunion.h" /* for inet_aton() */
42: #include "buffer.h"
43:
44: #include <sys/types.h>
45:
46: #include "ospfd/ospfd.h" /* for "struct thread_master" */
47: #include "ospfd/ospf_interface.h"
48: #include "ospfd/ospf_ism.h"
49: #include "ospfd/ospf_asbr.h"
50: #include "ospfd/ospf_lsa.h"
51: #include "ospfd/ospf_lsdb.h"
52: #include "ospfd/ospf_neighbor.h"
53: #include "ospfd/ospf_nsm.h"
54: #include "ospfd/ospf_flood.h"
55: #include "ospfd/ospf_packet.h"
56: #include "ospfd/ospf_spf.h"
57: #include "ospfd/ospf_dump.h"
58: #include "ospfd/ospf_route.h"
59: #include "ospfd/ospf_ase.h"
60: #include "ospfd/ospf_zebra.h"
61:
62: #include "ospfd/ospf_api.h"
63: #include "ospfd/ospf_apiserver.h"
64:
65: /* This is an implementation of an API to the OSPF daemon that allows
66: * external applications to access the OSPF daemon through socket
67: * connections. The application can use this API to inject its own
68: * opaque LSAs and flood them to other OSPF daemons. Other OSPF
69: * daemons then receive these LSAs and inform applications through the
70: * API by sending a corresponding message. The application can also
71: * register to receive all LSA types (in addition to opaque types) and
72: * use this information to reconstruct the OSPF's LSDB. The OSPF
73: * daemon supports multiple applications concurrently. */
74:
75: /* List of all active connections. */
76: struct list *apiserver_list;
77:
78: /* -----------------------------------------------------------
79: * Functions to lookup interfaces
80: * -----------------------------------------------------------
81: */
82:
83: struct ospf_interface *
84: ospf_apiserver_if_lookup_by_addr (struct in_addr address)
85: {
86: struct listnode *node, *nnode;
87: struct ospf_interface *oi;
88: struct ospf *ospf;
89:
90: if (!(ospf = ospf_lookup ()))
91: return NULL;
92:
93: for (ALL_LIST_ELEMENTS (ospf->oiflist, node, nnode, oi))
94: if (oi->type != OSPF_IFTYPE_VIRTUALLINK)
95: if (IPV4_ADDR_SAME (&address, &oi->address->u.prefix4))
96: return oi;
97:
98: return NULL;
99: }
100:
101: struct ospf_interface *
102: ospf_apiserver_if_lookup_by_ifp (struct interface *ifp)
103: {
104: struct listnode *node, *nnode;
105: struct ospf_interface *oi;
106: struct ospf *ospf;
107:
108: if (!(ospf = ospf_lookup ()));
109: return NULL;
110:
111: for (ALL_LIST_ELEMENTS (ospf->oiflist, node, nnode, oi))
112: if (oi->ifp == ifp)
113: return oi;
114:
115: return NULL;
116: }
117:
118: /* -----------------------------------------------------------
119: * Initialization
120: * -----------------------------------------------------------
121: */
122:
123: unsigned short
124: ospf_apiserver_getport (void)
125: {
126: struct servent *sp = getservbyname ("ospfapi", "tcp");
127:
128: return sp ? ntohs (sp->s_port) : OSPF_API_SYNC_PORT;
129: }
130:
131: /* Initialize OSPF API module. Invoked from ospf_opaque_init() */
132: int
133: ospf_apiserver_init (void)
134: {
135: int fd;
136: int rc = -1;
137:
138: /* Create new socket for synchronous messages. */
139: fd = ospf_apiserver_serv_sock_family (ospf_apiserver_getport (), AF_INET);
140:
141: if (fd < 0)
142: goto out;
143:
144: /* Schedule new thread that handles accepted connections. */
145: ospf_apiserver_event (OSPF_APISERVER_ACCEPT, fd, NULL);
146:
147: /* Initialize list that keeps track of all connections. */
148: apiserver_list = list_new ();
149:
150: /* Register opaque-independent call back functions. These functions
151: are invoked on ISM, NSM changes and LSA update and LSA deletes */
152: rc =
153: ospf_register_opaque_functab (0 /* all LSAs */,
154: 0 /* all opaque types */,
155: ospf_apiserver_new_if,
156: ospf_apiserver_del_if,
157: ospf_apiserver_ism_change,
158: ospf_apiserver_nsm_change,
159: NULL,
160: NULL,
161: NULL,
162: NULL, /* ospf_apiserver_show_info */
163: NULL, /* originator_func */
164: NULL, /* ospf_apiserver_lsa_refresher */
165: ospf_apiserver_lsa_update,
166: ospf_apiserver_lsa_delete);
167: if (rc != 0)
168: {
169: zlog_warn ("ospf_apiserver_init: Failed to register opaque type [0/0]");
170: }
171:
172: rc = 0;
173:
174: out:
175: return rc;
176: }
177:
178: /* Terminate OSPF API module. */
179: void
180: ospf_apiserver_term (void)
181: {
182: struct ospf_apiserver *apiserv;
183:
184: /* Unregister wildcard [0/0] type */
185: ospf_delete_opaque_functab (0 /* all LSAs */,
186: 0 /* all opaque types */);
187:
188: /*
189: * Free all client instances. ospf_apiserver_free removes the node
190: * from the list, so we examine the head of the list anew each time.
191: */
192: while ( apiserver_list &&
193: (apiserv = listgetdata (listhead (apiserver_list))) != NULL)
194: ospf_apiserver_free (apiserv);
195:
196: /* Free client list itself */
197: if (apiserver_list)
198: list_delete (apiserver_list);
199:
200: /* Free wildcard list */
201: /* XXX */
202: }
203:
204: static struct ospf_apiserver *
205: lookup_apiserver (u_char lsa_type, u_char opaque_type)
206: {
207: struct listnode *n1, *n2;
208: struct registered_opaque_type *r;
209: struct ospf_apiserver *apiserv, *found = NULL;
210:
211: /* XXX: this approaches O(n**2) */
212: for (ALL_LIST_ELEMENTS_RO (apiserver_list, n1, apiserv))
213: {
214: for (ALL_LIST_ELEMENTS_RO (apiserv->opaque_types, n2, r))
215: if (r->lsa_type == lsa_type && r->opaque_type == opaque_type)
216: {
217: found = apiserv;
218: goto out;
219: }
220: }
221: out:
222: return found;
223: }
224:
225: static struct ospf_apiserver *
226: lookup_apiserver_by_lsa (struct ospf_lsa *lsa)
227: {
228: struct lsa_header *lsah = lsa->data;
229: struct ospf_apiserver *found = NULL;
230:
231: if (IS_OPAQUE_LSA (lsah->type))
232: {
233: found = lookup_apiserver (lsah->type,
234: GET_OPAQUE_TYPE (ntohl (lsah->id.s_addr)));
235: }
236: return found;
237: }
238:
239: /* -----------------------------------------------------------
240: * Followings are functions to manage client connections.
241: * -----------------------------------------------------------
242: */
243: static int
244: ospf_apiserver_new_lsa_hook (struct ospf_lsa *lsa)
245: {
246: if (IS_DEBUG_OSPF_EVENT)
247: zlog_debug ("API: Put LSA(%p)[%s] into reserve, total=%ld", lsa, dump_lsa_key (lsa), lsa->lsdb->total);
248: return 0;
249: }
250:
251: static int
252: ospf_apiserver_del_lsa_hook (struct ospf_lsa *lsa)
253: {
254: if (IS_DEBUG_OSPF_EVENT)
255: zlog_debug ("API: Get LSA(%p)[%s] from reserve, total=%ld", lsa, dump_lsa_key (lsa), lsa->lsdb->total);
256: return 0;
257: }
258:
259: /* Allocate new connection structure. */
260: struct ospf_apiserver *
261: ospf_apiserver_new (int fd_sync, int fd_async)
262: {
263: struct ospf_apiserver *new =
264: XMALLOC (MTYPE_OSPF_APISERVER, sizeof (struct ospf_apiserver));
265:
266: new->filter =
267: XMALLOC (MTYPE_OSPF_APISERVER_MSGFILTER, sizeof (struct lsa_filter_type));
268:
269: new->fd_sync = fd_sync;
270: new->fd_async = fd_async;
271:
272: /* list of registered opaque types that application uses */
273: new->opaque_types = list_new ();
274:
275: /* Initialize temporary strage for LSA instances to be refreshed. */
276: memset (&new->reserve, 0, sizeof (struct ospf_lsdb));
277: ospf_lsdb_init (&new->reserve);
278:
279: new->reserve.new_lsa_hook = ospf_apiserver_new_lsa_hook; /* debug */
280: new->reserve.del_lsa_hook = ospf_apiserver_del_lsa_hook; /* debug */
281:
282: new->out_sync_fifo = msg_fifo_new ();
283: new->out_async_fifo = msg_fifo_new ();
284: new->t_sync_read = NULL;
285: #ifdef USE_ASYNC_READ
286: new->t_async_read = NULL;
287: #endif /* USE_ASYNC_READ */
288: new->t_sync_write = NULL;
289: new->t_async_write = NULL;
290:
291: new->filter->typemask = 0; /* filter all LSAs */
292: new->filter->origin = ANY_ORIGIN;
293: new->filter->num_areas = 0;
294:
295: return new;
296: }
297:
298: void
299: ospf_apiserver_event (enum event event, int fd,
300: struct ospf_apiserver *apiserv)
301: {
302: struct thread *apiserver_serv_thread;
303:
304: switch (event)
305: {
306: case OSPF_APISERVER_ACCEPT:
307: apiserver_serv_thread =
308: thread_add_read (master, ospf_apiserver_accept, apiserv, fd);
309: break;
310: case OSPF_APISERVER_SYNC_READ:
311: apiserv->t_sync_read =
312: thread_add_read (master, ospf_apiserver_read, apiserv, fd);
313: break;
314: #ifdef USE_ASYNC_READ
315: case OSPF_APISERVER_ASYNC_READ:
316: apiserv->t_async_read =
317: thread_add_read (master, ospf_apiserver_read, apiserv, fd);
318: break;
319: #endif /* USE_ASYNC_READ */
320: case OSPF_APISERVER_SYNC_WRITE:
321: if (!apiserv->t_sync_write)
322: {
323: apiserv->t_sync_write =
324: thread_add_write (master, ospf_apiserver_sync_write, apiserv, fd);
325: }
326: break;
327: case OSPF_APISERVER_ASYNC_WRITE:
328: if (!apiserv->t_async_write)
329: {
330: apiserv->t_async_write =
331: thread_add_write (master, ospf_apiserver_async_write, apiserv, fd);
332: }
333: break;
334: }
335: }
336:
337: /* Free instance. First unregister all opaque types used by
338: application, flush opaque LSAs injected by application
339: from network and close connection. */
340: void
341: ospf_apiserver_free (struct ospf_apiserver *apiserv)
342: {
343: struct listnode *node;
344:
345: /* Cancel read and write threads. */
346: if (apiserv->t_sync_read)
347: {
348: thread_cancel (apiserv->t_sync_read);
349: }
350: #ifdef USE_ASYNC_READ
351: if (apiserv->t_async_read)
352: {
353: thread_cancel (apiserv->t_async_read);
354: }
355: #endif /* USE_ASYNC_READ */
356: if (apiserv->t_sync_write)
357: {
358: thread_cancel (apiserv->t_sync_write);
359: }
360:
361: if (apiserv->t_async_write)
362: {
363: thread_cancel (apiserv->t_async_write);
364: }
365:
366: /* Unregister all opaque types that application registered
367: and flush opaque LSAs if still in LSDB. */
368:
369: while ((node = listhead (apiserv->opaque_types)) != NULL)
370: {
371: struct registered_opaque_type *regtype = listgetdata(node);
372:
373: ospf_apiserver_unregister_opaque_type (apiserv, regtype->lsa_type,
374: regtype->opaque_type);
375:
376: }
377:
378: /* Close connections to OSPFd. */
379: if (apiserv->fd_sync > 0)
380: {
381: close (apiserv->fd_sync);
382: }
383:
384: if (apiserv->fd_async > 0)
385: {
386: close (apiserv->fd_async);
387: }
388:
389: /* Free fifos */
390: msg_fifo_free (apiserv->out_sync_fifo);
391: msg_fifo_free (apiserv->out_async_fifo);
392:
393: /* Clear temporary strage for LSA instances to be refreshed. */
394: ospf_lsdb_delete_all (&apiserv->reserve);
395: ospf_lsdb_cleanup (&apiserv->reserve);
396:
397: /* Remove from the list of active clients. */
398: listnode_delete (apiserver_list, apiserv);
399:
400: if (IS_DEBUG_OSPF_EVENT)
401: zlog_debug ("API: Delete apiserv(%p), total#(%d)", apiserv, apiserver_list->count);
402:
403: /* And free instance. */
404: XFREE (MTYPE_OSPF_APISERVER, apiserv);
405: }
406:
407: int
408: ospf_apiserver_read (struct thread *thread)
409: {
410: struct ospf_apiserver *apiserv;
411: struct msg *msg;
412: int fd;
413: int rc = -1;
414: enum event event;
415:
416: apiserv = THREAD_ARG (thread);
417: fd = THREAD_FD (thread);
418:
419: if (fd == apiserv->fd_sync)
420: {
421: event = OSPF_APISERVER_SYNC_READ;
422: apiserv->t_sync_read = NULL;
423:
424: if (IS_DEBUG_OSPF_EVENT)
425: zlog_debug ("API: ospf_apiserver_read: Peer: %s/%u",
426: inet_ntoa (apiserv->peer_sync.sin_addr),
427: ntohs (apiserv->peer_sync.sin_port));
428: }
429: #ifdef USE_ASYNC_READ
430: else if (fd == apiserv->fd_async)
431: {
432: event = OSPF_APISERVER_ASYNC_READ;
433: apiserv->t_async_read = NULL;
434:
435: if (IS_DEBUG_OSPF_EVENT)
436: zlog_debug ("API: ospf_apiserver_read: Peer: %s/%u",
437: inet_ntoa (apiserv->peer_async.sin_addr),
438: ntohs (apiserv->peer_async.sin_port));
439: }
440: #endif /* USE_ASYNC_READ */
441: else
442: {
443: zlog_warn ("ospf_apiserver_read: Unknown fd(%d)", fd);
444: ospf_apiserver_free (apiserv);
445: goto out;
446: }
447:
448: /* Read message from fd. */
449: msg = msg_read (fd);
450: if (msg == NULL)
451: {
452: zlog_warn
453: ("ospf_apiserver_read: read failed on fd=%d, closing connection", fd);
454:
455: /* Perform cleanup. */
456: ospf_apiserver_free (apiserv);
457: goto out;
458: }
459:
460: if (IS_DEBUG_OSPF_EVENT)
461: msg_print (msg);
462:
463: /* Dispatch to corresponding message handler. */
464: rc = ospf_apiserver_handle_msg (apiserv, msg);
465:
466: /* Prepare for next message, add read thread. */
467: ospf_apiserver_event (event, fd, apiserv);
468:
469: msg_free (msg);
470:
471: out:
472: return rc;
473: }
474:
475: int
476: ospf_apiserver_sync_write (struct thread *thread)
477: {
478: struct ospf_apiserver *apiserv;
479: struct msg *msg;
480: int fd;
481: int rc = -1;
482:
483: apiserv = THREAD_ARG (thread);
484: assert (apiserv);
485: fd = THREAD_FD (thread);
486:
487: apiserv->t_sync_write = NULL;
488:
489: /* Sanity check */
490: if (fd != apiserv->fd_sync)
491: {
492: zlog_warn ("ospf_apiserver_sync_write: Unknown fd=%d", fd);
493: goto out;
494: }
495:
496: if (IS_DEBUG_OSPF_EVENT)
497: zlog_debug ("API: ospf_apiserver_sync_write: Peer: %s/%u",
498: inet_ntoa (apiserv->peer_sync.sin_addr),
499: ntohs (apiserv->peer_sync.sin_port));
500:
501: /* Check whether there is really a message in the fifo. */
502: msg = msg_fifo_pop (apiserv->out_sync_fifo);
503: if (!msg)
504: {
505: zlog_warn ("API: ospf_apiserver_sync_write: No message in Sync-FIFO?");
506: return 0;
507: }
508:
509: if (IS_DEBUG_OSPF_EVENT)
510: msg_print (msg);
511:
512: rc = msg_write (fd, msg);
513:
514: /* Once a message is dequeued, it should be freed anyway. */
515: msg_free (msg);
516:
517: if (rc < 0)
518: {
519: zlog_warn
520: ("ospf_apiserver_sync_write: write failed on fd=%d", fd);
521: goto out;
522: }
523:
524:
525: /* If more messages are in sync message fifo, schedule write thread. */
526: if (msg_fifo_head (apiserv->out_sync_fifo))
527: {
528: ospf_apiserver_event (OSPF_APISERVER_SYNC_WRITE, apiserv->fd_sync,
529: apiserv);
530: }
531:
532: out:
533:
534: if (rc < 0)
535: {
536: /* Perform cleanup and disconnect with peer */
537: ospf_apiserver_free (apiserv);
538: }
539:
540: return rc;
541: }
542:
543:
544: int
545: ospf_apiserver_async_write (struct thread *thread)
546: {
547: struct ospf_apiserver *apiserv;
548: struct msg *msg;
549: int fd;
550: int rc = -1;
551:
552: apiserv = THREAD_ARG (thread);
553: assert (apiserv);
554: fd = THREAD_FD (thread);
555:
556: apiserv->t_async_write = NULL;
557:
558: /* Sanity check */
559: if (fd != apiserv->fd_async)
560: {
561: zlog_warn ("ospf_apiserver_async_write: Unknown fd=%d", fd);
562: goto out;
563: }
564:
565: if (IS_DEBUG_OSPF_EVENT)
566: zlog_debug ("API: ospf_apiserver_async_write: Peer: %s/%u",
567: inet_ntoa (apiserv->peer_async.sin_addr),
568: ntohs (apiserv->peer_async.sin_port));
569:
570: /* Check whether there is really a message in the fifo. */
571: msg = msg_fifo_pop (apiserv->out_async_fifo);
572: if (!msg)
573: {
574: zlog_warn ("API: ospf_apiserver_async_write: No message in Async-FIFO?");
575: return 0;
576: }
577:
578: if (IS_DEBUG_OSPF_EVENT)
579: msg_print (msg);
580:
581: rc = msg_write (fd, msg);
582:
583: /* Once a message is dequeued, it should be freed anyway. */
584: msg_free (msg);
585:
586: if (rc < 0)
587: {
588: zlog_warn
589: ("ospf_apiserver_async_write: write failed on fd=%d", fd);
590: goto out;
591: }
592:
593:
594: /* If more messages are in async message fifo, schedule write thread. */
595: if (msg_fifo_head (apiserv->out_async_fifo))
596: {
597: ospf_apiserver_event (OSPF_APISERVER_ASYNC_WRITE, apiserv->fd_async,
598: apiserv);
599: }
600:
601: out:
602:
603: if (rc < 0)
604: {
605: /* Perform cleanup and disconnect with peer */
606: ospf_apiserver_free (apiserv);
607: }
608:
609: return rc;
610: }
611:
612:
613: int
614: ospf_apiserver_serv_sock_family (unsigned short port, int family)
615: {
616: union sockunion su;
617: int accept_sock;
618: int rc;
619:
620: memset (&su, 0, sizeof (union sockunion));
621: su.sa.sa_family = family;
622:
623: /* Make new socket */
624: accept_sock = sockunion_stream_socket (&su);
625: if (accept_sock < 0)
626: return accept_sock;
627:
628: /* This is a server, so reuse address and port */
629: sockopt_reuseaddr (accept_sock);
630: sockopt_reuseport (accept_sock);
631:
632: /* Bind socket to address and given port. */
633: rc = sockunion_bind (accept_sock, &su, port, NULL);
634: if (rc < 0)
635: {
636: close (accept_sock); /* Close socket */
637: return rc;
638: }
639:
640: /* Listen socket under queue length 3. */
641: rc = listen (accept_sock, 3);
642: if (rc < 0)
643: {
644: zlog_warn ("ospf_apiserver_serv_sock_family: listen: %s",
645: safe_strerror (errno));
646: close (accept_sock); /* Close socket */
647: return rc;
648: }
649: return accept_sock;
650: }
651:
652:
653: /* Accept connection request from external applications. For each
654: accepted connection allocate own connection instance. */
655: int
656: ospf_apiserver_accept (struct thread *thread)
657: {
658: int accept_sock;
659: int new_sync_sock;
660: int new_async_sock;
661: union sockunion su;
662: struct ospf_apiserver *apiserv;
663: struct sockaddr_in peer_async;
664: struct sockaddr_in peer_sync;
665: unsigned int peerlen;
666: int ret;
667:
668: /* THREAD_ARG (thread) is NULL */
669: accept_sock = THREAD_FD (thread);
670:
671: /* Keep hearing on socket for further connections. */
672: ospf_apiserver_event (OSPF_APISERVER_ACCEPT, accept_sock, NULL);
673:
674: memset (&su, 0, sizeof (union sockunion));
675: /* Accept connection for synchronous messages */
676: new_sync_sock = sockunion_accept (accept_sock, &su);
677: if (new_sync_sock < 0)
678: {
679: zlog_warn ("ospf_apiserver_accept: accept: %s", safe_strerror (errno));
680: return -1;
681: }
682:
683: /* Get port address and port number of peer to make reverse connection.
684: The reverse channel uses the port number of the peer port+1. */
685:
686: memset(&peer_sync, 0, sizeof(struct sockaddr_in));
687: peerlen = sizeof (struct sockaddr_in);
688:
689: ret = getpeername (new_sync_sock, (struct sockaddr *)&peer_sync, &peerlen);
690: if (ret < 0)
691: {
692: zlog_warn ("ospf_apiserver_accept: getpeername: %s", safe_strerror (errno));
693: close (new_sync_sock);
694: return -1;
695: }
696:
697: if (IS_DEBUG_OSPF_EVENT)
698: zlog_debug ("API: ospf_apiserver_accept: New peer: %s/%u",
699: inet_ntoa (peer_sync.sin_addr), ntohs (peer_sync.sin_port));
700:
701: /* Create new socket for asynchronous messages. */
702: peer_async = peer_sync;
703: peer_async.sin_port = htons(ntohs(peer_sync.sin_port) + 1);
704:
705: /* Check if remote port number to make reverse connection is valid one. */
706: if (ntohs (peer_async.sin_port) == ospf_apiserver_getport ())
707: {
708: zlog_warn ("API: ospf_apiserver_accept: Peer(%s/%u): Invalid async port number?",
709: inet_ntoa (peer_async.sin_addr), ntohs (peer_async.sin_port));
710: close (new_sync_sock);
711: return -1;
712: }
713:
714: new_async_sock = socket (AF_INET, SOCK_STREAM, 0);
715: if (new_async_sock < 0)
716: {
717: zlog_warn ("ospf_apiserver_accept: socket: %s", safe_strerror (errno));
718: close (new_sync_sock);
719: return -1;
720: }
721:
722: ret = connect (new_async_sock, (struct sockaddr *) &peer_async,
723: sizeof (struct sockaddr_in));
724:
725: if (ret < 0)
726: {
727: zlog_warn ("ospf_apiserver_accept: connect: %s", safe_strerror (errno));
728: close (new_sync_sock);
729: close (new_async_sock);
730: return -1;
731: }
732:
733: #ifdef USE_ASYNC_READ
734: #else /* USE_ASYNC_READ */
735: /* Make the asynchronous channel write-only. */
736: ret = shutdown (new_async_sock, SHUT_RD);
737: if (ret < 0)
738: {
739: zlog_warn ("ospf_apiserver_accept: shutdown: %s", safe_strerror (errno));
740: close (new_sync_sock);
741: close (new_async_sock);
742: return -1;
743: }
744: #endif /* USE_ASYNC_READ */
745:
746: /* Allocate new server-side connection structure */
747: apiserv = ospf_apiserver_new (new_sync_sock, new_async_sock);
748:
749: /* Add to active connection list */
750: listnode_add (apiserver_list, apiserv);
751: apiserv->peer_sync = peer_sync;
752: apiserv->peer_async = peer_async;
753:
754: /* And add read threads for new connection */
755: ospf_apiserver_event (OSPF_APISERVER_SYNC_READ, new_sync_sock, apiserv);
756: #ifdef USE_ASYNC_READ
757: ospf_apiserver_event (OSPF_APISERVER_ASYNC_READ, new_async_sock, apiserv);
758: #endif /* USE_ASYNC_READ */
759:
760: if (IS_DEBUG_OSPF_EVENT)
761: zlog_debug ("API: New apiserv(%p), total#(%d)", apiserv, apiserver_list->count);
762:
763: return 0;
764: }
765:
766:
767: /* -----------------------------------------------------------
768: * Send reply with return code to client application
769: * -----------------------------------------------------------
770: */
771:
772: static int
773: ospf_apiserver_send_msg (struct ospf_apiserver *apiserv, struct msg *msg)
774: {
775: struct msg_fifo *fifo;
776: struct msg *msg2;
777: enum event event;
778: int fd;
779:
780: switch (msg->hdr.msgtype)
781: {
782: case MSG_REPLY:
783: fifo = apiserv->out_sync_fifo;
784: fd = apiserv->fd_sync;
785: event = OSPF_APISERVER_SYNC_WRITE;
786: break;
787: case MSG_READY_NOTIFY:
788: case MSG_LSA_UPDATE_NOTIFY:
789: case MSG_LSA_DELETE_NOTIFY:
790: case MSG_NEW_IF:
791: case MSG_DEL_IF:
792: case MSG_ISM_CHANGE:
793: case MSG_NSM_CHANGE:
794: fifo = apiserv->out_async_fifo;
795: fd = apiserv->fd_async;
796: event = OSPF_APISERVER_ASYNC_WRITE;
797: break;
798: default:
799: zlog_warn ("ospf_apiserver_send_msg: Unknown message type %d",
800: msg->hdr.msgtype);
801: return -1;
802: }
803:
804: /* Make a copy of the message and put in the fifo. Once the fifo
805: gets drained by the write thread, the message will be freed. */
806: /* NB: Given "msg" is untouched in this function. */
807: msg2 = msg_dup (msg);
808:
809: /* Enqueue message into corresponding fifo queue */
810: msg_fifo_push (fifo, msg2);
811:
812: /* Schedule write thread */
813: ospf_apiserver_event (event, fd, apiserv);
814: return 0;
815: }
816:
817: int
818: ospf_apiserver_send_reply (struct ospf_apiserver *apiserv, u_int32_t seqnr,
819: u_char rc)
820: {
821: struct msg *msg = new_msg_reply (seqnr, rc);
822: int ret;
823:
824: if (!msg)
825: {
826: zlog_warn ("ospf_apiserver_send_reply: msg_new failed");
827: #ifdef NOTYET
828: /* Cannot allocate new message. What should we do? */
829: ospf_apiserver_free (apiserv);
830: #endif
831: return -1;
832: }
833:
834: ret = ospf_apiserver_send_msg (apiserv, msg);
835: msg_free (msg);
836: return ret;
837: }
838:
839:
840: /* -----------------------------------------------------------
841: * Generic message dispatching handler function
842: * -----------------------------------------------------------
843: */
844:
845: int
846: ospf_apiserver_handle_msg (struct ospf_apiserver *apiserv, struct msg *msg)
847: {
848: int rc;
849:
850: /* Call corresponding message handler function. */
851: switch (msg->hdr.msgtype)
852: {
853: case MSG_REGISTER_OPAQUETYPE:
854: rc = ospf_apiserver_handle_register_opaque_type (apiserv, msg);
855: break;
856: case MSG_UNREGISTER_OPAQUETYPE:
857: rc = ospf_apiserver_handle_unregister_opaque_type (apiserv, msg);
858: break;
859: case MSG_REGISTER_EVENT:
860: rc = ospf_apiserver_handle_register_event (apiserv, msg);
861: break;
862: case MSG_SYNC_LSDB:
863: rc = ospf_apiserver_handle_sync_lsdb (apiserv, msg);
864: break;
865: case MSG_ORIGINATE_REQUEST:
866: rc = ospf_apiserver_handle_originate_request (apiserv, msg);
867: break;
868: case MSG_DELETE_REQUEST:
869: rc = ospf_apiserver_handle_delete_request (apiserv, msg);
870: break;
871: default:
872: zlog_warn ("ospf_apiserver_handle_msg: Unknown message type: %d",
873: msg->hdr.msgtype);
874: rc = -1;
875: }
876: return rc;
877: }
878:
879:
880: /* -----------------------------------------------------------
881: * Following are functions for opaque type registration
882: * -----------------------------------------------------------
883: */
884:
885: int
886: ospf_apiserver_register_opaque_type (struct ospf_apiserver *apiserv,
887: u_char lsa_type, u_char opaque_type)
888: {
889: struct registered_opaque_type *regtype;
890: int (*originator_func) (void *arg);
891: int rc;
892:
893: switch (lsa_type)
894: {
895: case OSPF_OPAQUE_LINK_LSA:
896: originator_func = ospf_apiserver_lsa9_originator;
897: break;
898: case OSPF_OPAQUE_AREA_LSA:
899: originator_func = ospf_apiserver_lsa10_originator;
900: break;
901: case OSPF_OPAQUE_AS_LSA:
902: originator_func = ospf_apiserver_lsa11_originator;
903: break;
904: default:
905: zlog_warn ("ospf_apiserver_register_opaque_type: lsa_type(%d)",
906: lsa_type);
907: return OSPF_API_ILLEGALLSATYPE;
908: }
909:
910:
911: /* Register opaque function table */
912: /* NB: Duplicated registration will be detected inside the function. */
913: rc =
914: ospf_register_opaque_functab (lsa_type, opaque_type,
915: NULL, /* ospf_apiserver_new_if */
916: NULL, /* ospf_apiserver_del_if */
917: NULL, /* ospf_apiserver_ism_change */
918: NULL, /* ospf_apiserver_nsm_change */
919: NULL,
920: NULL,
921: NULL,
922: ospf_apiserver_show_info,
923: originator_func,
924: ospf_apiserver_lsa_refresher,
925: NULL, /* ospf_apiserver_lsa_update */
926: NULL /* ospf_apiserver_lsa_delete */);
927:
928: if (rc != 0)
929: {
930: zlog_warn ("Failed to register opaque type [%d/%d]",
931: lsa_type, opaque_type);
932: return OSPF_API_OPAQUETYPEINUSE;
933: }
934:
935: /* Remember the opaque type that application registers so when
936: connection shuts down, we can flush all LSAs of this opaque
937: type. */
938:
939: regtype =
940: XCALLOC (MTYPE_OSPF_APISERVER, sizeof (struct registered_opaque_type));
941: regtype->lsa_type = lsa_type;
942: regtype->opaque_type = opaque_type;
943:
944: /* Add to list of registered opaque types */
945: listnode_add (apiserv->opaque_types, regtype);
946:
947: if (IS_DEBUG_OSPF_EVENT)
948: zlog_debug ("API: Add LSA-type(%d)/Opaque-type(%d) into"
949: " apiserv(%p), total#(%d)",
950: lsa_type, opaque_type, apiserv,
951: listcount (apiserv->opaque_types));
952:
953: return 0;
954: }
955:
956: int
957: ospf_apiserver_unregister_opaque_type (struct ospf_apiserver *apiserv,
958: u_char lsa_type, u_char opaque_type)
959: {
960: struct listnode *node, *nnode;
961: struct registered_opaque_type *regtype;
962:
963: for (ALL_LIST_ELEMENTS (apiserv->opaque_types, node, nnode, regtype))
964: {
965: /* Check if we really registered this opaque type */
966: if (regtype->lsa_type == lsa_type &&
967: regtype->opaque_type == opaque_type)
968: {
969:
970: /* Yes, we registered this opaque type. Flush
971: all existing opaque LSAs of this type */
972:
973: ospf_apiserver_flush_opaque_lsa (apiserv, lsa_type, opaque_type);
974: ospf_delete_opaque_functab (lsa_type, opaque_type);
975:
976: /* Remove from list of registered opaque types */
977: listnode_delete (apiserv->opaque_types, regtype);
978:
979: if (IS_DEBUG_OSPF_EVENT)
980: zlog_debug ("API: Del LSA-type(%d)/Opaque-type(%d)"
981: " from apiserv(%p), total#(%d)",
982: lsa_type, opaque_type, apiserv,
983: listcount (apiserv->opaque_types));
984:
985: return 0;
986: }
987: }
988:
989: /* Opaque type is not registered */
990: zlog_warn ("Failed to unregister opaque type [%d/%d]",
991: lsa_type, opaque_type);
992: return OSPF_API_OPAQUETYPENOTREGISTERED;
993: }
994:
995:
996: static int
997: apiserver_is_opaque_type_registered (struct ospf_apiserver *apiserv,
998: u_char lsa_type, u_char opaque_type)
999: {
1000: struct listnode *node, *nnode;
1001: struct registered_opaque_type *regtype;
1002:
1003: /* XXX: how many types are there? if few, why not just a bitmap? */
1004: for (ALL_LIST_ELEMENTS (apiserv->opaque_types, node, nnode, regtype))
1005: {
1006: /* Check if we really registered this opaque type */
1007: if (regtype->lsa_type == lsa_type &&
1008: regtype->opaque_type == opaque_type)
1009: {
1010: /* Yes registered */
1011: return 1;
1012: }
1013: }
1014: /* Not registered */
1015: return 0;
1016: }
1017:
1018: int
1019: ospf_apiserver_handle_register_opaque_type (struct ospf_apiserver *apiserv,
1020: struct msg *msg)
1021: {
1022: struct msg_register_opaque_type *rmsg;
1023: u_char lsa_type;
1024: u_char opaque_type;
1025: int rc = 0;
1026:
1027: /* Extract parameters from register opaque type message */
1028: rmsg = (struct msg_register_opaque_type *) STREAM_DATA (msg->s);
1029:
1030: lsa_type = rmsg->lsatype;
1031: opaque_type = rmsg->opaquetype;
1032:
1033: rc = ospf_apiserver_register_opaque_type (apiserv, lsa_type, opaque_type);
1034:
1035: /* Send a reply back to client including return code */
1036: rc = ospf_apiserver_send_reply (apiserv, ntohl (msg->hdr.msgseq), rc);
1037: if (rc < 0)
1038: goto out;
1039:
1040: /* Now inform application about opaque types that are ready */
1041: switch (lsa_type)
1042: {
1043: case OSPF_OPAQUE_LINK_LSA:
1044: ospf_apiserver_notify_ready_type9 (apiserv);
1045: break;
1046: case OSPF_OPAQUE_AREA_LSA:
1047: ospf_apiserver_notify_ready_type10 (apiserv);
1048: break;
1049: case OSPF_OPAQUE_AS_LSA:
1050: ospf_apiserver_notify_ready_type11 (apiserv);
1051: break;
1052: }
1053: out:
1054: return rc;
1055: }
1056:
1057:
1058: /* Notify specific client about all opaque types 9 that are ready. */
1059: void
1060: ospf_apiserver_notify_ready_type9 (struct ospf_apiserver *apiserv)
1061: {
1062: struct listnode *node, *nnode;
1063: struct listnode *node2, *nnode2;
1064: struct ospf *ospf;
1065: struct ospf_interface *oi;
1066: struct registered_opaque_type *r;
1067:
1068: ospf = ospf_lookup ();
1069:
1070: for (ALL_LIST_ELEMENTS (ospf->oiflist, node, nnode, oi))
1071: {
1072: /* Check if this interface is indeed ready for type 9 */
1073: if (!ospf_apiserver_is_ready_type9 (oi))
1074: continue;
1075:
1076: /* Check for registered opaque type 9 types */
1077: /* XXX: loop-de-loop - optimise me */
1078: for (ALL_LIST_ELEMENTS (apiserv->opaque_types, node2, nnode2, r))
1079: {
1080: struct msg *msg;
1081:
1082: if (r->lsa_type == OSPF_OPAQUE_LINK_LSA)
1083: {
1084:
1085: /* Yes, this opaque type is ready */
1086: msg = new_msg_ready_notify (0, OSPF_OPAQUE_LINK_LSA,
1087: r->opaque_type,
1088: oi->address->u.prefix4);
1089: if (!msg)
1090: {
1091: zlog_warn ("apiserver_notify_ready_type9: msg_new failed");
1092: #ifdef NOTYET
1093: /* Cannot allocate new message. What should we do? */
1094: ospf_apiserver_free (apiserv);
1095: #endif
1096: goto out;
1097: }
1098: ospf_apiserver_send_msg (apiserv, msg);
1099: msg_free (msg);
1100: }
1101: }
1102: }
1103:
1104: out:
1105: return;
1106: }
1107:
1108:
1109: /* Notify specific client about all opaque types 10 that are ready. */
1110: void
1111: ospf_apiserver_notify_ready_type10 (struct ospf_apiserver *apiserv)
1112: {
1113: struct listnode *node, *nnode;
1114: struct listnode *node2, *nnode2;
1115: struct ospf *ospf;
1116: struct ospf_area *area;
1117:
1118: ospf = ospf_lookup ();
1119:
1120: for (ALL_LIST_ELEMENTS (ospf->areas, node, nnode, area))
1121: {
1122: struct registered_opaque_type *r;
1123:
1124: if (!ospf_apiserver_is_ready_type10 (area))
1125: {
1126: continue;
1127: }
1128:
1129: /* Check for registered opaque type 10 types */
1130: /* XXX: loop in loop - optimise me */
1131: for (ALL_LIST_ELEMENTS (apiserv->opaque_types, node2, nnode2, r))
1132: {
1133: struct msg *msg;
1134:
1135: if (r->lsa_type == OSPF_OPAQUE_AREA_LSA)
1136: {
1137: /* Yes, this opaque type is ready */
1138: msg =
1139: new_msg_ready_notify (0, OSPF_OPAQUE_AREA_LSA,
1140: r->opaque_type, area->area_id);
1141: if (!msg)
1142: {
1143: zlog_warn ("apiserver_notify_ready_type10: msg_new failed");
1144: #ifdef NOTYET
1145: /* Cannot allocate new message. What should we do? */
1146: ospf_apiserver_free (apiserv);
1147: #endif
1148: goto out;
1149: }
1150: ospf_apiserver_send_msg (apiserv, msg);
1151: msg_free (msg);
1152: }
1153: }
1154: }
1155:
1156: out:
1157: return;
1158: }
1159:
1160: /* Notify specific client about all opaque types 11 that are ready */
1161: void
1162: ospf_apiserver_notify_ready_type11 (struct ospf_apiserver *apiserv)
1163: {
1164: struct listnode *node, *nnode;
1165: struct ospf *ospf;
1166: struct registered_opaque_type *r;
1167:
1168: ospf = ospf_lookup ();
1169:
1170: /* Can type 11 be originated? */
1171: if (!ospf_apiserver_is_ready_type11 (ospf))
1172: goto out;
1173:
1174: /* Check for registered opaque type 11 types */
1175: for (ALL_LIST_ELEMENTS (apiserv->opaque_types, node, nnode, r))
1176: {
1177: struct msg *msg;
1178: struct in_addr noarea_id = { .s_addr = 0L };
1179:
1180: if (r->lsa_type == OSPF_OPAQUE_AS_LSA)
1181: {
1182: /* Yes, this opaque type is ready */
1183: msg = new_msg_ready_notify (0, OSPF_OPAQUE_AS_LSA,
1184: r->opaque_type, noarea_id);
1185:
1186: if (!msg)
1187: {
1188: zlog_warn ("apiserver_notify_ready_type11: msg_new failed");
1189: #ifdef NOTYET
1190: /* Cannot allocate new message. What should we do? */
1191: ospf_apiserver_free (apiserv);
1192: #endif
1193: goto out;
1194: }
1195: ospf_apiserver_send_msg (apiserv, msg);
1196: msg_free (msg);
1197: }
1198: }
1199:
1200: out:
1201: return;
1202: }
1203:
1204: int
1205: ospf_apiserver_handle_unregister_opaque_type (struct ospf_apiserver *apiserv,
1206: struct msg *msg)
1207: {
1208: struct msg_unregister_opaque_type *umsg;
1209: u_char ltype;
1210: u_char otype;
1211: int rc = 0;
1212:
1213: /* Extract parameters from unregister opaque type message */
1214: umsg = (struct msg_unregister_opaque_type *) STREAM_DATA (msg->s);
1215:
1216: ltype = umsg->lsatype;
1217: otype = umsg->opaquetype;
1218:
1219: rc = ospf_apiserver_unregister_opaque_type (apiserv, ltype, otype);
1220:
1221: /* Send a reply back to client including return code */
1222: rc = ospf_apiserver_send_reply (apiserv, ntohl (msg->hdr.msgseq), rc);
1223:
1224: return rc;
1225: }
1226:
1227:
1228: /* -----------------------------------------------------------
1229: * Following are functions for event (filter) registration.
1230: * -----------------------------------------------------------
1231: */
1232: int
1233: ospf_apiserver_handle_register_event (struct ospf_apiserver *apiserv,
1234: struct msg *msg)
1235: {
1236: struct msg_register_event *rmsg;
1237: int rc;
1238: u_int32_t seqnum;
1239:
1240: rmsg = (struct msg_register_event *) STREAM_DATA (msg->s);
1241:
1242: /* Get request sequence number */
1243: seqnum = msg_get_seq (msg);
1244:
1245: /* Free existing filter in apiserv. */
1246: XFREE (MTYPE_OSPF_APISERVER_MSGFILTER, apiserv->filter);
1247: /* Alloc new space for filter. */
1248:
1249: apiserv->filter = XMALLOC (MTYPE_OSPF_APISERVER_MSGFILTER,
1250: ntohs (msg->hdr.msglen));
1251: if (apiserv->filter)
1252: {
1253: /* copy it over. */
1254: memcpy (apiserv->filter, &rmsg->filter, ntohs (msg->hdr.msglen));
1255: rc = OSPF_API_OK;
1256: }
1257: else
1258: {
1259: rc = OSPF_API_NOMEMORY;
1260: }
1261: /* Send a reply back to client with return code */
1262: rc = ospf_apiserver_send_reply (apiserv, seqnum, rc);
1263: return rc;
1264: }
1265:
1266:
1267: /* -----------------------------------------------------------
1268: * Followings are functions for LSDB synchronization.
1269: * -----------------------------------------------------------
1270: */
1271:
1272: static int
1273: apiserver_sync_callback (struct ospf_lsa *lsa, void *p_arg, int int_arg)
1274: {
1275: struct ospf_apiserver *apiserv;
1276: int seqnum;
1277: struct msg *msg;
1278: struct param_t
1279: {
1280: struct ospf_apiserver *apiserv;
1281: struct lsa_filter_type *filter;
1282: }
1283: *param;
1284: int rc = -1;
1285:
1286: /* Sanity check */
1287: assert (lsa->data);
1288: assert (p_arg);
1289:
1290: param = (struct param_t *) p_arg;
1291: apiserv = param->apiserv;
1292: seqnum = (u_int32_t) int_arg;
1293:
1294: /* Check origin in filter. */
1295: if ((param->filter->origin == ANY_ORIGIN) ||
1296: (param->filter->origin == (lsa->flags & OSPF_LSA_SELF)))
1297: {
1298:
1299: /* Default area for AS-External and Opaque11 LSAs */
1300: struct in_addr area_id = { .s_addr = 0L };
1301:
1302: /* Default interface for non Opaque9 LSAs */
1303: struct in_addr ifaddr = { .s_addr = 0L };
1304:
1305: if (lsa->area)
1306: {
1307: area_id = lsa->area->area_id;
1308: }
1309: if (lsa->data->type == OSPF_OPAQUE_LINK_LSA)
1310: {
1311: ifaddr = lsa->oi->address->u.prefix4;
1312: }
1313:
1314: msg = new_msg_lsa_change_notify (MSG_LSA_UPDATE_NOTIFY,
1315: seqnum,
1316: ifaddr, area_id,
1317: lsa->flags & OSPF_LSA_SELF, lsa->data);
1318: if (!msg)
1319: {
1320: zlog_warn ("apiserver_sync_callback: new_msg_update failed");
1321: #ifdef NOTYET
1322: /* Cannot allocate new message. What should we do? */
1323: /* ospf_apiserver_free (apiserv);*//* Do nothing here XXX */
1324: #endif
1325: goto out;
1326: }
1327:
1328: /* Send LSA */
1329: ospf_apiserver_send_msg (apiserv, msg);
1330: msg_free (msg);
1331: }
1332: rc = 0;
1333:
1334: out:
1335: return rc;
1336: }
1337:
1338: int
1339: ospf_apiserver_handle_sync_lsdb (struct ospf_apiserver *apiserv,
1340: struct msg *msg)
1341: {
1342: struct listnode *node, *nnode;
1343: u_int32_t seqnum;
1344: int rc = 0;
1345: struct msg_sync_lsdb *smsg;
1346: struct ospf_apiserver_param_t
1347: {
1348: struct ospf_apiserver *apiserv;
1349: struct lsa_filter_type *filter;
1350: } param;
1351: u_int16_t mask;
1352: struct route_node *rn;
1353: struct ospf_lsa *lsa;
1354: struct ospf *ospf;
1355: struct ospf_area *area;
1356:
1357: ospf = ospf_lookup ();
1358:
1359: /* Get request sequence number */
1360: seqnum = msg_get_seq (msg);
1361: /* Set sync msg. */
1362: smsg = (struct msg_sync_lsdb *) STREAM_DATA (msg->s);
1363:
1364: /* Set parameter struct. */
1365: param.apiserv = apiserv;
1366: param.filter = &smsg->filter;
1367:
1368: /* Remember mask. */
1369: mask = ntohs (smsg->filter.typemask);
1370:
1371: /* Iterate over all areas. */
1372: for (ALL_LIST_ELEMENTS (ospf->areas, node, nnode, area))
1373: {
1374: int i;
1375: u_int32_t *area_id = NULL;
1376:
1377: /* Compare area_id with area_ids in sync request. */
1378: if ((i = smsg->filter.num_areas) > 0)
1379: {
1380: /* Let area_id point to the list of area IDs,
1381: * which is at the end of smsg->filter. */
1382: area_id = (u_int32_t *) (&smsg->filter + 1);
1383: while (i)
1384: {
1385: if (*area_id == area->area_id.s_addr)
1386: {
1387: break;
1388: }
1389: i--;
1390: area_id++;
1391: }
1392: }
1393: else
1394: {
1395: i = 1;
1396: }
1397:
1398: /* If area was found, then i>0 here. */
1399: if (i)
1400: {
1401: /* Check msg type. */
1402: if (mask & Power2[OSPF_ROUTER_LSA])
1403: LSDB_LOOP (ROUTER_LSDB (area), rn, lsa)
1404: apiserver_sync_callback(lsa, (void *) ¶m, seqnum);
1405: if (mask & Power2[OSPF_NETWORK_LSA])
1406: LSDB_LOOP (NETWORK_LSDB (area), rn, lsa)
1407: apiserver_sync_callback(lsa, (void *) ¶m, seqnum);
1408: if (mask & Power2[OSPF_SUMMARY_LSA])
1409: LSDB_LOOP (SUMMARY_LSDB (area), rn, lsa)
1410: apiserver_sync_callback(lsa, (void *) ¶m, seqnum);
1411: if (mask & Power2[OSPF_ASBR_SUMMARY_LSA])
1412: LSDB_LOOP (ASBR_SUMMARY_LSDB (area), rn, lsa)
1413: apiserver_sync_callback(lsa, (void *) ¶m, seqnum);
1414: if (mask & Power2[OSPF_OPAQUE_LINK_LSA])
1415: LSDB_LOOP (OPAQUE_LINK_LSDB (area), rn, lsa)
1416: apiserver_sync_callback(lsa, (void *) ¶m, seqnum);
1417: if (mask & Power2[OSPF_OPAQUE_AREA_LSA])
1418: LSDB_LOOP (OPAQUE_AREA_LSDB (area), rn, lsa)
1419: apiserver_sync_callback(lsa, (void *) ¶m, seqnum);
1420: }
1421: }
1422:
1423: /* For AS-external LSAs */
1424: if (ospf->lsdb)
1425: {
1426: if (mask & Power2[OSPF_AS_EXTERNAL_LSA])
1427: LSDB_LOOP (EXTERNAL_LSDB (ospf), rn, lsa)
1428: apiserver_sync_callback(lsa, (void *) ¶m, seqnum);
1429: }
1430:
1431: /* For AS-external opaque LSAs */
1432: if (ospf->lsdb)
1433: {
1434: if (mask & Power2[OSPF_OPAQUE_AS_LSA])
1435: LSDB_LOOP (OPAQUE_AS_LSDB (ospf), rn, lsa)
1436: apiserver_sync_callback(lsa, (void *) ¶m, seqnum);
1437: }
1438:
1439: /* Send a reply back to client with return code */
1440: rc = ospf_apiserver_send_reply (apiserv, seqnum, rc);
1441: return rc;
1442: }
1443:
1444:
1445: /* -----------------------------------------------------------
1446: * Followings are functions to originate or update LSA
1447: * from an application.
1448: * -----------------------------------------------------------
1449: */
1450:
1451: /* Create a new internal opaque LSA by taking prototype and filling in
1452: missing fields such as age, sequence number, advertising router,
1453: checksum and so on. The interface parameter is used for type 9
1454: LSAs, area parameter for type 10. Type 11 LSAs do neither need area
1455: nor interface. */
1456:
1457: struct ospf_lsa *
1458: ospf_apiserver_opaque_lsa_new (struct ospf_area *area,
1459: struct ospf_interface *oi,
1460: struct lsa_header *protolsa)
1461: {
1462: struct stream *s;
1463: struct lsa_header *newlsa;
1464: struct ospf_lsa *new = NULL;
1465: u_char options = 0x0;
1466: u_int16_t length;
1467:
1468: struct ospf *ospf;
1469:
1470: ospf = ospf_lookup();
1471: assert(ospf);
1472:
1473: /* Create a stream for internal opaque LSA */
1474: if ((s = stream_new (OSPF_MAX_LSA_SIZE)) == NULL)
1475: {
1476: zlog_warn ("ospf_apiserver_opaque_lsa_new: stream_new failed");
1477: return NULL;
1478: }
1479:
1480: newlsa = (struct lsa_header *) STREAM_DATA (s);
1481:
1482: /* XXX If this is a link-local LSA or an AS-external LSA, how do we
1483: have to set options? */
1484:
1485: if (area)
1486: {
1487: options = LSA_OPTIONS_GET (area);
1488: options |= LSA_OPTIONS_NSSA_GET (area);
1489: }
1490:
1491: options |= OSPF_OPTION_O; /* Don't forget to set option bit */
1492:
1493: if (IS_DEBUG_OSPF (lsa, LSA_GENERATE))
1494: {
1495: zlog_debug ("LSA[Type%d:%s]: Creating an Opaque-LSA instance",
1496: protolsa->type, inet_ntoa (protolsa->id));
1497: }
1498:
1499: /* Set opaque-LSA header fields. */
1500: lsa_header_set (s, options, protolsa->type, protolsa->id,
1501: ospf->router_id);
1502:
1503: /* Set opaque-LSA body fields. */
1504: stream_put (s, ((u_char *) protolsa) + sizeof (struct lsa_header),
1505: ntohs (protolsa->length) - sizeof (struct lsa_header));
1506:
1507: /* Determine length of LSA. */
1508: length = stream_get_endp (s);
1509: newlsa->length = htons (length);
1510:
1511: /* Create OSPF LSA. */
1512: if ((new = ospf_lsa_new ()) == NULL)
1513: {
1514: zlog_warn ("ospf_apiserver_opaque_lsa_new: ospf_lsa_new() ?");
1515: stream_free (s);
1516: return NULL;
1517: }
1518:
1519: if ((new->data = ospf_lsa_data_new (length)) == NULL)
1520: {
1521: zlog_warn ("ospf_apiserver_opaque_lsa_new: ospf_lsa_data_new() ?");
1522: ospf_lsa_unlock (&new);
1523: stream_free (s);
1524: return NULL;
1525: }
1526:
1527: new->area = area;
1528: new->oi = oi;
1529:
1530: SET_FLAG (new->flags, OSPF_LSA_SELF);
1531: memcpy (new->data, newlsa, length);
1532: stream_free (s);
1533:
1534: return new;
1535: }
1536:
1537:
1538: int
1539: ospf_apiserver_is_ready_type9 (struct ospf_interface *oi)
1540: {
1541: /* Type 9 opaque LSA can be originated if there is at least one
1542: active opaque-capable neighbor attached to the outgoing
1543: interface. */
1544:
1545: return (ospf_nbr_count_opaque_capable (oi) > 0);
1546: }
1547:
1548: int
1549: ospf_apiserver_is_ready_type10 (struct ospf_area *area)
1550: {
1551: /* Type 10 opaque LSA can be originated if there is at least one
1552: interface belonging to the area that has an active opaque-capable
1553: neighbor. */
1554: struct listnode *node, *nnode;
1555: struct ospf_interface *oi;
1556:
1557: for (ALL_LIST_ELEMENTS (area->oiflist, node, nnode, oi))
1558: /* Is there an active neighbor attached to this interface? */
1559: if (ospf_apiserver_is_ready_type9 (oi))
1560: return 1;
1561:
1562: /* No active neighbor in area */
1563: return 0;
1564: }
1565:
1566: int
1567: ospf_apiserver_is_ready_type11 (struct ospf *ospf)
1568: {
1569: /* Type 11 opaque LSA can be originated if there is at least one interface
1570: that has an active opaque-capable neighbor. */
1571: struct listnode *node, *nnode;
1572: struct ospf_interface *oi;
1573:
1574: for (ALL_LIST_ELEMENTS (ospf->oiflist, node, nnode, oi))
1575: /* Is there an active neighbor attached to this interface? */
1576: if (ospf_apiserver_is_ready_type9 (oi))
1577: return 1;
1578:
1579: /* No active neighbor at all */
1580: return 0;
1581: }
1582:
1583:
1584: int
1585: ospf_apiserver_handle_originate_request (struct ospf_apiserver *apiserv,
1586: struct msg *msg)
1587: {
1588: struct msg_originate_request *omsg;
1589: struct lsa_header *data;
1590: struct ospf_lsa *new;
1591: struct ospf_lsa *old;
1592: struct ospf_area *area = NULL;
1593: struct ospf_interface *oi = NULL;
1594: struct ospf_lsdb *lsdb = NULL;
1595: struct ospf *ospf;
1596: int lsa_type, opaque_type;
1597: int ready = 0;
1598: int rc = 0;
1599:
1600: ospf = ospf_lookup();
1601:
1602: /* Extract opaque LSA data from message */
1603: omsg = (struct msg_originate_request *) STREAM_DATA (msg->s);
1604: data = &omsg->data;
1605:
1606: /* Determine interface for type9 or area for type10 LSAs. */
1607: switch (data->type)
1608: {
1609: case OSPF_OPAQUE_LINK_LSA:
1610: oi = ospf_apiserver_if_lookup_by_addr (omsg->ifaddr);
1611: if (!oi)
1612: {
1613: zlog_warn ("apiserver_originate: unknown interface %s",
1614: inet_ntoa (omsg->ifaddr));
1615: rc = OSPF_API_NOSUCHINTERFACE;
1616: goto out;
1617: }
1618: area = oi->area;
1619: lsdb = area->lsdb;
1620: break;
1621: case OSPF_OPAQUE_AREA_LSA:
1622: area = ospf_area_lookup_by_area_id (ospf, omsg->area_id);
1623: if (!area)
1624: {
1625: zlog_warn ("apiserver_originate: unknown area %s",
1626: inet_ntoa (omsg->area_id));
1627: rc = OSPF_API_NOSUCHAREA;
1628: goto out;
1629: }
1630: lsdb = area->lsdb;
1631: break;
1632: case OSPF_OPAQUE_AS_LSA:
1633: lsdb = ospf->lsdb;
1634: break;
1635: default:
1636: /* We can only handle opaque types here */
1637: zlog_warn ("apiserver_originate: Cannot originate non-opaque LSA type %d",
1638: data->type);
1639: rc = OSPF_API_ILLEGALLSATYPE;
1640: goto out;
1641: }
1642:
1643: /* Check if we registered this opaque type */
1644: lsa_type = data->type;
1645: opaque_type = GET_OPAQUE_TYPE (ntohl (data->id.s_addr));
1646:
1647: if (!apiserver_is_opaque_type_registered (apiserv, lsa_type, opaque_type))
1648: {
1649: zlog_warn ("apiserver_originate: LSA-type(%d)/Opaque-type(%d): Not registered", lsa_type, opaque_type);
1650: rc = OSPF_API_OPAQUETYPENOTREGISTERED;
1651: goto out;
1652: }
1653:
1654: /* Make sure that the neighbors are ready before we can originate */
1655: switch (data->type)
1656: {
1657: case OSPF_OPAQUE_LINK_LSA:
1658: ready = ospf_apiserver_is_ready_type9 (oi);
1659: break;
1660: case OSPF_OPAQUE_AREA_LSA:
1661: ready = ospf_apiserver_is_ready_type10 (area);
1662: break;
1663: case OSPF_OPAQUE_AS_LSA:
1664: ready = ospf_apiserver_is_ready_type11 (ospf);
1665: break;
1666: default:
1667: break;
1668: }
1669:
1670: if (!ready)
1671: {
1672: zlog_warn ("Neighbors not ready to originate type %d", data->type);
1673: rc = OSPF_API_NOTREADY;
1674: goto out;
1675: }
1676:
1677: /* Create OSPF's internal opaque LSA representation */
1678: new = ospf_apiserver_opaque_lsa_new (area, oi, data);
1679: if (!new)
1680: {
1681: rc = OSPF_API_NOMEMORY; /* XXX */
1682: goto out;
1683: }
1684:
1685: /* Determine if LSA is new or an update for an existing one. */
1686: old = ospf_lsdb_lookup (lsdb, new);
1687:
1688: if (!old)
1689: {
1690: /* New LSA install in LSDB. */
1691: rc = ospf_apiserver_originate1 (new);
1692: }
1693: else
1694: {
1695: /*
1696: * Keep the new LSA instance in the "waiting place" until the next
1697: * refresh timing. If several LSA update requests for the same LSID
1698: * have issued by peer, the last one takes effect.
1699: */
1700: new->lsdb = &apiserv->reserve;
1701: ospf_lsdb_add (&apiserv->reserve, new);
1702:
1703: /* Kick the scheduler function. */
1704: ospf_opaque_lsa_refresh_schedule (old);
1705: }
1706:
1707: out:
1708:
1709: /* Send a reply back to client with return code */
1710: rc = ospf_apiserver_send_reply (apiserv, ntohl (msg->hdr.msgseq), rc);
1711: return rc;
1712: }
1713:
1714:
1715: /* -----------------------------------------------------------
1716: * Flood an LSA within its flooding scope.
1717: * -----------------------------------------------------------
1718: */
1719:
1720: /* XXX We can probably use ospf_flood_through instead of this function
1721: but then we need the neighbor parameter. If we set nbr to
1722: NULL then ospf_flood_through crashes due to dereferencing NULL. */
1723:
1724: void
1725: ospf_apiserver_flood_opaque_lsa (struct ospf_lsa *lsa)
1726: {
1727: assert (lsa);
1728:
1729: switch (lsa->data->type)
1730: {
1731: case OSPF_OPAQUE_LINK_LSA:
1732: /* Increment counters? XXX */
1733:
1734: /* Flood LSA through local network. */
1735: ospf_flood_through_area (lsa->area, NULL /*nbr */ , lsa);
1736: break;
1737: case OSPF_OPAQUE_AREA_LSA:
1738: /* Update LSA origination count. */
1739: assert (lsa->area);
1740: lsa->area->ospf->lsa_originate_count++;
1741:
1742: /* Flood LSA through area. */
1743: ospf_flood_through_area (lsa->area, NULL /*nbr */ , lsa);
1744: break;
1745: case OSPF_OPAQUE_AS_LSA:
1746: {
1747: struct ospf *ospf;
1748:
1749: ospf = ospf_lookup();
1750: assert(ospf);
1751:
1752: /* Increment counters? XXX */
1753:
1754: /* Flood LSA through AS. */
1755: ospf_flood_through_as (ospf, NULL /*nbr */ , lsa);
1756: break;
1757: }
1758: }
1759: }
1760:
1761: int
1762: ospf_apiserver_originate1 (struct ospf_lsa *lsa)
1763: {
1764: struct ospf *ospf;
1765:
1766: ospf = ospf_lookup();
1767: assert(ospf);
1768:
1769: /* Install this LSA into LSDB. */
1770: if (ospf_lsa_install (ospf, lsa->oi, lsa) == NULL)
1771: {
1772: zlog_warn ("ospf_apiserver_originate1: ospf_lsa_install failed");
1773: return -1;
1774: }
1775:
1776: /* Flood LSA within scope */
1777:
1778: #ifdef NOTYET
1779: /*
1780: * NB: Modified version of "ospf_flood_though ()" accepts NULL "inbr"
1781: * parameter, and thus it does not cause SIGSEGV error.
1782: */
1783: ospf_flood_through (NULL /*nbr */ , lsa);
1784: #else /* NOTYET */
1785:
1786: ospf_apiserver_flood_opaque_lsa (lsa);
1787: #endif /* NOTYET */
1788:
1789: return 0;
1790: }
1791:
1792:
1793: /* Opaque LSAs of type 9 on a specific interface can now be
1794: originated. Tell clients that registered type 9. */
1795: int
1796: ospf_apiserver_lsa9_originator (void *arg)
1797: {
1798: struct ospf_interface *oi;
1799:
1800: oi = (struct ospf_interface *) arg;
1801: if (listcount (apiserver_list) > 0) {
1802: ospf_apiserver_clients_notify_ready_type9 (oi);
1803: }
1804: return 0;
1805: }
1806:
1807: int
1808: ospf_apiserver_lsa10_originator (void *arg)
1809: {
1810: struct ospf_area *area;
1811:
1812: area = (struct ospf_area *) arg;
1813: if (listcount (apiserver_list) > 0) {
1814: ospf_apiserver_clients_notify_ready_type10 (area);
1815: }
1816: return 0;
1817: }
1818:
1819: int
1820: ospf_apiserver_lsa11_originator (void *arg)
1821: {
1822: struct ospf *ospf;
1823:
1824: ospf = (struct ospf *) arg;
1825: if (listcount (apiserver_list) > 0) {
1826: ospf_apiserver_clients_notify_ready_type11 (ospf);
1827: }
1828: return 0;
1829: }
1830:
1831:
1832: /* Periodically refresh opaque LSAs so that they do not expire in
1833: other routers. */
1834: struct ospf_lsa *
1835: ospf_apiserver_lsa_refresher (struct ospf_lsa *lsa)
1836: {
1837: struct ospf_apiserver *apiserv;
1838: struct ospf_lsa *new = NULL;
1839: struct ospf * ospf;
1840:
1841: ospf = ospf_lookup();
1842: assert(ospf);
1843:
1844: apiserv = lookup_apiserver_by_lsa (lsa);
1845: if (!apiserv)
1846: {
1847: zlog_warn ("ospf_apiserver_lsa_refresher: LSA[%s]: No apiserver?", dump_lsa_key (lsa));
1848: lsa->data->ls_age = htons (OSPF_LSA_MAXAGE); /* Flush it anyway. */
1849: }
1850:
1851: if (IS_LSA_MAXAGE (lsa))
1852: {
1853: ospf_opaque_lsa_flush_schedule (lsa);
1854: goto out;
1855: }
1856:
1857: /* Check if updated version of LSA instance has already prepared. */
1858: new = ospf_lsdb_lookup (&apiserv->reserve, lsa);
1859: if (!new)
1860: {
1861: /* This is a periodic refresh, driven by core OSPF mechanism. */
1862: new = ospf_apiserver_opaque_lsa_new (lsa->area, lsa->oi, lsa->data);
1863: if (!new)
1864: {
1865: zlog_warn ("ospf_apiserver_lsa_refresher: Cannot create a new LSA?");
1866: goto out;
1867: }
1868: }
1869: else
1870: {
1871: /* This is a forcible refresh, requested by OSPF-API client. */
1872: ospf_lsdb_delete (&apiserv->reserve, new);
1873: new->lsdb = NULL;
1874: }
1875:
1876: /* Increment sequence number */
1877: new->data->ls_seqnum = lsa_seqnum_increment (lsa);
1878:
1879: /* New LSA is in same area. */
1880: new->area = lsa->area;
1881: SET_FLAG (new->flags, OSPF_LSA_SELF);
1882:
1883: /* Install LSA into LSDB. */
1884: if (ospf_lsa_install (ospf, new->oi, new) == NULL)
1885: {
1886: zlog_warn ("ospf_apiserver_lsa_refresher: ospf_lsa_install failed");
1887: ospf_lsa_unlock (&new);
1888: goto out;
1889: }
1890:
1891: /* Flood updated LSA through interface, area or AS */
1892:
1893: #ifdef NOTYET
1894: ospf_flood_through (NULL /*nbr */ , new);
1895: #endif /* NOTYET */
1896: ospf_apiserver_flood_opaque_lsa (new);
1897:
1898: /* Debug logging. */
1899: if (IS_DEBUG_OSPF (lsa, LSA_GENERATE))
1900: {
1901: zlog_debug ("LSA[Type%d:%s]: Refresh Opaque LSA",
1902: new->data->type, inet_ntoa (new->data->id));
1903: ospf_lsa_header_dump (new->data);
1904: }
1905:
1906: out:
1907: return new;
1908: }
1909:
1910:
1911: /* -----------------------------------------------------------
1912: * Followings are functions to delete LSAs
1913: * -----------------------------------------------------------
1914: */
1915:
1916: int
1917: ospf_apiserver_handle_delete_request (struct ospf_apiserver *apiserv,
1918: struct msg *msg)
1919: {
1920: struct msg_delete_request *dmsg;
1921: struct ospf_lsa *old;
1922: struct ospf_area *area = NULL;
1923: struct in_addr id;
1924: int lsa_type, opaque_type;
1925: int rc = 0;
1926: struct ospf * ospf;
1927:
1928: ospf = ospf_lookup();
1929: assert(ospf);
1930:
1931: /* Extract opaque LSA from message */
1932: dmsg = (struct msg_delete_request *) STREAM_DATA (msg->s);
1933:
1934: /* Lookup area for link-local and area-local opaque LSAs */
1935: switch (dmsg->lsa_type)
1936: {
1937: case OSPF_OPAQUE_LINK_LSA:
1938: case OSPF_OPAQUE_AREA_LSA:
1939: area = ospf_area_lookup_by_area_id (ospf, dmsg->area_id);
1940: if (!area)
1941: {
1942: zlog_warn ("ospf_apiserver_lsa_delete: unknown area %s",
1943: inet_ntoa (dmsg->area_id));
1944: rc = OSPF_API_NOSUCHAREA;
1945: goto out;
1946: }
1947: break;
1948: case OSPF_OPAQUE_AS_LSA:
1949: /* AS-external opaque LSAs have no designated area */
1950: area = NULL;
1951: break;
1952: default:
1953: zlog_warn
1954: ("ospf_apiserver_lsa_delete: Cannot delete non-opaque LSA type %d",
1955: dmsg->lsa_type);
1956: rc = OSPF_API_ILLEGALLSATYPE;
1957: goto out;
1958: }
1959:
1960: /* Check if we registered this opaque type */
1961: lsa_type = dmsg->lsa_type;
1962: opaque_type = dmsg->opaque_type;
1963:
1964: if (!apiserver_is_opaque_type_registered (apiserv, lsa_type, opaque_type))
1965: {
1966: zlog_warn ("ospf_apiserver_lsa_delete: LSA-type(%d)/Opaque-type(%d): Not registered", lsa_type, opaque_type);
1967: rc = OSPF_API_OPAQUETYPENOTREGISTERED;
1968: goto out;
1969: }
1970:
1971: /* opaque_id is in network byte order */
1972: id.s_addr = htonl (SET_OPAQUE_LSID (dmsg->opaque_type,
1973: ntohl (dmsg->opaque_id)));
1974:
1975: /*
1976: * Even if the target LSA has once scheduled to flush, it remains in
1977: * the LSDB until it is finally handled by the maxage remover thread.
1978: * Therefore, the lookup function below may return non-NULL result.
1979: */
1980: old = ospf_lsa_lookup (area, dmsg->lsa_type, id, ospf->router_id);
1981: if (!old)
1982: {
1983: zlog_warn ("ospf_apiserver_lsa_delete: LSA[Type%d:%s] not in LSDB",
1984: dmsg->lsa_type, inet_ntoa (id));
1985: rc = OSPF_API_NOSUCHLSA;
1986: goto out;
1987: }
1988:
1989: /* Schedule flushing of LSA from LSDB */
1990: /* NB: Multiple scheduling will produce a warning message, but harmless. */
1991: ospf_opaque_lsa_flush_schedule (old);
1992:
1993: out:
1994:
1995: /* Send reply back to client including return code */
1996: rc = ospf_apiserver_send_reply (apiserv, ntohl (msg->hdr.msgseq), rc);
1997: return rc;
1998: }
1999:
2000: /* Flush self-originated opaque LSA */
2001: static int
2002: apiserver_flush_opaque_type_callback (struct ospf_lsa *lsa,
2003: void *p_arg, int int_arg)
2004: {
2005: struct param_t
2006: {
2007: struct ospf_apiserver *apiserv;
2008: u_char lsa_type;
2009: u_char opaque_type;
2010: }
2011: *param;
2012:
2013: /* Sanity check */
2014: assert (lsa->data);
2015: assert (p_arg);
2016: param = (struct param_t *) p_arg;
2017:
2018: /* If LSA matches type and opaque type then delete it */
2019: if (IS_LSA_SELF (lsa) && lsa->data->type == param->lsa_type
2020: && GET_OPAQUE_TYPE (ntohl (lsa->data->id.s_addr)) == param->opaque_type)
2021: {
2022: ospf_opaque_lsa_flush_schedule (lsa);
2023: }
2024: return 0;
2025: }
2026:
2027: /* Delete self-originated opaque LSAs of a given opaque type. This
2028: function is called when an application unregisters a given opaque
2029: type or a connection to an application closes and all those opaque
2030: LSAs need to be flushed the LSDB. */
2031: void
2032: ospf_apiserver_flush_opaque_lsa (struct ospf_apiserver *apiserv,
2033: u_char lsa_type, u_char opaque_type)
2034: {
2035: struct param_t
2036: {
2037: struct ospf_apiserver *apiserv;
2038: u_char lsa_type;
2039: u_char opaque_type;
2040: } param;
2041: struct listnode *node, *nnode;
2042: struct ospf * ospf;
2043: struct ospf_area *area;
2044:
2045: ospf = ospf_lookup();
2046: assert(ospf);
2047:
2048: /* Set parameter struct. */
2049: param.apiserv = apiserv;
2050: param.lsa_type = lsa_type;
2051: param.opaque_type = opaque_type;
2052:
2053: switch (lsa_type)
2054: {
2055: struct route_node *rn;
2056: struct ospf_lsa *lsa;
2057:
2058: case OSPF_OPAQUE_LINK_LSA:
2059: for (ALL_LIST_ELEMENTS (ospf->areas, node, nnode, area))
2060: LSDB_LOOP (OPAQUE_LINK_LSDB (area), rn, lsa)
2061: apiserver_flush_opaque_type_callback(lsa, (void *) ¶m, 0);
2062: break;
2063: case OSPF_OPAQUE_AREA_LSA:
2064: for (ALL_LIST_ELEMENTS (ospf->areas, node, nnode, area))
2065: LSDB_LOOP (OPAQUE_AREA_LSDB (area), rn, lsa)
2066: apiserver_flush_opaque_type_callback(lsa, (void *) ¶m, 0);
2067: break;
2068: case OSPF_OPAQUE_AS_LSA:
2069: LSDB_LOOP (OPAQUE_LINK_LSDB (ospf), rn, lsa)
2070: apiserver_flush_opaque_type_callback(lsa, (void *) ¶m, 0);
2071: break;
2072: default:
2073: break;
2074: }
2075: return;
2076: }
2077:
2078:
2079: /* -----------------------------------------------------------
2080: * Followings are callback functions to handle opaque types
2081: * -----------------------------------------------------------
2082: */
2083:
2084: int
2085: ospf_apiserver_new_if (struct interface *ifp)
2086: {
2087: struct ospf_interface *oi;
2088:
2089: /* For some strange reason it seems possible that we are invoked
2090: with an interface that has no name. This seems to happen during
2091: initialization. Return if this happens */
2092:
2093: if (ifp->name[0] == '\0') {
2094: /* interface has empty name */
2095: zlog_warn ("ospf_apiserver_new_if: interface has no name?");
2096: return 0;
2097: }
2098:
2099: /* zlog_warn for debugging */
2100: zlog_warn ("ospf_apiserver_new_if");
2101: zlog_warn ("ifp name=%s status=%d index=%d", ifp->name, ifp->status,
2102: ifp->ifindex);
2103:
2104: if (ifp->name[0] == '\0') {
2105: /* interface has empty name */
2106: zlog_warn ("ospf_apiserver_new_if: interface has no name?");
2107: return 0;
2108: }
2109:
2110: oi = ospf_apiserver_if_lookup_by_ifp (ifp);
2111:
2112: if (!oi) {
2113: /* This interface is known to Zebra but not to OSPF daemon yet. */
2114: zlog_warn ("ospf_apiserver_new_if: interface %s not known to OSPFd?",
2115: ifp->name);
2116: return 0;
2117: }
2118:
2119: assert (oi);
2120:
2121: /* New interface added to OSPF, tell clients about it */
2122: if (listcount (apiserver_list) > 0) {
2123: ospf_apiserver_clients_notify_new_if (oi);
2124: }
2125: return 0;
2126: }
2127:
2128: int
2129: ospf_apiserver_del_if (struct interface *ifp)
2130: {
2131: struct ospf_interface *oi;
2132:
2133: /* zlog_warn for debugging */
2134: zlog_warn ("ospf_apiserver_del_if");
2135: zlog_warn ("ifp name=%s status=%d index=%d\n", ifp->name, ifp->status,
2136: ifp->ifindex);
2137:
2138: oi = ospf_apiserver_if_lookup_by_ifp (ifp);
2139:
2140: if (!oi) {
2141: /* This interface is known to Zebra but not to OSPF daemon
2142: anymore. No need to tell clients about it */
2143: return 0;
2144: }
2145:
2146: /* Interface deleted, tell clients about it */
2147: if (listcount (apiserver_list) > 0) {
2148: ospf_apiserver_clients_notify_del_if (oi);
2149: }
2150: return 0;
2151: }
2152:
2153: void
2154: ospf_apiserver_ism_change (struct ospf_interface *oi, int old_state)
2155: {
2156: /* Tell clients about interface change */
2157:
2158: /* zlog_warn for debugging */
2159: zlog_warn ("ospf_apiserver_ism_change");
2160: if (listcount (apiserver_list) > 0) {
2161: ospf_apiserver_clients_notify_ism_change (oi);
2162: }
2163:
2164: zlog_warn ("oi->ifp->name=%s", oi->ifp->name);
2165: zlog_warn ("old_state=%d", old_state);
2166: zlog_warn ("oi->state=%d", oi->state);
2167: }
2168:
2169: void
2170: ospf_apiserver_nsm_change (struct ospf_neighbor *nbr, int old_status)
2171: {
2172: /* Neighbor status changed, tell clients about it */
2173: zlog_warn ("ospf_apiserver_nsm_change");
2174: if (listcount (apiserver_list) > 0) {
2175: ospf_apiserver_clients_notify_nsm_change (nbr);
2176: }
2177: }
2178:
2179: void
2180: ospf_apiserver_show_info (struct vty *vty, struct ospf_lsa *lsa)
2181: {
2182: struct opaque_lsa
2183: {
2184: struct lsa_header header;
2185: u_char data[1]; /* opaque data have variable length. This is start
2186: address */
2187: };
2188: struct opaque_lsa *olsa;
2189: int opaquelen;
2190:
2191: olsa = (struct opaque_lsa *) lsa->data;
2192:
2193: if (VALID_OPAQUE_INFO_LEN (lsa->data))
2194: opaquelen = ntohs (lsa->data->length) - OSPF_LSA_HEADER_SIZE;
2195: else
2196: opaquelen = 0;
2197:
2198: /* Output information about opaque LSAs */
2199: if (vty != NULL)
2200: {
2201: int i;
2202: vty_out (vty, " Added using OSPF API: %u octets of opaque data %s%s",
2203: opaquelen,
2204: VALID_OPAQUE_INFO_LEN (lsa->data) ? "" : "(Invalid length?)",
2205: VTY_NEWLINE);
2206: vty_out (vty, " Opaque data: ");
2207:
2208: for (i = 0; i < opaquelen; i++)
2209: {
2210: vty_out (vty, "0x%x ", olsa->data[i]);
2211: }
2212: vty_out (vty, "%s", VTY_NEWLINE);
2213: }
2214: else
2215: {
2216: int i;
2217: zlog_debug (" Added using OSPF API: %u octets of opaque data %s",
2218: opaquelen,
2219: VALID_OPAQUE_INFO_LEN (lsa->
2220: data) ? "" : "(Invalid length?)");
2221: zlog_debug (" Opaque data: ");
2222:
2223: for (i = 0; i < opaquelen; i++)
2224: {
2225: zlog_debug ("0x%x ", olsa->data[i]);
2226: }
2227: zlog_debug ("\n");
2228: }
2229: return;
2230: }
2231:
2232: /* -----------------------------------------------------------
2233: * Followings are functions to notify clients about events
2234: * -----------------------------------------------------------
2235: */
2236:
2237: /* Send a message to all clients. This is useful for messages
2238: that need to be notified to all clients (such as interface
2239: changes) */
2240:
2241: void
2242: ospf_apiserver_clients_notify_all (struct msg *msg)
2243: {
2244: struct listnode *node, *nnode;
2245: struct ospf_apiserver *apiserv;
2246:
2247: /* Send message to all clients */
2248: for (ALL_LIST_ELEMENTS (apiserver_list, node, nnode, apiserv))
2249: ospf_apiserver_send_msg (apiserv, msg);
2250: }
2251:
2252: /* An interface is now ready to accept opaque LSAs. Notify all
2253: clients that registered to use this opaque type */
2254: void
2255: ospf_apiserver_clients_notify_ready_type9 (struct ospf_interface *oi)
2256: {
2257: struct listnode *node, *nnode;
2258: struct msg *msg;
2259: struct ospf_apiserver *apiserv;
2260:
2261: assert (oi);
2262: if (!oi->address)
2263: {
2264: zlog_warn ("Interface has no address?");
2265: return;
2266: }
2267:
2268: if (!ospf_apiserver_is_ready_type9 (oi))
2269: {
2270: zlog_warn ("Interface not ready for type 9?");
2271: return;
2272: }
2273:
2274: for (ALL_LIST_ELEMENTS (apiserver_list, node, nnode, apiserv))
2275: {
2276: struct listnode *node2, *nnode2;
2277: struct registered_opaque_type *r;
2278:
2279: for (ALL_LIST_ELEMENTS (apiserv->opaque_types, node2, nnode2, r))
2280: {
2281: if (r->lsa_type == OSPF_OPAQUE_LINK_LSA)
2282: {
2283: msg = new_msg_ready_notify (0, OSPF_OPAQUE_LINK_LSA,
2284: r->opaque_type,
2285: oi->address->u.prefix4);
2286: if (!msg)
2287: {
2288: zlog_warn
2289: ("ospf_apiserver_clients_notify_ready_type9: new_msg_ready_notify failed");
2290: #ifdef NOTYET
2291: /* Cannot allocate new message. What should we do? */
2292: ospf_apiserver_free (apiserv);
2293: #endif
2294: goto out;
2295: }
2296:
2297: ospf_apiserver_send_msg (apiserv, msg);
2298: msg_free (msg);
2299: }
2300: }
2301: }
2302:
2303: out:
2304: return;
2305: }
2306:
2307: void
2308: ospf_apiserver_clients_notify_ready_type10 (struct ospf_area *area)
2309: {
2310: struct listnode *node, *nnode;
2311: struct msg *msg;
2312: struct ospf_apiserver *apiserv;
2313:
2314: assert (area);
2315:
2316: if (!ospf_apiserver_is_ready_type10 (area))
2317: {
2318: zlog_warn ("Area not ready for type 10?");
2319: return;
2320: }
2321:
2322: for (ALL_LIST_ELEMENTS (apiserver_list, node, nnode, apiserv))
2323: {
2324: struct listnode *node2, *nnode2;
2325: struct registered_opaque_type *r;
2326:
2327: for (ALL_LIST_ELEMENTS (apiserv->opaque_types, node2, nnode2, r))
2328: {
2329: if (r->lsa_type == OSPF_OPAQUE_AREA_LSA)
2330: {
2331: msg = new_msg_ready_notify (0, OSPF_OPAQUE_AREA_LSA,
2332: r->opaque_type, area->area_id);
2333: if (!msg)
2334: {
2335: zlog_warn
2336: ("ospf_apiserver_clients_notify_ready_type10: new_msg_ready_nofity failed");
2337: #ifdef NOTYET
2338: /* Cannot allocate new message. What should we do? */
2339: ospf_apiserver_free (apiserv);
2340: #endif
2341: goto out;
2342: }
2343:
2344: ospf_apiserver_send_msg (apiserv, msg);
2345: msg_free (msg);
2346: }
2347: }
2348: }
2349:
2350: out:
2351: return;
2352: }
2353:
2354:
2355: void
2356: ospf_apiserver_clients_notify_ready_type11 (struct ospf *top)
2357: {
2358: struct listnode *node, *nnode;
2359: struct msg *msg;
2360: struct in_addr id_null = { .s_addr = 0L };
2361: struct ospf_apiserver *apiserv;
2362:
2363: assert (top);
2364:
2365: if (!ospf_apiserver_is_ready_type11 (top))
2366: {
2367: zlog_warn ("AS not ready for type 11?");
2368: return;
2369: }
2370:
2371: for (ALL_LIST_ELEMENTS (apiserver_list, node, nnode, apiserv))
2372: {
2373: struct listnode *node2, *nnode2;
2374: struct registered_opaque_type *r;
2375:
2376: for (ALL_LIST_ELEMENTS (apiserv->opaque_types, node2, nnode2, r))
2377: {
2378: if (r->lsa_type == OSPF_OPAQUE_AS_LSA)
2379: {
2380: msg = new_msg_ready_notify (0, OSPF_OPAQUE_AS_LSA,
2381: r->opaque_type, id_null);
2382: if (!msg)
2383: {
2384: zlog_warn
2385: ("ospf_apiserver_clients_notify_ready_type11: new_msg_ready_notify failed");
2386: #ifdef NOTYET
2387: /* Cannot allocate new message. What should we do? */
2388: ospf_apiserver_free (apiserv);
2389: #endif
2390: goto out;
2391: }
2392:
2393: ospf_apiserver_send_msg (apiserv, msg);
2394: msg_free (msg);
2395: }
2396: }
2397: }
2398:
2399: out:
2400: return;
2401: }
2402:
2403: void
2404: ospf_apiserver_clients_notify_new_if (struct ospf_interface *oi)
2405: {
2406: struct msg *msg;
2407:
2408: msg = new_msg_new_if (0, oi->address->u.prefix4, oi->area->area_id);
2409: if (msg != NULL)
2410: {
2411: ospf_apiserver_clients_notify_all (msg);
2412: msg_free (msg);
2413: }
2414: }
2415:
2416: void
2417: ospf_apiserver_clients_notify_del_if (struct ospf_interface *oi)
2418: {
2419: struct msg *msg;
2420:
2421: msg = new_msg_del_if (0, oi->address->u.prefix4);
2422: if (msg != NULL)
2423: {
2424: ospf_apiserver_clients_notify_all (msg);
2425: msg_free (msg);
2426: }
2427: }
2428:
2429: void
2430: ospf_apiserver_clients_notify_ism_change (struct ospf_interface *oi)
2431: {
2432: struct msg *msg;
2433: struct in_addr ifaddr = { .s_addr = 0L };
2434: struct in_addr area_id = { .s_addr = 0L };
2435:
2436: assert (oi);
2437: assert (oi->ifp);
2438:
2439: if (oi->address)
2440: {
2441: ifaddr = oi->address->u.prefix4;
2442: }
2443: if (oi->area)
2444: {
2445: area_id = oi->area->area_id;
2446: }
2447:
2448: msg = new_msg_ism_change (0, ifaddr, area_id, oi->state);
2449: if (!msg)
2450: {
2451: zlog_warn ("apiserver_clients_notify_ism_change: msg_new failed");
2452: return;
2453: }
2454:
2455: ospf_apiserver_clients_notify_all (msg);
2456: msg_free (msg);
2457: }
2458:
2459: void
2460: ospf_apiserver_clients_notify_nsm_change (struct ospf_neighbor *nbr)
2461: {
2462: struct msg *msg;
2463: struct in_addr ifaddr = { .s_addr = 0L };
2464: struct in_addr nbraddr = { .s_addr = 0L };
2465:
2466: assert (nbr);
2467:
2468: if (nbr->oi)
2469: {
2470: ifaddr = nbr->oi->address->u.prefix4;
2471: }
2472:
2473: nbraddr = nbr->address.u.prefix4;
2474:
2475: msg = new_msg_nsm_change (0, ifaddr, nbraddr, nbr->router_id, nbr->state);
2476: if (!msg)
2477: {
2478: zlog_warn ("apiserver_clients_notify_nsm_change: msg_new failed");
2479: return;
2480: }
2481:
2482: ospf_apiserver_clients_notify_all (msg);
2483: msg_free (msg);
2484: }
2485:
2486: static void
2487: apiserver_clients_lsa_change_notify (u_char msgtype, struct ospf_lsa *lsa)
2488: {
2489: struct msg *msg;
2490: struct listnode *node, *nnode;
2491: struct ospf_apiserver *apiserv;
2492:
2493: /* Default area for AS-External and Opaque11 LSAs */
2494: struct in_addr area_id = { .s_addr = 0L };
2495:
2496: /* Default interface for non Opaque9 LSAs */
2497: struct in_addr ifaddr = { .s_addr = 0L };
2498:
2499: if (lsa->area)
2500: {
2501: area_id = lsa->area->area_id;
2502: }
2503: if (lsa->data->type == OSPF_OPAQUE_LINK_LSA)
2504: {
2505: assert (lsa->oi);
2506: ifaddr = lsa->oi->address->u.prefix4;
2507: }
2508:
2509: /* Prepare message that can be sent to clients that have a matching
2510: filter */
2511: msg = new_msg_lsa_change_notify (msgtype, 0L, /* no sequence number */
2512: ifaddr, area_id,
2513: lsa->flags & OSPF_LSA_SELF, lsa->data);
2514: if (!msg)
2515: {
2516: zlog_warn ("apiserver_clients_lsa_change_notify: msg_new failed");
2517: return;
2518: }
2519:
2520: /* Now send message to all clients with a matching filter */
2521: for (ALL_LIST_ELEMENTS (apiserver_list, node, nnode, apiserv))
2522: {
2523: struct lsa_filter_type *filter;
2524: u_int16_t mask;
2525: u_int32_t *area;
2526: int i;
2527:
2528: /* Check filter for this client. */
2529: filter = apiserv->filter;
2530:
2531: /* Check area IDs in case of non AS-E LSAs.
2532: * If filter has areas (num_areas > 0),
2533: * then one of the areas must match the area ID of this LSA. */
2534:
2535: i = filter->num_areas;
2536: if ((lsa->data->type == OSPF_AS_EXTERNAL_LSA) ||
2537: (lsa->data->type == OSPF_OPAQUE_AS_LSA))
2538: {
2539: i = 0;
2540: }
2541:
2542: if (i > 0)
2543: {
2544: area = (u_int32_t *) (filter + 1);
2545: while (i)
2546: {
2547: if (*area == area_id.s_addr)
2548: {
2549: break;
2550: }
2551: i--;
2552: area++;
2553: }
2554: }
2555: else
2556: {
2557: i = 1;
2558: }
2559:
2560: if (i > 0)
2561: {
2562: /* Area match. Check LSA type. */
2563: mask = ntohs (filter->typemask);
2564:
2565: if (mask & Power2[lsa->data->type])
2566: {
2567: /* Type also matches. Check origin. */
2568: if ((filter->origin == ANY_ORIGIN) ||
2569: (filter->origin == IS_LSA_SELF (lsa)))
2570: {
2571: ospf_apiserver_send_msg (apiserv, msg);
2572: }
2573: }
2574: }
2575: }
2576: /* Free message since it is not used anymore */
2577: msg_free (msg);
2578: }
2579:
2580:
2581: /* -------------------------------------------------------------
2582: * Followings are hooks invoked when LSAs are updated or deleted
2583: * -------------------------------------------------------------
2584: */
2585:
2586:
2587: static int
2588: apiserver_notify_clients_lsa (u_char msgtype, struct ospf_lsa *lsa)
2589: {
2590: struct msg *msg;
2591: /* default area for AS-External and Opaque11 LSAs */
2592: struct in_addr area_id = { .s_addr = 0L };
2593:
2594: /* default interface for non Opaque9 LSAs */
2595: struct in_addr ifaddr = { .s_addr = 0L };
2596:
2597: /* Only notify this update if the LSA's age is smaller than
2598: MAXAGE. Otherwise clients would see LSA updates with max age just
2599: before they are deleted from the LSDB. LSA delete messages have
2600: MAXAGE too but should not be filtered. */
2601: if (IS_LSA_MAXAGE(lsa) && (msgtype == MSG_LSA_UPDATE_NOTIFY)) {
2602: return 0;
2603: }
2604:
2605: if (lsa->area)
2606: {
2607: area_id = lsa->area->area_id;
2608: }
2609: if (lsa->data->type == OSPF_OPAQUE_LINK_LSA)
2610: {
2611: ifaddr = lsa->oi->address->u.prefix4;
2612: }
2613: msg = new_msg_lsa_change_notify (msgtype, 0L, /* no sequence number */
2614: ifaddr, area_id,
2615: lsa->flags & OSPF_LSA_SELF, lsa->data);
2616: if (!msg)
2617: {
2618: zlog_warn ("notify_clients_lsa: msg_new failed");
2619: return -1;
2620: }
2621: /* Notify all clients that new LSA is added/updated */
2622: apiserver_clients_lsa_change_notify (msgtype, lsa);
2623:
2624: /* Clients made their own copies of msg so we can free msg here */
2625: msg_free (msg);
2626:
2627: return 0;
2628: }
2629:
2630: int
2631: ospf_apiserver_lsa_update (struct ospf_lsa *lsa)
2632: {
2633: return apiserver_notify_clients_lsa (MSG_LSA_UPDATE_NOTIFY, lsa);
2634: }
2635:
2636: int
2637: ospf_apiserver_lsa_delete (struct ospf_lsa *lsa)
2638: {
2639: return apiserver_notify_clients_lsa (MSG_LSA_DELETE_NOTIFY, lsa);
2640: }
2641:
2642: #endif /* SUPPORT_OSPF_API */
2643:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ospf_apiserver.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / ospfd