229 lines
8.3 KiB
C
229 lines
8.3 KiB
C
/*********************************************************************************************************
|
|
* 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;
|
|
}
|