← Back to branch summary

~ubuntu-branches/debian/sid/kamailio/sid

« back to all changes in this revision

Viewing changes to .pc/spelling_errors.patch/modules/presence/event_list.c

  • Committer: Package Import Robot
  • Author(s): Victor Seva
  • Date: 2014-01-06 11:47:13 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20140106114713-t8xidp4arzrnyeya
Tags: 4.1.1-1
http://bugs.debian.org/728915
* New upstream release
* debian/patches:
  - add upstream fixes
* Added tls outbound websocket autheph dnssec modules
  - openssl exception added to their license
* removing sparc and ia64 from supported archs
  for mono module (Closes: #728915)

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/spelling_errors.patch/modules/presence/event_list.c
1
 
/*
2
 
 * Copyright (C) 2006 Voice Sistem S.R.L.
3
 
 *
4
 
 * This file is part of Kamailio, a free SIP server.
5
 
 *
6
 
 * Kamailio is free software; you can redistribute it and/or modify
7
 
 * it under the terms of the GNU General Public License as published by
8
 
 * the Free Software Foundation; either version 2 of the License, or
9
 
 * (at your option) any later version
10
 
 *
11
 
 * Kamailio is distributed in the hope that it will be useful,
12
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 * GNU General Public License for more details.
15
 
 *
16
 
 * You should have received a copy of the GNU General Public License 
17
 
 * along with this program; if not, write to the Free Software 
18
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 
 *
20
 
 * History:
21
 
 * --------
22
 
 *  2007-04-04  initial version (Anca Vamanu)
23
 
 */
24
 
 
25
 
/*!
26
 
 * \file
27
 
 * \brief Kamailio presence module :: Events
28
 
 * \ingroup presence 
29
 
 */
30
 
 
31
 
 
32
 
#include <stdlib.h>
33
 
#include<stdio.h>
34
 
#include <string.h>
35
 
#include "../../str.h"
36
 
#include "../../dprint.h"
37
 
#include "../../parser/parse_event.h" 
38
 
#include "../../mem/shm_mem.h" 
39
 
#include "../../mem/mem.h" 
40
 
#include "event_list.h"
41
 
#include "hash.h"
42
 
 
43
 
#define MAX_EVNAME_SIZE 20
44
 
 
45
 
int search_event_params(event_t* ev, event_t* searched_ev);
46
 
 
47
 
event_t* shm_copy_event(event_t* e)
48
 
{
49
 
        event_t* ev= NULL;
50
 
        param_t* p1, *p2;
51
 
        int size;
52
 
 
53
 
        ev= (event_t*)shm_malloc(sizeof(event_t));
54
 
        if(ev== NULL)
55
 
        {
56
 
                ERR_MEM(SHARE_MEM);
57
 
        }
58
 
        memset(ev, 0, sizeof(event_t));
59
 
 
60
 
        ev->name.s= (char*)shm_malloc(e->name.len* sizeof(char));
61
 
        if(ev->name.s== NULL)
62
 
        {
63
 
                ERR_MEM(SHARE_MEM);
64
 
        }
65
 
        memcpy(ev->name.s, e->name.s, e->name.len);
66
 
        ev->name.len= e->name.len;
67
 
 
68
 
        p1= e->params.list;
69
 
        while(p1)
70
 
        {
71
 
                size= sizeof(param_t)+ (p1->name.len+ p1->body.len)* sizeof(char);
72
 
                p2= (param_t*)shm_malloc(size);
73
 
                if(p2== NULL)
74
 
                {
75
 
                        ERR_MEM(SHARE_MEM);
76
 
                }
77
 
                memset(p2, 0, size);
78
 
 
79
 
                size= sizeof(param_t);
80
 
                CONT_COPY(p2, p2->name, p1->name);
81
 
                if(p1->body.s && p1->body.len)
82
 
                        CONT_COPY(p2, p2->body, p1->body);
83
 
                p2->next= ev->params.list;
84
 
                ev->params.list= p2;
85
 
 
86
 
                /* Update parameter hooks in the shmmem copy, this is needed so that
87
 
                 * we can test for the presence of the sla parameter even in the
88
 
                 * shared copy of the event */
89
 
                if (e->params.hooks.event_dialog.call_id == p1)
90
 
                        ev->params.hooks.event_dialog.call_id = p2;
91
 
                if (e->params.hooks.event_dialog.from_tag == p1)
92
 
                        ev->params.hooks.event_dialog.from_tag = p2;
93
 
                if (e->params.hooks.event_dialog.to_tag == p1)
94
 
                        ev->params.hooks.event_dialog.to_tag = p2;
95
 
                if (e->params.hooks.event_dialog.include_session_description == p1) 
96
 
                        ev->params.hooks.event_dialog.include_session_description = p2;
97
 
                if (e->params.hooks.event_dialog.sla == p1)
98
 
                        ev->params.hooks.event_dialog.sla = p2;
99
 
 
100
 
                p1= p1->next;
101
 
        }
102
 
        ev->type= e->type;
103
 
 
104
 
        return ev;
105
 
 
106
 
error:
107
 
        shm_free_event(ev);
108
 
        return NULL;
109
 
}
110
 
 
111
 
void shm_free_event(event_t* ev)
112
 
{
113
 
        if(ev== NULL)
114
 
                return;
115
 
        
116
 
        if(ev->name.s)
117
 
                shm_free(ev->name.s);
118
 
 
119
 
        free_event_params(ev->params.list, SHM_MEM_TYPE);
120
 
 
121
 
        shm_free(ev);
122
 
}
123
 
 
124
 
 
125
 
int add_event(pres_ev_t* event)
126
 
{
127
 
        pres_ev_t* ev= NULL;
128
 
        event_t parsed_event;
129
 
        str wipeer_name;
130
 
        char* sep;
131
 
        char buf[50];
132
 
        int not_in_list= 0;
133
 
 
134
 
        memset(&parsed_event, 0, sizeof(event_t));
135
 
 
136
 
        if(event->name.s== NULL || event->name.len== 0)
137
 
        {
138
 
                LM_ERR("NULL event name\n");
139
 
                return -1;
140
 
        }
141
 
 
142
 
        if(event->content_type.s== NULL || event->content_type.len== 0)
143
 
        {
144
 
                LM_ERR("NULL content_type param\n");
145
 
                return -1;
146
 
        }
147
 
        
148
 
        ev= contains_event(&event->name, &parsed_event);
149
 
        if(ev== NULL)
150
 
        {
151
 
                not_in_list= 1;
152
 
                ev= (pres_ev_t*)shm_malloc(sizeof(pres_ev_t));
153
 
                if(ev== NULL)
154
 
                {
155
 
                        free_event_params(parsed_event.params.list, PKG_MEM_TYPE);
156
 
                        ERR_MEM(SHARE_MEM);
157
 
                }
158
 
                memset(ev, 0, sizeof(pres_ev_t));
159
 
                ev->name.s= (char*)shm_malloc(event->name.len* sizeof(char));
160
 
                if(ev->name.s== NULL)
161
 
                {
162
 
                        ERR_MEM(SHARE_MEM);
163
 
                }
164
 
                memcpy(ev->name.s, event->name.s, event->name.len);
165
 
                ev->name.len= event->name.len;
166
 
 
167
 
                ev->evp= shm_copy_event(&parsed_event);
168
 
                if(ev->evp== NULL)
169
 
                {
170
 
                        LM_ERR("copying event_t structure\n");
171
 
                        goto error;
172
 
                }
173
 
        }
174
 
        else
175
 
        {
176
 
                if(ev->content_type.s)
177
 
                {
178
 
                        LM_DBG("Event already registered\n");
179
 
                        goto done;
180
 
                }
181
 
        }
182
 
 
183
 
        ev->content_type.s=
184
 
                        (char*)shm_malloc(event->content_type.len* sizeof(char)) ;
185
 
        if(ev->content_type.s== NULL)
186
 
        {
187
 
                ERR_MEM(SHARE_MEM);
188
 
        }       
189
 
        ev->content_type.len= event->content_type.len;
190
 
        memcpy(ev->content_type.s, event->content_type.s, event->content_type.len);
191
 
 
192
 
        for(sep=parsed_event.name.s; sep<parsed_event.name.s+parsed_event.name.len;
193
 
                        sep++)
194
 
                if(*sep=='.') break;
195
 
        if(sep>=parsed_event.name.s+parsed_event.name.len) sep=0;
196
 
        if(sep && strncmp(sep+1, "winfo", 5)== 0)
197
 
        {       
198
 
                ev->type= WINFO_TYPE;
199
 
                wipeer_name.s= parsed_event.name.s;
200
 
                wipeer_name.len= sep - parsed_event.name.s;
201
 
                ev->wipeer= contains_event(&wipeer_name, NULL);
202
 
                if (ev->wipeer) {
203
 
                        LM_DBG("Found wipeer event [%.*s] for event [%.*s]\n",
204
 
                                        wipeer_name.len,wipeer_name.s,
205
 
                                        parsed_event.name.len,parsed_event.name.s);
206
 
                }
207
 
        }
208
 
        else
209
 
        {       
210
 
                ev->type= PUBL_TYPE;
211
 
                if (parsed_event.name.len + 6 > 50) {
212
 
                        LM_ERR("buffer too small\n");
213
 
                        goto error;
214
 
                }
215
 
                wipeer_name.s= buf;
216
 
                memcpy(wipeer_name.s, parsed_event.name.s, parsed_event.name.len);
217
 
                wipeer_name.len= parsed_event.name.len;
218
 
                memcpy(wipeer_name.s+ wipeer_name.len, ".winfo", 6);
219
 
                wipeer_name.len+= 6;
220
 
                ev->wipeer= contains_event(&wipeer_name, NULL);
221
 
                if (ev->wipeer) {
222
 
                        LM_DBG("Found wipeer event [%.*s] for event [%.*s]\n",
223
 
                                        wipeer_name.len,wipeer_name.s,
224
 
                                        parsed_event.name.len,parsed_event.name.s);
225
 
                }
226
 
        }
227
 
        
228
 
        if(ev->wipeer)  
229
 
                ev->wipeer->wipeer= ev;
230
 
 
231
 
        if(event->req_auth && 
232
 
                ( event->get_auth_status==0 ||event->get_rules_doc== 0))
233
 
        {
234
 
                LM_ERR("bad event structure\n");
235
 
                goto error;
236
 
        }
237
 
        ev->req_auth= event->req_auth;
238
 
        ev->agg_nbody= event->agg_nbody;
239
 
        ev->apply_auth_nbody= event->apply_auth_nbody;
240
 
        ev->get_auth_status= event->get_auth_status;
241
 
        ev->get_rules_doc= event->get_rules_doc;
242
 
        ev->get_pidf_doc= event->get_pidf_doc;
243
 
        ev->evs_publ_handl= event->evs_publ_handl;
244
 
        ev->evs_subs_handl= event->evs_subs_handl;
245
 
        ev->etag_not_new= event->etag_not_new;
246
 
        ev->aux_body_processing= event->aux_body_processing;
247
 
        ev->aux_free_body= event->aux_free_body;
248
 
        ev->free_body= event->free_body;
249
 
        ev->default_expires= event->default_expires;
250
 
 
251
 
        if(not_in_list)
252
 
        {
253
 
                ev->next= EvList->events;
254
 
                EvList->events= ev;
255
 
        }
256
 
        EvList->ev_count++;
257
 
        
258
 
        LM_DBG("succesfully added event: %.*s - len= %d\n",ev->name.len,
259
 
                        ev->name.s, ev->name.len);
260
 
done:
261
 
        free_event_params(parsed_event.params.list, PKG_MEM_TYPE);
262
 
        return 0;
263
 
error:
264
 
        free_event_params(parsed_event.params.list, PKG_MEM_TYPE);
265
 
        if(ev && not_in_list)
266
 
        {
267
 
                free_pres_event(ev);    
268
 
        }
269
 
        return -1;
270
 
}
271
 
 
272
 
void free_pres_event(pres_ev_t* ev)
273
 
{
274
 
        if(ev== NULL)
275
 
                return;
276
 
 
277
 
        if(ev->name.s)
278
 
                shm_free(ev->name.s);
279
 
        if(ev->content_type.s)
280
 
                shm_free(ev->content_type.s);
281
 
        if(ev->wipeer)
282
 
                ev->wipeer->wipeer = 0;
283
 
        shm_free_event(ev->evp);
284
 
        shm_free(ev);
285
 
 
286
 
}
287
 
 
288
 
evlist_t* init_evlist(void)
289
 
{
290
 
        evlist_t*  list= NULL;
291
 
 
292
 
        list= (evlist_t*)shm_malloc(sizeof(evlist_t));
293
 
        if(list== NULL)
294
 
        {
295
 
                LM_ERR("no more share memory\n");
296
 
                return NULL;
297
 
        }
298
 
        list->ev_count= 0;
299
 
        list->events= NULL;
300
 
        
301
 
        return list;
302
 
}       
303
 
 
304
 
pres_ev_t* contains_event(str* sname, event_t* parsed_event)
305
 
{
306
 
        event_t event;
307
 
        event_t *pe;
308
 
        pres_ev_t* e;
309
 
        
310
 
        pe = (parsed_event)?parsed_event:&event;
311
 
 
312
 
        memset(pe, 0, sizeof(event_t));
313
 
        if(event_parser(sname->s, sname->len, pe)< 0)
314
 
        {
315
 
                LM_ERR("parsing event\n");
316
 
                return NULL;
317
 
        }
318
 
        e= search_event(pe);
319
 
        if(parsed_event==0)
320
 
        {
321
 
                free_event_params(pe->params.list, PKG_MEM_TYPE);
322
 
                pe->params.list = NULL;
323
 
        }
324
 
 
325
 
        return e;
326
 
}
327
 
 
328
 
void free_event_params(param_t* params, int mem_type)
329
 
{
330
 
        param_t* t1, *t2;
331
 
        t2= t1= params;
332
 
 
333
 
        while(t1)
334
 
        {
335
 
                t2= t1->next;
336
 
                if(mem_type == SHM_MEM_TYPE)
337
 
                        shm_free(t1);
338
 
                else
339
 
                        pkg_free(t1);
340
 
                t1= t2;
341
 
        }
342
 
        
343
 
}
344
 
 
345
 
pres_ev_t* search_event(event_t* event)
346
 
{
347
 
        pres_ev_t* pres_ev;
348
 
        pres_ev= EvList->events;
349
 
 
350
 
        LM_DBG("start event= [%.*s/%d]\n", event->name.len, event->name.s,
351
 
                        event->type);
352
 
 
353
 
        while(pres_ev)
354
 
        {
355
 
                if((pres_ev->evp->type== event->type && event->type!=EVENT_OTHER)
356
 
                        || (pres_ev->evp->name.len== event->name.len &&
357
 
                                strncasecmp(pres_ev->evp->name.s,event->name.s,
358
 
                                        pres_ev->evp->name.len)== 0))
359
 
                {
360
 
                        if(event->params.list== NULL && pres_ev->evp->params.list== NULL)
361
 
                        {
362
 
                                return pres_ev;
363
 
                        }
364
 
        
365
 
                        /* search all parameters in event in ev */
366
 
                        if(search_event_params(event, pres_ev->evp)< 0)
367
 
                                goto cont;
368
 
                        
369
 
                        /* search all parameters in ev in event */
370
 
                        if(search_event_params(pres_ev->evp, event)< 0)
371
 
                                goto cont;
372
 
 
373
 
                        return pres_ev;
374
 
                }
375
 
cont:           pres_ev= pres_ev->next;
376
 
        }
377
 
        return NULL;
378
 
 
379
 
}
380
 
 
381
 
int search_event_params(event_t* ev, event_t* searched_ev)
382
 
{
383
 
        param_t* ps, *p;
384
 
        int found;
385
 
 
386
 
        ps= ev->params.list;
387
 
 
388
 
        while(ps)
389
 
        {
390
 
                p= searched_ev->params.list;
391
 
                found= 0;
392
 
        
393
 
                while(p)
394
 
                {
395
 
                        if(p->name.len== ps->name.len && 
396
 
                                strncmp(p->name.s,ps->name.s, ps->name.len)== 0)
397
 
                                if((p->body.s== 0 && ps->body.s== 0) ||
398
 
                                        (p->body.len== ps->body.len && 
399
 
                                        strncmp(p->body.s,ps->body.s,ps->body.len)== 0))
400
 
                                {
401
 
                                        found= 1;
402
 
                                        break;
403
 
                                }
404
 
                                p= p->next;
405
 
                }
406
 
                if(found== 0)
407
 
                        return -1;
408
 
                ps= ps->next;
409
 
        }
410
 
 
411
 
        return 1;
412
 
 
413
 
}
414
 
int get_event_list(str** ev_list)
415
 
{       
416
 
        pres_ev_t* ev= EvList->events;
417
 
        int i;
418
 
        str* list;
419
 
        *ev_list= NULL;
420
 
        
421
 
        if(EvList->ev_count== 0)
422
 
                return 0;
423
 
        
424
 
        list= (str*)pkg_malloc(sizeof(str));
425
 
        if(list== NULL)
426
 
        {
427
 
                LM_ERR("No more memory\n");
428
 
                return -1;
429
 
        }
430
 
        memset(list, 0, sizeof(str));
431
 
        list->s= (char*)pkg_malloc(EvList->ev_count* MAX_EVNAME_SIZE);
432
 
        if(list->s== NULL)
433
 
        {
434
 
                LM_ERR("No more memory\n");
435
 
                pkg_free(list);
436
 
                return -1;
437
 
        }
438
 
        list->s[0]= '\0';
439
 
        
440
 
        for(i= 0; i< EvList->ev_count; i++)
441
 
        {
442
 
                if(i> 0)
443
 
                {
444
 
                        memcpy(list->s+ list->len, ", ", 2);
445
 
                        list->len+= 2;
446
 
                }       
447
 
                memcpy(list->s+ list->len, ev->name.s, ev->name.len );
448
 
                list->len+= ev->name.len ;
449
 
                ev= ev->next;
450
 
        }
451
 
        
452
 
        *ev_list= list;
453
 
        return 0;
454
 
}
455
 
 
456
 
void destroy_evlist(void)
457
 
{
458
 
    pres_ev_t* e1, *e2;
459
 
    if (EvList) 
460
 
        {
461
 
                e1= EvList->events;
462
 
                while(e1)
463
 
            {
464
 
                        e2= e1->next;
465
 
                        free_pres_event(e1);
466
 
                        e1= e2;
467
 
            }   
468
 
                shm_free(EvList);
469
 
    }
470
 
}
471