Annotation of embedaddon/quagga/ospfclient/ospfclient.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Simple program to demonstrate how OSPF API can be used. This
3: * application retrieves the LSDB from the OSPF daemon and then
4: * originates, updates and finally deletes an application-specific
5: * opaque LSA. You can use this application as a template when writing
6: * your own application.
7: */
8:
9: /* The following includes are needed in all OSPF API client
10: applications. */
11:
12: #include <zebra.h>
13: #include "prefix.h" /* needed by ospf_asbr.h */
14: #include "privs.h"
15: #include "log.h"
16:
17: #include "ospfd/ospfd.h"
18: #include "ospfd/ospf_asbr.h"
19: #include "ospfd/ospf_lsa.h"
20: #include "ospfd/ospf_opaque.h"
21: #include "ospfd/ospf_api.h"
22: #include "ospf_apiclient.h"
23:
24: /* privileges struct.
25: * set cap_num_* and uid/gid to nothing to use NULL privs
26: * as ospfapiclient links in libospf.a which uses privs.
27: */
28: struct zebra_privs_t ospfd_privs =
29: {
30: .user = NULL,
31: .group = NULL,
32: .cap_num_p = 0,
33: .cap_num_i = 0
34: };
35:
36: /* The following includes are specific to this application. For
37: example it uses threads from libzebra, however your application is
38: free to use any thread library (like pthreads). */
39:
40: #include "ospfd/ospf_dump.h" /* for ospf_lsa_header_dump */
41: #include "thread.h"
42: #include "log.h"
43:
44: /* Local portnumber for async channel. Note that OSPF API library will also
45: allocate a sync channel at ASYNCPORT+1. */
46: #define ASYNCPORT 4000
47:
48: /* Master thread */
49: struct thread_master *master;
50:
51: /* Global variables */
52: struct ospf_apiclient *oclient;
53: char **args;
54:
55: /* Our opaque LSAs have the following format. */
56: struct my_opaque_lsa
57: {
58: struct lsa_header hdr; /* include common LSA header */
59: u_char data[4]; /* our own data format then follows here */
60: };
61:
62:
63: /* ---------------------------------------------------------
64: * Threads for asynchronous messages and LSA update/delete
65: * ---------------------------------------------------------
66: */
67:
68: static int
69: lsa_delete (struct thread *t)
70: {
71: struct ospf_apiclient *oclient;
72: struct in_addr area_id;
73: int rc;
74:
75: oclient = THREAD_ARG (t);
76:
77: inet_aton (args[6], &area_id);
78:
79: printf ("Deleting LSA... ");
80: rc = ospf_apiclient_lsa_delete (oclient,
81: area_id,
82: atoi (args[2]), /* lsa type */
83: atoi (args[3]), /* opaque type */
84: atoi (args[4])); /* opaque ID */
85: printf ("done, return code is = %d\n", rc);
86: return rc;
87: }
88:
89: static int
90: lsa_inject (struct thread *t)
91: {
92: struct ospf_apiclient *cl;
93: struct in_addr ifaddr;
94: struct in_addr area_id;
95: u_char lsa_type;
96: u_char opaque_type;
97: u_int32_t opaque_id;
98: void *opaquedata;
99: int opaquelen;
100:
101: static u_int32_t counter = 1; /* Incremented each time invoked */
102: int rc;
103:
104: cl = THREAD_ARG (t);
105:
106: inet_aton (args[5], &ifaddr);
107: inet_aton (args[6], &area_id);
108: lsa_type = atoi (args[2]);
109: opaque_type = atoi (args[3]);
110: opaque_id = atoi (args[4]);
111: opaquedata = &counter;
112: opaquelen = sizeof (u_int32_t);
113:
114: printf ("Originating/updating LSA with counter=%d... ", counter);
115: rc = ospf_apiclient_lsa_originate(cl, ifaddr, area_id,
116: lsa_type,
117: opaque_type, opaque_id,
118: opaquedata, opaquelen);
119:
120: printf ("done, return code is %d\n", rc);
121:
122: counter++;
123:
124: return 0;
125: }
126:
127:
128: /* This thread handles asynchronous messages coming in from the OSPF
129: API server */
130: static int
131: lsa_read (struct thread *thread)
132: {
133: struct ospf_apiclient *oclient;
134: int fd;
135: int ret;
136:
137: printf ("lsa_read called\n");
138:
139: oclient = THREAD_ARG (thread);
140: fd = THREAD_FD (thread);
141:
142: /* Handle asynchronous message */
143: ret = ospf_apiclient_handle_async (oclient);
144: if (ret < 0) {
145: printf ("Connection closed, exiting...");
146: exit(0);
147: }
148:
149: /* Reschedule read thread */
150: thread_add_read (master, lsa_read, oclient, fd);
151:
152: return 0;
153: }
154:
155: /* ---------------------------------------------------------
156: * Callback functions for asynchronous events
157: * ---------------------------------------------------------
158: */
159:
160: static void
161: lsa_update_callback (struct in_addr ifaddr, struct in_addr area_id,
162: u_char is_self_originated,
163: struct lsa_header *lsa)
164: {
165: printf ("lsa_update_callback: ");
166: printf ("ifaddr: %s ", inet_ntoa (ifaddr));
167: printf ("area: %s\n", inet_ntoa (area_id));
168: printf ("is_self_origin: %u\n", is_self_originated);
169:
170: /* It is important to note that lsa_header does indeed include the
171: header and the LSA payload. To access the payload, first check
172: the LSA type and then typecast lsa into the corresponding type,
173: e.g.:
174:
175: if (lsa->type == OSPF_ROUTER_LSA) {
176: struct router_lsa *rl = (struct router_lsa) lsa;
177: ...
178: u_int16_t links = rl->links;
179: ...
180: }
181: */
182:
183: ospf_lsa_header_dump (lsa);
184: }
185:
186: static void
187: lsa_delete_callback (struct in_addr ifaddr, struct in_addr area_id,
188: u_char is_self_originated,
189: struct lsa_header *lsa)
190: {
191: printf ("lsa_delete_callback: ");
192: printf ("ifaddr: %s ", inet_ntoa (ifaddr));
193: printf ("area: %s\n", inet_ntoa (area_id));
194: printf ("is_self_origin: %u\n", is_self_originated);
195:
196: ospf_lsa_header_dump (lsa);
197: }
198:
199: static void
200: ready_callback (u_char lsa_type, u_char opaque_type, struct in_addr addr)
201: {
202: printf ("ready_callback: lsa_type: %d opaque_type: %d addr=%s\n",
203: lsa_type, opaque_type, inet_ntoa (addr));
204:
205: /* Schedule opaque LSA originate in 5 secs */
206: thread_add_timer (master, lsa_inject, oclient, 5);
207:
208: /* Schedule opaque LSA update with new value */
209: thread_add_timer (master, lsa_inject, oclient, 10);
210:
211: /* Schedule delete */
212: thread_add_timer (master, lsa_delete, oclient, 30);
213: }
214:
215: static void
216: new_if_callback (struct in_addr ifaddr, struct in_addr area_id)
217: {
218: printf ("new_if_callback: ifaddr: %s ", inet_ntoa (ifaddr));
219: printf ("area_id: %s\n", inet_ntoa (area_id));
220: }
221:
222: static void
223: del_if_callback (struct in_addr ifaddr)
224: {
225: printf ("new_if_callback: ifaddr: %s\n ", inet_ntoa (ifaddr));
226: }
227:
228: static void
229: ism_change_callback (struct in_addr ifaddr, struct in_addr area_id,
230: u_char state)
231: {
232: printf ("ism_change: ifaddr: %s ", inet_ntoa (ifaddr));
233: printf ("area_id: %s\n", inet_ntoa (area_id));
234: printf ("state: %d [%s]\n", state, LOOKUP (ospf_ism_state_msg, state));
235: }
236:
237: static void
238: nsm_change_callback (struct in_addr ifaddr, struct in_addr nbraddr,
239: struct in_addr router_id, u_char state)
240: {
241: printf ("nsm_change: ifaddr: %s ", inet_ntoa (ifaddr));
242: printf ("nbraddr: %s\n", inet_ntoa (nbraddr));
243: printf ("router_id: %s\n", inet_ntoa (router_id));
244: printf ("state: %d [%s]\n", state, LOOKUP (ospf_nsm_state_msg, state));
245: }
246:
247:
248: /* ---------------------------------------------------------
249: * Main program
250: * ---------------------------------------------------------
251: */
252:
253: static int usage()
254: {
255: printf("Usage: ospfclient <ospfd> <lsatype> <opaquetype> <opaqueid> <ifaddr> <areaid>\n");
256: printf("where ospfd : router where API-enabled OSPF daemon is running\n");
257: printf(" lsatype : either 9, 10, or 11 depending on flooding scope\n");
258: printf(" opaquetype: 0-255 (e.g., experimental applications use > 128)\n");
259: printf(" opaqueid : arbitrary application instance (24 bits)\n");
260: printf(" ifaddr : interface IP address (for type 9) otherwise ignored\n");
261: printf(" areaid : area in IP address format (for type 10) otherwise ignored\n");
262:
263: exit(1);
264: }
265:
266: int
267: main (int argc, char *argv[])
268: {
269: struct thread thread;
270:
271: args = argv;
272:
273: /* ospfclient should be started with the following arguments:
274: *
275: * (1) host (2) lsa_type (3) opaque_type (4) opaque_id (5) if_addr
276: * (6) area_id
277: *
278: * host: name or IP of host where ospfd is running
279: * lsa_type: 9, 10, or 11
280: * opaque_type: 0-255 (e.g., experimental applications use > 128)
281: * opaque_id: arbitrary application instance (24 bits)
282: * if_addr: interface IP address (for type 9) otherwise ignored
283: * area_id: area in IP address format (for type 10) otherwise ignored
284: */
285:
286: if (argc != 7)
287: {
288: usage();
289: }
290:
291: /* Initialization */
292: zprivs_init (&ospfd_privs);
293: master = thread_master_create ();
294:
295: /* Open connection to OSPF daemon */
296: oclient = ospf_apiclient_connect (args[1], ASYNCPORT);
297: if (!oclient)
298: {
299: printf ("Connecting to OSPF daemon on %s failed!\n",
300: args[1]);
301: exit (1);
302: }
303:
304: /* Register callback functions. */
305: ospf_apiclient_register_callback (oclient,
306: ready_callback,
307: new_if_callback,
308: del_if_callback,
309: ism_change_callback,
310: nsm_change_callback,
311: lsa_update_callback,
312: lsa_delete_callback);
313:
314: /* Register LSA type and opaque type. */
315: ospf_apiclient_register_opaque_type (oclient, atoi (args[2]),
316: atoi (args[3]));
317:
318: /* Synchronize database with OSPF daemon. */
319: ospf_apiclient_sync_lsdb (oclient);
320:
321: /* Schedule thread that handles asynchronous messages */
322: thread_add_read (master, lsa_read, oclient, oclient->fd_async);
323:
324: /* Now connection is established, run loop */
325: while (1)
326: {
327: thread_fetch (master, &thread);
328: thread_call (&thread);
329: }
330:
331: /* Never reached */
332: return 0;
333: }
334:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ospfclient.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 / ospfclient