all: updated FSF address in GPL text
[sip-router] / modules / ims_registrar_pcscf / async_reginfo.c
1 /*
2  * $Id$
3  *
4  * Copyright (C) 2012 Smile Communications, jason.penton@smilecoms.com
5  * Copyright (C) 2012 Smile Communications, richard.good@smilecoms.com
6  * 
7  * The initial version of this code was written by Dragos Vingarzan
8  * (dragos(dot)vingarzan(at)fokus(dot)fraunhofer(dot)de and the
9  * Fruanhofer Institute. It was and still is maintained in a separate
10  * branch of the original SER. We are therefore migrating it to
11  * Kamailio/SR and look forward to maintaining it from here on out.
12  * 2011/2012 Smile Communications, Pty. Ltd.
13  * ported/maintained/improved by 
14  * Jason Penton (jason(dot)penton(at)smilecoms.com and
15  * Richard Good (richard(dot)good(at)smilecoms.com) as part of an 
16  * effort to add full IMS support to Kamailio/SR using a new and
17  * improved architecture
18  * 
19  * NB: Alot of this code was originally part of OpenIMSCore,
20  * FhG Fokus. 
21  * Copyright (C) 2004-2006 FhG Fokus
22  * Thanks for great work! This is an effort to 
23  * break apart the various CSCF functions into logically separate
24  * components. We hope this will drive wider use. We also feel
25  * that in this way the architecture is more complete and thereby easier
26  * to manage in the Kamailio/SR environment
27  *
28  * This file is part of Kamailio, a free SIP server.
29  *
30  * Kamailio is free software; you can redistribute it and/or modify
31  * it under the terms of the GNU General Public License as published by
32  * the Free Software Foundation; either version 2 of the License, or
33  * (at your option) any later version
34  *
35  * Kamailio is distributed in the hope that it will be useful,
36  * but WITHOUT ANY WARRANTY; without even the implied warranty of
37  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
38  * GNU General Public License for more details.
39  *
40  * You should have received a copy of the GNU General Public License 
41  * along with this program; if not, write to the Free Software 
42  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
43  * 
44  */
45
46 #include <time.h>
47 #include "async_reginfo.h"
48
49 reginfo_event_list_t *reginfo_event_list = 0;
50
51 int init_reginfo_event_list()
52 {
53         reginfo_event_list = shm_malloc(sizeof(reginfo_event_list_t));
54         if (!reginfo_event_list) {
55                 LM_ERR("No more SHM mem\n");
56                 return 0;
57         }
58         memset(reginfo_event_list, 0, sizeof(reginfo_event_list_t));
59         reginfo_event_list->lock = lock_alloc();
60         if (!reginfo_event_list->lock) {
61                 LM_ERR("failed to create reginfo event list lock\n");
62                 return 0;
63         }
64         reginfo_event_list->lock = lock_init(reginfo_event_list->lock);
65
66         sem_new(reginfo_event_list->empty, 0); //pre-locked - as we assume list is empty at start
67
68         return 1;
69 }
70 void destroy_reginfo_event_list()
71 {
72         reginfo_event_t *ev, *tmp;
73
74         lock_get(reginfo_event_list->lock);
75         ev = reginfo_event_list->head;
76         while (ev) {
77                 tmp = ev->next;
78                 free_reginfo_event(ev);
79                 ev = tmp;
80         }
81         lock_destroy(reginfo_event_list->lock);
82         lock_dealloc(reginfo_event_list->lock);
83         shm_free(reginfo_event_list);
84 }
85
86 reginfo_event_t* new_reginfo_event (int event)
87 {
88         reginfo_event_t *new_event = shm_malloc(sizeof(reginfo_event_t));
89         if (!new_event) {
90                 LM_ERR("No more shm mem\n");
91                 return NULL;
92         }
93         new_event->registered = time(NULL);
94         new_event->event = event;
95         new_event->next = 0;
96
97         return new_event;
98 }
99
100 void push_reginfo_event(reginfo_event_t* event)
101 {
102         lock_get(reginfo_event_list->lock);
103         if (reginfo_event_list->head == 0) { //empty list
104                 reginfo_event_list->head = reginfo_event_list->tail = event;
105         } else {
106                 reginfo_event_list->tail->next = event;
107                 reginfo_event_list->tail = event;
108         }
109         sem_release(reginfo_event_list->empty);
110         lock_release(reginfo_event_list->lock);
111 }
112
113 reginfo_event_t* pop_reginfo_event()
114 {
115         reginfo_event_t *ev;
116
117         lock_get(reginfo_event_list->lock);
118         while (reginfo_event_list->head == 0) {
119                 lock_release(reginfo_event_list->lock);
120                 sem_get(reginfo_event_list->empty);
121                 lock_get(reginfo_event_list->lock);
122         }
123
124         ev = reginfo_event_list->head;
125         reginfo_event_list->head = ev->next;
126
127         if (ev == reginfo_event_list->tail) { //list now empty
128                 reginfo_event_list->tail = 0;
129         }
130         ev->next = 0; //make sure whoever gets this cant access our list
131         lock_release(reginfo_event_list->lock);
132
133         return ev;
134 }
135
136 void free_reginfo_event(reginfo_event_t* ev)
137 {
138         if (ev) {
139                 LM_DBG("Freeing reginfo event structure\n");
140                 shm_free(ev);
141         }
142 }
143
144 void reginfo_event_process()
145 {
146         reginfo_event_t *ev;
147         for (;;) {
148                         LM_DBG("POPPING REGINFO EVENT\n");
149                 ev = pop_reginfo_event();
150                 LM_DBG("PROCESSING REGINFO EVENT with event [%d]\n", ev->event);
151
152                 switch (ev->event) {
153                 case REG_EVENT_PUBLISH:
154                         LM_DBG("Sending out-of-band publish\n");
155                         break;
156                 case REG_EVENT_SUBSCRIBE:
157                         LM_DBG("Sending out-of-band subscribe\n");
158                         break;
159                 default:
160                         LM_ERR("Unknown REG event.....ignoring\n");
161                         break;
162                 }
163                 free_reginfo_event(ev);
164         }
165 }
166
167
168