Adding upstream version 8.4.4.upstream/8.4.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 342 insertions, 0 deletions

diff --git a/ospfclient/ospfclient.c b/ospfclient/ospfclient.c
new file mode 100644
index 0000000..edf8141
--- /dev/null
+++ b/ospfclient/ospfclient.c
@@ -0,0 +1,342 @@
+/* This file is part of Quagga.
+ *
+ * Quagga is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * Quagga is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/*
+ * Simple program to demonstrate how OSPF API can be used. This
+ * application retrieves the LSDB from the OSPF daemon and then
+ * originates, updates and finally deletes an application-specific
+ * opaque LSA. You can use this application as a template when writing
+ * your own application.
+ */
+
+/* The following includes are needed in all OSPF API client
+   applications. */
+
+#include <zebra.h>
+#include "prefix.h" /* needed by ospf_asbr.h */
+#include "privs.h"
+#include "log.h"
+#include "lib/printfrr.h"
+
+/* work around gcc bug 69981, disable MTYPEs in libospf */
+#define _QUAGGA_OSPF_MEMORY_H
+
+#include "ospfd/ospfd.h"
+#include "ospfd/ospf_asbr.h"
+#include "ospfd/ospf_lsa.h"
+#include "ospfd/ospf_opaque.h"
+#include "ospfd/ospf_api.h"
+#include "ospf_apiclient.h"
+
+/* privileges struct.
+ * set cap_num_* and uid/gid to nothing to use NULL privs
+ * as ospfapiclient links in libospf.a which uses privs.
+ */
+struct zebra_privs_t ospfd_privs = {.user = NULL,
+				    .group = NULL,
+				    .cap_num_p = 0,
+				    .cap_num_i = 0};
+
+/* The following includes are specific to this application. For
+   example it uses threads from libfrr, however your application is
+   free to use any thread library (like pthreads). */
+
+#include "ospfd/ospf_dump.h" /* for ospf_lsa_header_dump */
+#include "thread.h"
+#include "log.h"
+
+/* Local portnumber for async channel. Note that OSPF API library will also
+   allocate a sync channel at ASYNCPORT+1. */
+#define ASYNCPORT 4000
+
+/* Master thread */
+struct thread_master *master;
+
+/* Global variables */
+struct ospf_apiclient *oclient;
+char **args;
+
+/* Our opaque LSAs have the following format. */
+struct my_opaque_lsa {
+	struct lsa_header hdr; /* include common LSA header */
+	uint8_t data[4];       /* our own data format then follows here */
+};
+
+
+/* ---------------------------------------------------------
+ * Threads for asynchronous messages and LSA update/delete
+ * ---------------------------------------------------------
+ */
+
+static void lsa_delete(struct thread *t)
+{
+	struct ospf_apiclient *oclient;
+	struct in_addr area_id;
+	int rc;
+
+	oclient = THREAD_ARG(t);
+
+	rc = inet_aton(args[6], &area_id);
+	if (rc <= 0) {
+		printf("Address Specified: %s is invalid\n", args[6]);
+		return;
+	}
+
+	printf("Deleting LSA... ");
+	rc = ospf_apiclient_lsa_delete(oclient, area_id,
+				       atoi(args[2]), /* lsa type */
+				       atoi(args[3]), /* opaque type */
+				       atoi(args[4]), /* opaque ID */
+				       0); /* send data in withdrawals */
+	printf("done, return code is = %d\n", rc);
+}
+
+static void lsa_inject(struct thread *t)
+{
+	struct ospf_apiclient *cl;
+	struct in_addr ifaddr;
+	struct in_addr area_id;
+	uint8_t lsa_type;
+	uint8_t opaque_type;
+	uint32_t opaque_id;
+	void *opaquedata;
+	int opaquelen;
+
+	static uint32_t counter = 1; /* Incremented each time invoked */
+	int rc;
+
+	cl = THREAD_ARG(t);
+
+	rc = inet_aton(args[5], &ifaddr);
+	if (rc <= 0) {
+		printf("Ifaddr specified %s is invalid\n", args[5]);
+		return;
+	}
+
+	rc = inet_aton(args[6], &area_id);
+	if (rc <= 0) {
+		printf("Area ID specified %s is invalid\n", args[6]);
+		return;
+	}
+	lsa_type = atoi(args[2]);
+	opaque_type = atoi(args[3]);
+	opaque_id = atoi(args[4]);
+	opaquedata = &counter;
+	opaquelen = sizeof(uint32_t);
+
+	printf("Originating/updating LSA with counter=%d... ", counter);
+	rc = ospf_apiclient_lsa_originate(cl, ifaddr, area_id, lsa_type,
+					  opaque_type, opaque_id, opaquedata,
+					  opaquelen);
+
+	printf("done, return code is %d\n", rc);
+
+	counter++;
+}
+
+
+/* This thread handles asynchronous messages coming in from the OSPF
+   API server */
+static void lsa_read(struct thread *thread)
+{
+	struct ospf_apiclient *oclient;
+	int fd;
+	int ret;
+
+	printf("lsa_read called\n");
+
+	oclient = THREAD_ARG(thread);
+	fd = THREAD_FD(thread);
+
+	/* Handle asynchronous message */
+	ret = ospf_apiclient_handle_async(oclient);
+	if (ret < 0) {
+		printf("Connection closed, exiting...");
+		exit(0);
+	}
+
+	/* Reschedule read thread */
+	thread_add_read(master, lsa_read, oclient, fd, NULL);
+}
+
+/* ---------------------------------------------------------
+ * Callback functions for asynchronous events
+ * ---------------------------------------------------------
+ */
+
+static void lsa_update_callback(struct in_addr ifaddr, struct in_addr area_id,
+				uint8_t is_self_originated,
+				struct lsa_header *lsa)
+{
+	printf("lsa_update_callback: ");
+	printfrr("ifaddr: %pI4 ", &ifaddr);
+	printfrr("area: %pI4\n", &area_id);
+	printf("is_self_origin: %u\n", is_self_originated);
+
+	/* It is important to note that lsa_header does indeed include the
+	   header and the LSA payload. To access the payload, first check
+	   the LSA type and then typecast lsa into the corresponding type,
+	   e.g.:
+
+	   if (lsa->type == OSPF_ROUTER_LSA) {
+	     struct router_lsa *rl = (struct router_lsa) lsa;
+	     ...
+	     uint16_t links = rl->links;
+	     ...
+	  }
+	*/
+
+	ospf_lsa_header_dump(lsa);
+}
+
+static void lsa_delete_callback(struct in_addr ifaddr, struct in_addr area_id,
+				uint8_t is_self_originated,
+				struct lsa_header *lsa)
+{
+	printf("lsa_delete_callback: ");
+	printf("ifaddr: %pI4 ", &ifaddr);
+	printf("area: %pI4\n", &area_id);
+	printf("is_self_origin: %u\n", is_self_originated);
+
+	ospf_lsa_header_dump(lsa);
+}
+
+static void ready_callback(uint8_t lsa_type, uint8_t opaque_type,
+			   struct in_addr addr)
+{
+	printfrr("ready_callback: lsa_type: %d opaque_type: %d addr=%pI4\n",
+		 lsa_type, opaque_type, &addr);
+
+	/* Schedule opaque LSA originate in 5 secs */
+	thread_add_timer(master, lsa_inject, oclient, 5, NULL);
+
+	/* Schedule opaque LSA update with new value */
+	thread_add_timer(master, lsa_inject, oclient, 10, NULL);
+
+	/* Schedule delete */
+	thread_add_timer(master, lsa_delete, oclient, 30, NULL);
+}
+
+static void new_if_callback(struct in_addr ifaddr, struct in_addr area_id)
+{
+	printfrr("new_if_callback: ifaddr: %pI4 ", &ifaddr);
+	printfrr("area_id: %pI4\n", &area_id);
+}
+
+static void del_if_callback(struct in_addr ifaddr)
+{
+	printfrr("new_if_callback: ifaddr: %pI4\n ", &ifaddr);
+}
+
+static void ism_change_callback(struct in_addr ifaddr, struct in_addr area_id,
+				uint8_t state)
+{
+	printfrr("ism_change: ifaddr: %pI4 ", &ifaddr);
+	printfrr("area_id: %pI4\n", &area_id);
+	printf("state: %d [%s]\n", state,
+	       lookup_msg(ospf_ism_state_msg, state, NULL));
+}
+
+static void nsm_change_callback(struct in_addr ifaddr, struct in_addr nbraddr,
+				struct in_addr router_id, uint8_t state)
+{
+	printfrr("nsm_change: ifaddr: %pI4 ", &ifaddr);
+	printfrr("nbraddr: %pI4\n", &nbraddr);
+	printfrr("router_id: %pI4\n", &router_id);
+	printf("state: %d [%s]\n", state,
+	       lookup_msg(ospf_nsm_state_msg, state, NULL));
+}
+
+
+/* ---------------------------------------------------------
+ * Main program
+ * ---------------------------------------------------------
+ */
+
+static int usage(void)
+{
+	printf("Usage: ospfclient <ospfd> <lsatype> <opaquetype> <opaqueid> <ifaddr> <areaid>\n");
+	printf("where ospfd     : router where API-enabled OSPF daemon is running\n");
+	printf("      lsatype   : either 9, 10, or 11 depending on flooding scope\n");
+	printf("      opaquetype: 0-255 (e.g., experimental applications use > 128)\n");
+	printf("      opaqueid  : arbitrary application instance (24 bits)\n");
+	printf("      ifaddr    : interface IP address (for type 9) otherwise ignored\n");
+	printf("      areaid    : area in IP address format (for type 10) otherwise ignored\n");
+
+	exit(1);
+}
+
+int main(int argc, char *argv[])
+{
+	struct thread thread;
+
+	args = argv;
+
+	/* ospfclient should be started with the following arguments:
+	 *
+	 * (1) host (2) lsa_type (3) opaque_type (4) opaque_id (5) if_addr
+	 * (6) area_id
+	 *
+	 * host: name or IP of host where ospfd is running
+	 * lsa_type: 9, 10, or 11
+	 * opaque_type: 0-255 (e.g., experimental applications use > 128)
+	 * opaque_id: arbitrary application instance (24 bits)
+	 * if_addr: interface IP address (for type 9) otherwise ignored
+	 * area_id: area in IP address format (for type 10) otherwise ignored
+	 */
+
+	if (argc != 7) {
+		usage();
+	}
+
+	/* Initialization */
+	zprivs_preinit(&ospfd_privs);
+	zprivs_init(&ospfd_privs);
+	master = thread_master_create(NULL);
+
+	/* Open connection to OSPF daemon */
+	oclient = ospf_apiclient_connect(args[1], ASYNCPORT);
+	if (!oclient) {
+		printf("Connecting to OSPF daemon on %s failed!\n", args[1]);
+		exit(1);
+	}
+
+	/* Register callback functions. */
+	ospf_apiclient_register_callback(
+		oclient, ready_callback, new_if_callback, del_if_callback,
+		ism_change_callback, nsm_change_callback, lsa_update_callback,
+		lsa_delete_callback);
+
+	/* Register LSA type and opaque type. */
+	ospf_apiclient_register_opaque_type(oclient, atoi(args[2]),
+					    atoi(args[3]));
+
+	/* Synchronize database with OSPF daemon. */
+	ospf_apiclient_sync_lsdb(oclient);
+
+	/* Schedule thread that handles asynchronous messages */
+	thread_add_read(master, lsa_read, oclient, oclient->fd_async, NULL);
+
+	/* Now connection is established, run loop */
+	while (1) {
+		thread_fetch(master, &thread);
+		thread_call(&thread);
+	}
+
+	/* Never reached */
+	return 0;
+}