dispatch.c

Last change on this file was 1151:100a0925f809, checked in by Sebastien Decugis <sdecugis@freediameter.net>, 8 years ago
Fix a number of issues reported by cppcheck: http://lists.freediameter.net/pipermail/dev/2013-May/000214.html
File size: 8.3 KB

Line
1	/*********************************************************************************************************
2	* Software License Agreement (BSD License) *
3	* Author: Sebastien Decugis <sdecugis@freediameter.net> *
4	* *
5	* Copyright (c) 2013, WIDE Project and NICT *
6	* All rights reserved. *
7	* *
8	* Redistribution and use of this software in source and binary forms, with or without modification, are *
9	* permitted provided that the following conditions are met: *
10	* *
11	* * Redistributions of source code must retain the above *
12	* copyright notice, this list of conditions and the *
13	* following disclaimer. *
14	* *
15	* * Redistributions in binary form must reproduce the above *
16	* copyright notice, this list of conditions and the *
17	* following disclaimer in the documentation and/or other *
18	* materials provided with the distribution. *
19	* *
20	* * Neither the name of the WIDE Project or NICT nor the *
21	* names of its contributors may be used to endorse or *
22	* promote products derived from this software without *
23	* specific prior written permission of WIDE Project and *
24	* NICT. *
25	* *
26	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED *
27	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
28	* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR *
29	* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT *
30	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS *
31	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR *
32	* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF *
33	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
34	*********************************************************************************************************/
35
36	#include "fdproto-internal.h"
37
38	/* The dispatch module in the library is quite simple: callbacks are saved in a global list
39	* in no particular order. In addition, they are also linked from the dictionary objects they
40	* refer to. */
41
42	/* Protection for the lists managed in this module. */
43	pthread_rwlock_t fd_disp_lock = PTHREAD_RWLOCK_INITIALIZER;
44
45	/* List of all registered handlers -- useful if we want to cleanup properly at some point... */
46	static struct fd_list all_handlers = FD_LIST_INITIALIZER( all_handlers );
47
48	/* List of handlers registered for DISP_HOW_ANY. Other handlers are stored in the dictionary */
49	static struct fd_list any_handlers = FD_LIST_INITIALIZER( any_handlers );
50
51	/* The structure to store a callback */
52	struct disp_hdl {
53	int eyec; /* Eye catcher, DISP_EYEC */
54	struct fd_list all; /* link in the all_handlers list */
55	struct fd_list parent;/* link in dictionary cb_list or in any_handlers */
56	enum disp_how how; /* Copy of registration parameter */
57	struct disp_when when; /* Copy of registration parameter */
58	int (cb)( struct msg , struct avp , struct session , void , enum disp_action ); / The callback itself */
59	void opaque; / opaque data passed back to the callback */
60	};
61
62	#define DISP_EYEC 0xD15241C1
63	#define VALIDATE_HDL( _hdl ) \
64	( ( ( _hdl ) != NULL ) && ( ((struct disp_hdl *)( _hdl ))->eyec == DISP_EYEC ) )
65
66	/**************************************************************************************/
67
68	/* Call CBs from a given list (any_handlers if cb_list is NULL) -- must have locked fd_disp_lock before */
69	int fd_disp_call_cb_int( struct fd_list * cb_list, struct msg ** msg, struct avp avp, struct session sess, enum disp_action *action,
70	struct dict_object * obj_app, struct dict_object * obj_cmd, struct dict_object * obj_avp, struct dict_object * obj_enu,
71	char drop_reason, struct msg drop_msg)
72	{
73	struct fd_list * senti, *li;
74	int r;
75	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);
76	CHECK_PARAMS(msg && action);
77
78	senti = cb_list;
79	if (!senti)
80	senti = &any_handlers;
81
82	for (li = senti->next; li != senti; li = li->next) {
83	struct disp_hdl * hdl = (struct disp_hdl *)(li->o);
84
85	TRACE_DEBUG(ANNOYING, "when: %p %p %p %p", hdl->when.app, hdl->when.command, hdl->when.avp, hdl->when.value);
86
87	/* Check this handler matches this message / avp */
88	if (hdl->when.app && (hdl->when.app != obj_app))
89	continue;
90	if (hdl->when.command && (hdl->when.command != obj_cmd))
91	continue;
92	if (hdl->when.avp && (hdl->when.avp != obj_avp))
93	continue;
94	if (hdl->when.value && (hdl->when.value != obj_enu))
95	continue;
96
97	/* We have a match, the cb must be called. */
98	CHECK_FCT_DO( (r = (*hdl->cb)(msg, avp, sess, hdl->opaque, action)),
99	{
100	*drop_reason = "Internal error: a DISPATCH callback returned an error";
101	drop_msg = msg;
102	*msg = NULL;
103	}
104	);
105
106	if (*action != DISP_ACT_CONT)
107	break;
108
109	if ( *msg == NULL )
110	break;
111	}
112
113	/* We're done on this list */
114	return 0;
115	}
116
117	/**************************************************************************************/
118
119	/* Create a new handler and link it */
120	int fd_disp_register ( int (cb)( struct msg , struct avp , struct session , void , enum disp_action *),
121	enum disp_how how, struct disp_when * when, void * opaque, struct disp_hdl ** handle )
122	{
123	struct fd_list * cb_list = NULL;
124	struct disp_hdl * new;
125	struct dict_object * type_enum = NULL, * type_avp;
126	struct dictionary * dict = NULL;
127
128	TRACE_ENTRY("%p %d %p %p", cb, how, when, handle);
129	CHECK_PARAMS( cb && ( (how == DISP_HOW_ANY) \|\| when ));
130
131	switch (how) {
132	case DISP_HOW_ANY:
133	cb_list = &any_handlers;
134	break;
135
136	case DISP_HOW_APPID:
137	CHECK_FCT( fd_dict_disp_cb(DICT_APPLICATION, when->app, &cb_list) );
138	break;
139
140	case DISP_HOW_CC:
141	CHECK_FCT( fd_dict_disp_cb(DICT_COMMAND, when->command, &cb_list) );
142	break;
143
144	case DISP_HOW_AVP_ENUMVAL:
145	CHECK_FCT( fd_dict_disp_cb(DICT_ENUMVAL, when->value, &cb_list) ); /* cb_list is then overwritten */
146	CHECK_FCT( fd_dict_getdict(when->value, &dict) );
147	CHECK_FCT( fd_dict_search(dict, DICT_TYPE, TYPE_OF_ENUMVAL, when->value, &type_enum, EINVAL) );
148	case DISP_HOW_AVP:
149	CHECK_FCT( fd_dict_disp_cb(DICT_AVP, when->avp, &cb_list) );
150	if (dict) {
151	CHECK_FCT( fd_dict_search(dict, DICT_TYPE, TYPE_OF_AVP, when->avp, &type_avp, EINVAL) );
152	if (type_enum) {
153	CHECK_PARAMS( type_enum == type_avp );
154	}
155	}
156	break;
157
158	default:
159	CHECK_PARAMS(how = 0);
160	}
161	/* We might further check optional fields, but we trust the caller ^^ */
162
163	/* Create the new handler */
164	CHECK_MALLOC( new = malloc( sizeof(struct disp_hdl) ) );
165	memset(new, 0, sizeof(struct disp_hdl));
166	new->eyec = DISP_EYEC;
167	fd_list_init(&new->all, new);
168	fd_list_init(&new->parent, new);
169	new->how = how;
170	switch (how) {
171	case DISP_HOW_ANY:
172	/* there is no "when" in that case */
173	break;
174	case DISP_HOW_AVP_ENUMVAL:
175	new->when.value = when->value;
176	case DISP_HOW_AVP:
177	new->when.avp = when->avp;
178	case DISP_HOW_CC:
179	new->when.command = when->command;
180	case DISP_HOW_APPID:
181	new->when.app = when->app;
182	}
183	new->cb = cb;
184	new->opaque = opaque;
185
186	/* Now, link this new element in the appropriate lists */
187	CHECK_POSIX( pthread_rwlock_wrlock(&fd_disp_lock) );
188	fd_list_insert_before(&all_handlers, &new->all);
189	fd_list_insert_before(cb_list, &new->parent);
190	CHECK_POSIX( pthread_rwlock_unlock(&fd_disp_lock) );
191
192	/* We're done */
193	if (handle)
194	*handle = new;
195
196	return 0;
197	}
198
199	/* Delete a handler */
200	int fd_disp_unregister ( struct disp_hdl handle, void opaque )
201	{
202	struct disp_hdl * del;
203	TRACE_ENTRY("%p", handle);
204	CHECK_PARAMS( handle && VALIDATE_HDL(*handle) );
205	del = *handle;
206	*handle = NULL;
207
208	CHECK_POSIX( pthread_rwlock_wrlock(&fd_disp_lock) );
209	fd_list_unlink(&del->all);
210	fd_list_unlink(&del->parent);
211	CHECK_POSIX( pthread_rwlock_unlock(&fd_disp_lock) );
212
213	if (opaque)
214	*opaque = del->opaque;
215
216	free(del);
217	return 0;
218	}
219
220	/* Delete all handlers */
221	void fd_disp_unregister_all ( void )
222	{
223	TRACE_ENTRY("");
224	while (!FD_IS_LIST_EMPTY(&all_handlers)) {
225	CHECK_FCT_DO( fd_disp_unregister((void )&(all_handlers.next->o), NULL), / continue */ );
226	}
227	return;
228	}

Note: See TracBrowser for help on using the repository browser.

Navigation

source: freeDiameter/libfdproto/dispatch.c

Download in other formats: