rpc: added register function and switched to hash table
[sip-router] / rpc_lookup.c
1 /* 
2  * $Id$
3  * 
4  * Copyright (C) 2009 iptelorg GmbH
5  *
6  * Permission to use, copy, modify, and distribute this software for any
7  * purpose with or without fee is hereby granted, provided that the above
8  * copyright notice and this permission notice appear in all copies.
9  *
10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17  */
18 /*
19  * SER RPC lookup and register functions
20  */
21 /*
22  * History:
23  * --------
24  *  2009-05-11  initial version (andrei)
25 */
26
27 #include "rpc.h"
28 #include "str_hash.h"
29 #include "ut.h"
30
31 #define RPC_HASH_SIZE   32
32 #define RPC_SARRAY_SIZE 32 /* initial size */
33
34 #define RPC_COPY_EXPORT
35
36 static struct str_hash_table rpc_hash_table;
37
38 /* array of pointer to rpc exports, sorted after their name
39  *  (used by listMethods) */
40 rpc_export_t** rpc_sarray;
41 int rpc_sarray_crt_size; /* used */
42 static int rpc_sarray_max_size; /* number of entries alloc'ed */
43
44 /** init the rpc hash table.
45   * @return 0 on success, -1 on error
46   */
47 int init_rpcs()
48 {
49         if (str_hash_alloc(&rpc_hash_table, RPC_HASH_SIZE)<0)
50                 return -1;
51         str_hash_init(&rpc_hash_table);
52         rpc_sarray_max_size=RPC_SARRAY_SIZE;
53         rpc_sarray=pkg_malloc(sizeof(*rpc_sarray)* rpc_sarray_max_size);
54         rpc_sarray_crt_size=0;
55         return 0;
56 }
57
58
59
60 void destroy_rpcs()
61 {
62         int r;
63         struct str_hash_entry* e;
64         struct str_hash_entry* bak;
65         for (r=0; r<rpc_hash_table.size; r++){
66                 clist_foreach_safe(&rpc_hash_table.table[r], e, bak, next){
67                         pkg_free(e);
68                 }
69         }
70         pkg_free(rpc_hash_table.table);
71         pkg_free(rpc_sarray);
72         rpc_hash_table.table=0;
73         rpc_hash_table.size=0;
74         rpc_sarray=0;
75         rpc_sarray_crt_size=0;
76         rpc_sarray_max_size=0;
77 }
78
79
80
81 /** adds a new rpc to the hash table (no checks).
82  * @return 0 on success, -1 on error, 1 on duplicate
83  */
84 static int rpc_hash_add(struct rpc_export* rpc)
85 {
86         struct str_hash_entry* e;
87         int name_len;
88         int doc0_len, doc1_len;
89         struct rpc_export* n_rpc;
90         struct rpc_export** r;
91         
92         name_len=strlen(rpc->name);
93         doc0_len=rpc->doc_str[0]?strlen(rpc->doc_str[0]):0;
94         doc1_len=rpc->doc_str[1]?strlen(rpc->doc_str[1]):0;
95         /* alloc everything into one block */
96         e=pkg_malloc(ROUND_POINTER(sizeof(struct str_hash_entry))
97 #ifdef RPC_COPY_EXPORT
98                                                                 +ROUND_POINTER(sizeof(*rpc))+2*sizeof(char*)+
99                                                                 +name_len+1+doc0_len+(rpc->doc_str[0]!=0)
100                                                                 +doc1_len+(rpc->doc_str[1]!=0)
101 #endif /* RPC_COPY_EXPORT */
102                                                                 );
103         if (e==0){
104                 ERR("out of memory\n");
105                 goto error;
106         }
107 #ifdef RPC_COPY_EXPORT
108         n_rpc=(rpc_export_t*)((char*)e+
109                         ROUND_POINTER(sizeof(struct str_hash_entry)));
110         /* copy rpc into n_rpc */
111         *n_rpc=*rpc;
112         n_rpc->doc_str=(const char**)((char*)n_rpc+ROUND_POINTER(sizeof(*rpc)));
113         n_rpc->name=(char*)n_rpc->doc_str+2*sizeof(char*);
114         memcpy((char*)n_rpc->name, rpc->name, name_len);
115         *((char*)&n_rpc->name[name_len])=0;
116         if (rpc->doc_str[0]){
117                 n_rpc->doc_str[0]=&n_rpc->name[name_len+1];
118                 memcpy((char*)n_rpc->doc_str[0], rpc->doc_str[0], doc0_len);
119                 *(char*)&(n_rpc->doc_str[0][doc0_len])=0;
120         }else{
121                 n_rpc->doc_str[0]=0;
122         }
123         if (rpc->doc_str[1]){
124                 n_rpc->doc_str[1]=n_rpc->doc_str[0]?&n_rpc->doc_str[0][doc0_len+1]:
125                                                         &n_rpc->name[name_len+1];;
126                 memcpy((char*)n_rpc->doc_str[1], rpc->doc_str[1], doc1_len);
127                 *(char*)&(n_rpc->doc_str[1][doc1_len])=0;
128         }else{
129                 n_rpc->doc_str[1]=0;
130         }
131 #else /* RPC_COPY_EXPORT */
132         n_rpc=rpc;
133 #endif /* RPC_COPY_EXPORT */
134         
135         e->key.s=(char*)n_rpc->name;
136         e->key.len=name_len;
137         e->flags=0;
138         e->u.p=n_rpc;
139         str_hash_add(&rpc_hash_table, e);
140         
141         /* insert it into the sorted array */
142         if (rpc_sarray_max_size<=rpc_sarray_crt_size){
143                 /* array must be increased */
144                 r=pkg_realloc(rpc_sarray, 2*rpc_sarray_max_size*sizeof(*rpc_sarray));
145                 if (r==0){
146                         ERR("out of memory while adding RPC to the sorted list\n");
147                         goto error;
148                 }
149                 rpc_sarray=r;
150                 rpc_sarray_max_size*=2;
151         };
152         /* insert into array, sorted */
153         for (r=rpc_sarray;r<(rpc_sarray+rpc_sarray_crt_size); r++){
154                 if (strcmp(n_rpc->name, (*r)->name)<0)
155                         break;
156         }
157         if (r!=(rpc_sarray+rpc_sarray_crt_size))
158                 memmove(r+1, r, (int)(long)((char*)(rpc_sarray+rpc_sarray_crt_size)-
159                                                                                         (char*)r));
160         rpc_sarray_crt_size++;
161         *r=n_rpc;
162         return 0;
163 error:
164         return -1;
165 }
166
167
168
169 /** lookup an rpc export after its name.
170  * @return pointer to rpc export on success, 0 on error
171  */
172 rpc_export_t* rpc_lookup(const char* name, int len)
173 {
174         struct str_hash_entry* e;
175         
176         e=str_hash_get(&rpc_hash_table, (char*)name, len);
177         return e?(rpc_export_t*)e->u.p:0;
178 }
179
180
181
182 /** register a new rpc.
183  * @return 0 on success, -1 on error, 1 on duplicate
184  */
185 int rpc_register(rpc_export_t* rpc)
186 {
187         
188         /* check if the entry is already registered */
189         if (rpc_lookup(rpc->name, strlen(rpc->name)))
190                 return 1;
191         if (rpc_hash_add(rpc)!=0) return -1;
192         return 0;
193 }
194
195
196
197 /** register all the rpc in a null-terminated array.
198   * @return 0 on success, >0 if duplicates were found (number of 
199   * duplicates), -1 on error
200   */
201 int rpc_register_array(rpc_export_t* rpc_array)
202 {
203         rpc_export_t* rpc;
204         int ret,i;
205         
206         ret=0;
207         for (rpc=rpc_array; rpc && rpc->name; rpc++){
208                 i=rpc_register(rpc);
209                 if (i!=0){
210                         if (i<0) goto error;
211                         ret++;
212                 }
213         }
214         return ret;
215 error:
216         return -1;
217 }
218
219
220 /* vi: set ts=4 sw=4 tw=79:ai:cindent: */