Initial commit
Change-Id: I6a4444e3c193dae437cd7929f4c39aba7b749efa
diff --git a/libfdproto/dispatch.c b/libfdproto/dispatch.c
new file mode 100644
index 0000000..6111915
--- /dev/null
+++ b/libfdproto/dispatch.c
@@ -0,0 +1,228 @@
+/*********************************************************************************************************
+* Software License Agreement (BSD License) *
+* Author: Sebastien Decugis <sdecugis@freediameter.net> *
+* *
+* Copyright (c) 2013, WIDE Project and NICT *
+* All rights reserved. *
+* *
+* Redistribution and use of this software in source and binary forms, with or without modification, are *
+* permitted provided that the following conditions are met: *
+* *
+* * Redistributions of source code must retain the above *
+* copyright notice, this list of conditions and the *
+* following disclaimer. *
+* *
+* * Redistributions in binary form must reproduce the above *
+* copyright notice, this list of conditions and the *
+* following disclaimer in the documentation and/or other *
+* materials provided with the distribution. *
+* *
+* * Neither the name of the WIDE Project or NICT nor the *
+* names of its contributors may be used to endorse or *
+* promote products derived from this software without *
+* specific prior written permission of WIDE Project and *
+* NICT. *
+* *
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED *
+* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
+* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR *
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT *
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS *
+* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR *
+* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF *
+* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
+*********************************************************************************************************/
+
+#include "fdproto-internal.h"
+
+/* The dispatch module in the library is quite simple: callbacks are saved in a global list
+ * in no particular order. In addition, they are also linked from the dictionary objects they
+ * refer to. */
+
+/* Protection for the lists managed in this module. */
+pthread_rwlock_t fd_disp_lock = PTHREAD_RWLOCK_INITIALIZER;
+
+/* List of all registered handlers -- useful if we want to cleanup properly at some point... */
+static struct fd_list all_handlers = FD_LIST_INITIALIZER( all_handlers );
+
+/* List of handlers registered for DISP_HOW_ANY. Other handlers are stored in the dictionary */
+static struct fd_list any_handlers = FD_LIST_INITIALIZER( any_handlers );
+
+/* The structure to store a callback */
+struct disp_hdl {
+ int eyec; /* Eye catcher, DISP_EYEC */
+ struct fd_list all; /* link in the all_handlers list */
+ struct fd_list parent;/* link in dictionary cb_list or in any_handlers */
+ enum disp_how how; /* Copy of registration parameter */
+ struct disp_when when; /* Copy of registration parameter */
+ int (*cb)( struct msg **, struct avp *, struct session *, void *, enum disp_action *); /* The callback itself */
+ void *opaque; /* opaque data passed back to the callback */
+};
+
+#define DISP_EYEC 0xD15241C1
+#define VALIDATE_HDL( _hdl ) \
+ ( ( ( _hdl ) != NULL ) && ( ((struct disp_hdl *)( _hdl ))->eyec == DISP_EYEC ) )
+
+/**************************************************************************************/
+
+/* Call CBs from a given list (any_handlers if cb_list is NULL) -- must have locked fd_disp_lock before */
+int fd_disp_call_cb_int( struct fd_list * cb_list, struct msg ** msg, struct avp *avp, struct session *sess, enum disp_action *action,
+ struct dict_object * obj_app, struct dict_object * obj_cmd, struct dict_object * obj_avp, struct dict_object * obj_enu,
+ char ** drop_reason, struct msg ** drop_msg)
+{
+ struct fd_list * senti, *li;
+ int r;
+ TRACE_ENTRY("%p %p %p %p %p %p %p %p %p", cb_list, msg, avp, sess, action, obj_app, obj_cmd, obj_avp, obj_enu);
+ CHECK_PARAMS(msg && action);
+
+ senti = cb_list;
+ if (!senti)
+ senti = &any_handlers;
+
+ for (li = senti->next; li != senti; li = li->next) {
+ struct disp_hdl * hdl = (struct disp_hdl *)(li->o);
+
+ TRACE_DEBUG(ANNOYING, "when: %p %p %p %p", hdl->when.app, hdl->when.command, hdl->when.avp, hdl->when.value);
+
+ /* Check this handler matches this message / avp */
+ if (hdl->when.app && (hdl->when.app != obj_app))
+ continue;
+ if (hdl->when.command && (hdl->when.command != obj_cmd))
+ continue;
+ if (hdl->when.avp && (hdl->when.avp != obj_avp))
+ continue;
+ if (hdl->when.value && (hdl->when.value != obj_enu))
+ continue;
+
+ /* We have a match, the cb must be called. */
+ CHECK_FCT_DO( (r = (*hdl->cb)(msg, avp, sess, hdl->opaque, action)),
+ {
+ *drop_reason = "Internal error: a DISPATCH callback returned an error";
+ *drop_msg = *msg;
+ *msg = NULL;
+ }
+ );
+
+ if (*action != DISP_ACT_CONT)
+ break;
+
+ if ( *msg == NULL )
+ break;
+ }
+
+ /* We're done on this list */
+ return 0;
+}
+
+/**************************************************************************************/
+
+/* Create a new handler and link it */
+int fd_disp_register ( int (*cb)( struct msg **, struct avp *, struct session *, void *, enum disp_action *),
+ enum disp_how how, struct disp_when * when, void * opaque, struct disp_hdl ** handle )
+{
+ struct fd_list * cb_list = NULL;
+ struct disp_hdl * new;
+ struct dict_object * type_enum = NULL, * type_avp;
+ struct dictionary * dict = NULL;
+
+ TRACE_ENTRY("%p %d %p %p", cb, how, when, handle);
+ CHECK_PARAMS( cb && ( (how == DISP_HOW_ANY) || when ));
+
+ switch (how) {
+ case DISP_HOW_ANY:
+ cb_list = &any_handlers;
+ break;
+
+ case DISP_HOW_APPID:
+ CHECK_FCT( fd_dict_disp_cb(DICT_APPLICATION, when->app, &cb_list) );
+ break;
+
+ case DISP_HOW_CC:
+ CHECK_FCT( fd_dict_disp_cb(DICT_COMMAND, when->command, &cb_list) );
+ break;
+
+ case DISP_HOW_AVP_ENUMVAL:
+ CHECK_FCT( fd_dict_disp_cb(DICT_ENUMVAL, when->value, &cb_list) ); /* cb_list is then overwritten */
+ CHECK_FCT( fd_dict_getdict(when->value, &dict) );
+ CHECK_FCT( fd_dict_search(dict, DICT_TYPE, TYPE_OF_ENUMVAL, when->value, &type_enum, EINVAL) );
+ case DISP_HOW_AVP:
+ CHECK_FCT( fd_dict_disp_cb(DICT_AVP, when->avp, &cb_list) );
+ if (dict) {
+ CHECK_FCT( fd_dict_search(dict, DICT_TYPE, TYPE_OF_AVP, when->avp, &type_avp, EINVAL) );
+ if (type_enum) {
+ CHECK_PARAMS( type_enum == type_avp );
+ }
+ }
+ break;
+
+ default:
+ CHECK_PARAMS(how = 0);
+ }
+ /* We might further check optional fields, but we trust the caller ^^ */
+
+ /* Create the new handler */
+ CHECK_MALLOC( new = malloc( sizeof(struct disp_hdl) ) );
+ memset(new, 0, sizeof(struct disp_hdl));
+ new->eyec = DISP_EYEC;
+ fd_list_init(&new->all, new);
+ fd_list_init(&new->parent, new);
+ new->how = how;
+ switch (how) {
+ case DISP_HOW_ANY:
+ /* there is no "when" in that case */
+ break;
+ case DISP_HOW_AVP_ENUMVAL:
+ new->when.value = when->value;
+ case DISP_HOW_AVP:
+ new->when.avp = when->avp;
+ case DISP_HOW_CC:
+ new->when.command = when->command;
+ case DISP_HOW_APPID:
+ new->when.app = when->app;
+ }
+ new->cb = cb;
+ new->opaque = opaque;
+
+ /* Now, link this new element in the appropriate lists */
+ CHECK_POSIX( pthread_rwlock_wrlock(&fd_disp_lock) );
+ fd_list_insert_before(&all_handlers, &new->all);
+ fd_list_insert_before(cb_list, &new->parent);
+ CHECK_POSIX( pthread_rwlock_unlock(&fd_disp_lock) );
+
+ /* We're done */
+ if (handle)
+ *handle = new;
+
+ return 0;
+}
+
+/* Delete a handler */
+int fd_disp_unregister ( struct disp_hdl ** handle, void ** opaque )
+{
+ struct disp_hdl * del;
+ TRACE_ENTRY("%p", handle);
+ CHECK_PARAMS( handle && VALIDATE_HDL(*handle) );
+ del = *handle;
+ *handle = NULL;
+
+ CHECK_POSIX( pthread_rwlock_wrlock(&fd_disp_lock) );
+ fd_list_unlink(&del->all);
+ fd_list_unlink(&del->parent);
+ CHECK_POSIX( pthread_rwlock_unlock(&fd_disp_lock) );
+
+ if (opaque)
+ *opaque = del->opaque;
+
+ free(del);
+ return 0;
+}
+
+/* Delete all handlers */
+void fd_disp_unregister_all ( void )
+{
+ TRACE_ENTRY("");
+ while (!FD_IS_LIST_EMPTY(&all_handlers)) {
+ CHECK_FCT_DO( fd_disp_unregister((void *)&(all_handlers.next->o), NULL), /* continue */ );
+ }
+ return;
+}