1 /*
2 belle-sip - SIP (RFC3261) library.
3 Copyright (C) 2010 Belledonne Communications SARL
4
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17 */
18 #ifndef belle_utils_h
19 #define belle_utils_h
20
21 #include <stdlib.h>
22 #include <string.h>
23 #include <stdio.h>
24 #include <sys/types.h>
25 #include <errno.h>
26 #include <netinet/in.h>
27
28 /* include all public headers*/
29 #include "belle-sip/belle-sip.h"
30 #include "bctoolbox/map.h"
31
32 #include "port.h"
33 #include <bctoolbox/port.h>
34 #include <bctoolbox/vconnect.h>
35
36 #ifdef HAVE_CONFIG_H
37
38 #ifdef PACKAGE
39 #undef PACKAGE
40 #endif
41 #ifdef PACKAGE_BUGREPORT
42 #undef PACKAGE_BUGREPORT
43 #endif
44 #ifdef PACKAGE_NAME
45 #undef PACKAGE_NAME
46 #endif
47 #ifdef PACKAGE_STRING
48 #undef PACKAGE_STRING
49 #endif
50 #ifdef PACKAGE_TARNAME
51 #undef PACKAGE_TARNAME
52 #endif
53 #ifdef VERSION
54 #undef VERSION
55 #endif
56 #ifdef PACKAGE_VERSION
57 #undef PACKAGE_VERSION
58 #endif
59
60 #include "config.h"
61
62 #else
63
64 #ifndef PACKAGE_VERSION
65 #error "PACKAGE_VERSION must be defined and equal to the VERSION file included in the belle-sip repository"
66 #endif
67
68 #endif
69
70
71 /*etc*/
72
73 #define BELLE_SIP_INTERFACE_GET_METHODS(obj,interface) \
74 ((BELLE_SIP_INTERFACE_METHODS_TYPE(interface)*)belle_sip_object_get_interface_methods((belle_sip_object_t*)obj,BELLE_SIP_INTERFACE_ID(interface)))
75
76 #define __BELLE_SIP_INVOKE_LISTENER_BEGIN(list,interface_name,method) \
77 if (list!=NULL) {\
78 belle_sip_list_t *__copy=belle_sip_list_copy_with_data((list), (void* (*)(void*))belle_sip_object_ref);\
79 const belle_sip_list_t *__elem=__copy;\
80 do{\
81 void *__method;\
82 interface_name *__obj=(interface_name*)__elem->data;\
83 __method=BELLE_SIP_INTERFACE_GET_METHODS(__obj,interface_name)->method;\
84 if (__method) BELLE_SIP_INTERFACE_GET_METHODS(__obj,interface_name)->
85
86 #define __BELLE_SIP_INVOKE_LISTENER_REVERSE_BEGIN(list,interface_name,method) \
87 if (list!=NULL) {\
88 belle_sip_list_t *__copy=belle_sip_list_copy_reverse_with_data((list), (void* (*)(void*))belle_sip_object_ref);\
89 const belle_sip_list_t *__elem=__copy;\
90 do{\
91 void *__method;\
92 interface_name *__obj=(interface_name*)__elem->data;\
93 __method=BELLE_SIP_INTERFACE_GET_METHODS(__obj,interface_name)->method;\
94 if (__method) BELLE_SIP_INTERFACE_GET_METHODS(__obj,interface_name)->
95
96 #define __BELLE_SIP_INVOKE_LISTENER_END \
97 __elem=__elem->next;\
98 }while(__elem!=NULL);\
99 belle_sip_list_free_with_data(__copy,belle_sip_object_unref);\
100 }
101
102 #define BELLE_SIP_INVOKE_LISTENERS_VOID(list,interface_name,method) \
103 __BELLE_SIP_INVOKE_LISTENER_BEGIN(list,interface_name,method)\
104 method(__obj);\
105 __BELLE_SIP_INVOKE_LISTENER_END
106
107 #define BELLE_SIP_INVOKE_LISTENERS_ARG(list,interface_name,method,arg) \
108 __BELLE_SIP_INVOKE_LISTENER_BEGIN(list,interface_name,method)\
109 method(__obj,arg);\
110 __BELLE_SIP_INVOKE_LISTENER_END
111
112 #define BELLE_SIP_INVOKE_LISTENERS_ARG1_ARG2(list,interface_name,method,arg1,arg2) \
113 __BELLE_SIP_INVOKE_LISTENER_BEGIN(list,interface_name,method)\
114 method(__obj,arg1,arg2);\
115 __BELLE_SIP_INVOKE_LISTENER_END
116
117 #define BELLE_SIP_INVOKE_LISTENERS_REVERSE_ARG1_ARG2(list,interface_name,method,arg1,arg2) \
118 __BELLE_SIP_INVOKE_LISTENER_REVERSE_BEGIN(list,interface_name,method)\
119 method(__obj,arg1,arg2);\
120 __BELLE_SIP_INVOKE_LISTENER_END
121
122 #define BELLE_SIP_INVOKE_LISTENERS_ARG1_ARG2_ARG3(list,interface_name,method,arg1,arg2,arg3) \
123 __BELLE_SIP_INVOKE_LISTENER_BEGIN(list,interface_name)\
124 method(__obj,arg1,arg2,arg3);\
125 __BELLE_SIP_INVOKE_LISTENER_END
126
127 #define BELLE_SIP_INVOKE_LISTENER_ARG(listener,interface_name,method,arg) \
128 ((BELLE_SIP_INTERFACE_GET_METHODS((listener),interface_name)->method!=NULL) ? \
129 BELLE_SIP_INTERFACE_GET_METHODS((listener),interface_name)->method(listener,(arg)) : 0 )
130
131 typedef struct weak_ref{
132 struct weak_ref *next;
133 belle_sip_object_destroy_notify_t notify;
134 void *userpointer;
135 }weak_ref_t;
136
137
138 void *belle_sip_object_get_interface_methods(belle_sip_object_t *obj, belle_sip_interface_id_t ifid);
139 /*used internally by unref()*/
140 void belle_sip_object_delete(void *obj);
141 void belle_sip_object_pool_add(belle_sip_object_pool_t *pool, belle_sip_object_t *obj);
142 void belle_sip_object_pool_remove(belle_sip_object_pool_t *pool, belle_sip_object_t *obj);
143
144 #define belle_sip_object_init(obj) /*nothing*/
145
146
147 /*list of all vptrs (classes) used in belle-sip*/
148 BELLE_SIP_DECLARE_VPTR(belle_sip_stack_t);
149 BELLE_SIP_DECLARE_VPTR(belle_sip_datagram_listening_point_t);
150 BELLE_SIP_DECLARE_VPTR(belle_sip_provider_t);
151 BELLE_SIP_DECLARE_VPTR(belle_sip_main_loop_t);
152 BELLE_SIP_DECLARE_VPTR(belle_sip_source_t);
153 BELLE_SIP_DECLARE_VPTR(belle_sip_dialog_t);
154 BELLE_SIP_DECLARE_VPTR(belle_sip_header_address_t);
155 BELLE_SIP_DECLARE_VPTR(belle_sip_header_contact_t);
156 BELLE_SIP_DECLARE_VPTR(belle_sip_header_from_t);
157 BELLE_SIP_DECLARE_VPTR(belle_sip_header_to_t);
158 BELLE_SIP_DECLARE_VPTR(belle_sip_header_via_t);
159 BELLE_SIP_DECLARE_VPTR(belle_sip_header_diversion_t);
160 BELLE_SIP_DECLARE_VPTR(belle_sip_uri_t);
161 BELLE_SIP_DECLARE_VPTR(belle_sip_message_t);
162 BELLE_SIP_DECLARE_VPTR(belle_sip_request_t);
163 BELLE_SIP_DECLARE_VPTR(belle_sip_response_t);
164 BELLE_SIP_DECLARE_VPTR(belle_sip_parameters_t);
165 BELLE_SIP_DECLARE_VPTR(belle_sip_header_call_id_t);
166 BELLE_SIP_DECLARE_VPTR(belle_sip_header_cseq_t);
167 BELLE_SIP_DECLARE_VPTR(belle_sip_header_content_type_t);
168 BELLE_SIP_DECLARE_VPTR(belle_sip_header_route_t);
169 BELLE_SIP_DECLARE_VPTR(belle_sip_header_record_route_t);
170 BELLE_SIP_DECLARE_VPTR(belle_sip_header_user_agent_t);
171 BELLE_SIP_DECLARE_VPTR(belle_sip_header_content_length_t);
172 BELLE_SIP_DECLARE_VPTR(belle_sip_header_t);
173 BELLE_SIP_DECLARE_VPTR(belle_sip_header_extension_t);
174 BELLE_SIP_DECLARE_VPTR(belle_sip_header_authorization_t);
175 BELLE_SIP_DECLARE_VPTR(belle_sip_header_www_authenticate_t);
176 BELLE_SIP_DECLARE_VPTR(belle_sip_header_proxy_authenticate_t);
177 BELLE_SIP_DECLARE_VPTR(belle_sip_header_proxy_authorization_t);
178 BELLE_SIP_DECLARE_VPTR(belle_sip_header_max_forwards_t);
179 BELLE_SIP_DECLARE_VPTR(belle_sip_header_expires_t);
180 BELLE_SIP_DECLARE_VPTR(belle_sip_header_allow_t);
181 BELLE_SIP_DECLARE_VPTR(belle_sdp_attribute_t);
182 BELLE_SIP_DECLARE_VPTR(belle_sdp_bandwidth_t);
183 BELLE_SIP_DECLARE_VPTR(belle_sdp_connection_t);
184 BELLE_SIP_DECLARE_VPTR(belle_sdp_email_t);
185 BELLE_SIP_DECLARE_VPTR(belle_sdp_info_t);
186 BELLE_SIP_DECLARE_VPTR(belle_sdp_key_t);
187 BELLE_SIP_DECLARE_VPTR(belle_sdp_media_t);
188 BELLE_SIP_DECLARE_VPTR(belle_sdp_media_description_t);
189 BELLE_SIP_DECLARE_VPTR(belle_sdp_origin_t);
190 BELLE_SIP_DECLARE_VPTR(belle_sdp_phone_t);
191 BELLE_SIP_DECLARE_VPTR(belle_sdp_raw_attribute_t);
192 BELLE_SIP_DECLARE_VPTR(belle_sdp_repeate_time_t);
193 BELLE_SIP_DECLARE_VPTR(belle_sdp_rtcp_fb_attribute_t);
194 BELLE_SIP_DECLARE_VPTR(belle_sdp_rtcp_xr_attribute_t);
195 BELLE_SIP_DECLARE_VPTR(belle_sdp_session_description_t);
196 BELLE_SIP_DECLARE_VPTR(belle_sdp_session_name_t);
197 BELLE_SIP_DECLARE_VPTR(belle_sdp_time_t);
198 BELLE_SIP_DECLARE_VPTR(belle_sdp_time_description_t);
199 BELLE_SIP_DECLARE_VPTR(belle_sdp_uri_t);
200 BELLE_SIP_DECLARE_VPTR(belle_sdp_version_t);
201 BELLE_SIP_DECLARE_VPTR(belle_sdp_base_description_t);
202 BELLE_SIP_DECLARE_VPTR(belle_sdp_mime_parameter_t);
203 BELLE_SIP_DECLARE_VPTR(belle_sip_refresher_t);
204 BELLE_SIP_DECLARE_VPTR(belle_sip_header_subscription_state_t);
205 BELLE_SIP_DECLARE_VPTR(belle_sip_header_service_route_t);
206 BELLE_SIP_DECLARE_VPTR(belle_sip_header_refer_to_t);
207 BELLE_SIP_DECLARE_VPTR(belle_sip_header_referred_by_t);
208 BELLE_SIP_DECLARE_VPTR(belle_sip_header_replaces_t);
209 BELLE_SIP_DECLARE_VPTR(belle_sip_header_date_t);
210 BELLE_SIP_DECLARE_VPTR(belle_sip_hop_t);
211 BELLE_SIP_DECLARE_VPTR(belle_sip_object_pool_t);
212 BELLE_SIP_DECLARE_VPTR(belle_sip_header_p_preferred_identity_t);
213 BELLE_SIP_DECLARE_VPTR(belle_sip_header_privacy_t);
214 BELLE_SIP_DECLARE_VPTR(belle_sip_certificates_chain_t);
215 BELLE_SIP_DECLARE_VPTR(belle_sip_signing_key_t);
216 BELLE_SIP_DECLARE_VPTR(belle_sip_dns_srv_t);
217 BELLE_SIP_DECLARE_VPTR(belle_sip_dict_t)
218 BELLE_SIP_DECLARE_VPTR(belle_http_provider_t);
219 BELLE_SIP_DECLARE_VPTR(belle_http_channel_context_t);
220 BELLE_SIP_DECLARE_VPTR(belle_http_request_t);
221 BELLE_SIP_DECLARE_VPTR(belle_http_response_t);
222 BELLE_SIP_DECLARE_VPTR(belle_generic_uri_t);
223 BELLE_SIP_DECLARE_VPTR(belle_http_callbacks_t);
224 BELLE_SIP_DECLARE_VPTR(belle_tls_crypto_config_t);
225 BELLE_SIP_DECLARE_VPTR(belle_http_header_authorization_t);
226 BELLE_SIP_DECLARE_VPTR(belle_sip_header_event_t);
227 BELLE_SIP_DECLARE_VPTR(belle_sip_header_supported_t);
228 BELLE_SIP_DECLARE_VPTR(belle_sip_header_content_disposition_t);
229 BELLE_SIP_DECLARE_VPTR(belle_sip_header_accept_t);
230 BELLE_SIP_DECLARE_VPTR(belle_sip_header_reason_t);
231 BELLE_SIP_DECLARE_VPTR(belle_sip_header_authentication_info_t);
232
233
234 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_resolver_context_t,belle_sip_source_t)
235 void (*cancel)(belle_sip_resolver_context_t *);
236 void (*notify)(belle_sip_resolver_context_t *);
237 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
238
239 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_simple_resolver_context_t,belle_sip_resolver_context_t)
240 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
241
242 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_combined_resolver_context_t,belle_sip_resolver_context_t)
243 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
244
245 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_dual_resolver_context_t,belle_sip_resolver_context_t)
246 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
247
248 void belle_sip_resolver_context_notify(belle_sip_resolver_context_t *ctx);
249
250 struct belle_sip_source{
251 belle_sip_object_t base;
252 belle_sip_list_t node;
253 unsigned long id;
254 belle_sip_fd_t fd;
255 unsigned short events,revents;
256 #ifdef _WIN32
257 long armed_events;
258 unsigned short pad;
259 #endif
260 int timeout;
261 void *data;
262 uint64_t expire_ms;
263 int index; /* index in pollfd table */
264 belle_sip_source_func_t notify;
265 belle_sip_source_remove_callback_t on_remove;
266 belle_sip_socket_t sock;
267 unsigned char cancelled;
268 unsigned char expired;
269 unsigned char oneshot;
270 unsigned char notify_required; /*for testing purpose, use to ask for being scheduled*/
271 bctbx_iterator_t *it; /*for fast removal*/
272 belle_sip_main_loop_t *ml;
273 };
274
275 void belle_sip_socket_source_init(belle_sip_source_t *s, belle_sip_source_func_t func, void *data, belle_sip_socket_t fd, unsigned int events, unsigned int timeout_value_ms);
276 void belle_sip_fd_source_init(belle_sip_source_t *s, belle_sip_source_func_t func, void *data, belle_sip_fd_t fd, unsigned int events, unsigned int timeout_value_ms);
277 belle_sip_source_t * belle_sip_fd_source_new(belle_sip_source_func_t func, void *data, belle_sip_fd_t fd, unsigned int events, unsigned int timeout_value_ms);
278 void belle_sip_source_uninit(belle_sip_source_t *s);
279 void belle_sip_source_set_notify(belle_sip_source_t *s, belle_sip_source_func_t func);
280
281
282
283 /* include private headers */
284 #include "channel.h"
285
286
287
288
289 #define belle_sip_new(type) (type*)belle_sip_malloc(sizeof(type))
290 #define belle_sip_new0(type) (type*)belle_sip_malloc0(sizeof(type))
291
292
293 #define belle_sip_list_next(elem) ((elem)->next)
294
295
296 /* dictionary */
297 struct belle_sip_dict {
298 belle_sip_object_t base;
299 };
300
301
302 #undef MIN
303 #define MIN(a,b) ((a)>(b) ? (b) : (a))
304 #undef MAX
305 #define MAX(a,b) ((a)>(b) ? (a) : (b))
306
307
308 #define belle_sip_concat bctbx_concat
309
310
311 /*parameters accessors*/
312 #define GET_SET_STRING(object_type,attribute) \
313 const char* object_type##_get_##attribute (const object_type##_t* obj) {\
314 return obj->attribute;\
315 }\
316 void object_type##_set_##attribute (object_type##_t* obj,const char* value) {\
317 const char* previous_value = obj->attribute; /*preserve if same value re-asigned*/ \
318 if (value) {\
319 obj->attribute=belle_sip_strdup(value); \
320 } else obj->attribute=NULL;\
321 if (previous_value != NULL) belle_sip_free((void*)previous_value);\
322 }
323 /*#define GET_SET_STRING_PARAM_NULL_ALLOWED(object_type,attribute) \
324 GET_STRING_PARAM2(object_type,attribute,attribute) \
325 void object_type##_set_##func_name (object_type##_t* obj,const char* value) {\
326 belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS(obj),#attribute,value);\
327 }
328 */
329 #define GET_SET_STRING_PARAM(object_type,attribute) GET_SET_STRING_PARAM2(object_type,attribute,attribute)
330 #define GET_SET_STRING_PARAM2(object_type,attribute,func_name) \
331 GET_STRING_PARAM2(object_type,attribute,func_name) \
332 void object_type##_set_##func_name (object_type##_t* obj,const char* value) {\
333 if (belle_sip_parameters_has_parameter(BELLE_SIP_PARAMETERS(obj),#attribute) && !value) {\
334 belle_sip_parameters_remove_parameter(BELLE_SIP_PARAMETERS(obj),#attribute); \
335 } else \
336 belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS(obj),#attribute,value);\
337 }
338
339 #define GET_STRING_PARAM2(object_type,attribute,func_name) \
340 const char* object_type##_get_##func_name (const object_type##_t* obj) {\
341 const char* l_value = belle_sip_parameters_get_parameter(BELLE_SIP_PARAMETERS(obj),#attribute);\
342 if (l_value == NULL) { \
343 /*belle_sip_warning("cannot find parameters [%s]",#attribute);*/\
344 return NULL;\
345 }\
346 return l_value;\
347 }
348
349 #define DESTROY_STRING(object,attribute) if (object->attribute) belle_sip_free((void*)object->attribute);
350
351 #define CLONE_STRING_GENERIC(object_type_src,object_type_dest,attribute,dest,src) \
352 if ( object_type_src##_get_##attribute (src)) {\
353 object_type_dest##_set_##attribute(dest,object_type_src##_get_##attribute(src));\
354 }
355
356 #define CLONE_STRING(object_type,attribute,dest,src) CLONE_STRING_GENERIC(object_type,object_type,attribute,dest,src)
357
358 #define GET_SET_INT(object_type,attribute,type) GET_SET_INT_PRIVATE(object_type,attribute,type,)
359
360 #define GET_SET_INT_PRIVATE(object_type,attribute,type,set_prefix) \
361 type object_type##_get_##attribute (const object_type##_t* obj) {\
362 return obj->attribute;\
363 }\
364 void set_prefix##object_type##_set_##attribute (object_type##_t* obj,type value) {\
365 obj->attribute=value;\
366 }
367 #define GET_SET_INT_PARAM(object_type,attribute,type) GET_SET_INT_PARAM_PRIVATE(object_type,attribute,type,)
368 #define GET_SET_INT_PARAM2(object_type,attribute,type,func_name) GET_SET_INT_PARAM_PRIVATE2(object_type,attribute,type,,func_name)
369
370 #define ATO_(type,value) ATO_##type(value)
371 #define ATO_int(value) atoi(value)
372 #define ATO_float(value) (float)strtod(value,NULL)
373 #define FORMAT_(type) FORMAT_##type
374 #define FORMAT_int "%i"
375 #define FORMAT_float "%f"
376
377 #define GET_SET_INT_PARAM_PRIVATE(object_type,attribute,type,set_prefix) GET_SET_INT_PARAM_PRIVATE2(object_type,attribute,type,set_prefix,attribute)
378 #define GET_SET_INT_PARAM_PRIVATE2(object_type,attribute,type,set_prefix,func_name) \
379 type object_type##_get_##func_name (const object_type##_t* obj) {\
380 const char* l_value = belle_sip_parameters_get_parameter(BELLE_SIP_PARAMETERS(obj),#attribute);\
381 if (l_value == NULL) { \
382 /*belle_sip_error("cannot find parameters [%s]",#attribute);*/\
383 return -1;\
384 }\
385 return ATO_(type,l_value);\
386 }\
387 void set_prefix##object_type##_set_##func_name (object_type##_t* obj,type value) {\
388 char l_str_value[16];\
389 if (value == -1) { \
390 belle_sip_parameters_remove_parameter(BELLE_SIP_PARAMETERS(obj),#attribute);\
391 return;\
392 }\
393 snprintf(l_str_value,16,FORMAT_(type),value);\
394 belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS(obj),#attribute,(const char*)l_str_value);\
395 }
396
397 #define GET_SET_BOOL(object_type,attribute,getter) \
398 unsigned int object_type##_##getter##_##attribute (const object_type##_t* obj) {\
399 return obj->attribute;\
400 }\
401 void object_type##_set_##attribute (object_type##_t* obj,unsigned int value) {\
402 obj->attribute=value;\
403 }
404 #define GET_SET_BOOL_PARAM2(object_type,attribute,getter,func_name) \
405 unsigned int object_type##_##getter##_##func_name (const object_type##_t* obj) {\
406 return belle_sip_parameters_has_parameter(BELLE_SIP_PARAMETERS(obj),#attribute);\
407 }\
408 void object_type##_set_##func_name (object_type##_t* obj,unsigned int value) {\
409 belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS(obj),#attribute,NULL);\
410 }
411
412 #ifdef HAVE_ANTLR_STRING_STREAM_NEW
413 #define ANTLR_STREAM_NEW(object_type, value,length) \
414 antlr3StringStreamNew((pANTLR3_UINT8)value,ANTLR3_ENC_8BIT,(ANTLR3_UINT32)length,(pANTLR3_UINT8)#object_type)
415 #else
416 #define ANTLR_STREAM_NEW(object_type, value, length) \
417 antlr3NewAsciiStringCopyStream((pANTLR3_UINT8)value,(ANTLR3_UINT32)length,NULL)
418 #endif /*HAVE_ANTLR_STRING_STREAM_NEW*/
419
420
421 #define BELLE_PARSE(parser_name, object_type_prefix, object_type) \
422 object_type_prefix##object_type##_t* object_type_prefix##object_type##_parse (const char* value) { \
423 pANTLR3_INPUT_STREAM input; \
424 pbelle_sip_messageLexer lex; \
425 pANTLR3_COMMON_TOKEN_STREAM tokens; \
426 p##parser_name parser; \
427 object_type_prefix##object_type##_t* l_parsed_object; \
428 input = ANTLR_STREAM_NEW(object_type,value,strlen(value));\
429 lex = belle_sip_messageLexerNew (input);\
430 tokens = antlr3CommonTokenStreamSourceNew (ANTLR3_SIZE_HINT, TOKENSOURCE(lex));\
431 parser = parser_name##New (tokens);\
432 l_parsed_object = parser->object_type(parser);\
433 parser ->free(parser);\
434 tokens ->free(tokens);\
435 lex ->free(lex);\
436 input ->close(input);\
437 if (l_parsed_object == NULL) belle_sip_error(#object_type" parser error for [%s]",value);\
438 return l_parsed_object;\
439 }
440 #define BELLE_SIP_PARSE(object_type) BELLE_PARSE(belle_sip_messageParser,belle_sip_,object_type)
441
442 #define BELLE_NEW(object_type,super_type) \
443 BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(object_type##_t); \
444 BELLE_SIP_INSTANCIATE_VPTR( object_type##_t\
445 , super_type##_t\
446 , object_type##_destroy\
447 , object_type##_clone\
448 , object_type##_marshal, TRUE); \
449 object_type##_t* object_type##_new () { \
450 object_type##_t* l_object = belle_sip_object_new(object_type##_t);\
451 super_type##_init((super_type##_t*)l_object); \
452 object_type##_init((object_type##_t*) l_object); \
453 return l_object;\
454 }
455
456 #define BELLE_SIP_NEW(object_type,super_type) BELLE_NEW (belle_sip_##object_type, belle_sip_##super_type)
457
458 #define BELLE_SIP_NEW_HEADER(object_type,super_type,name) BELLE_SIP_NEW_HEADER_INIT(object_type,super_type,name,header)
459 #define BELLE_SIP_NEW_HEADER_INIT(object_type,super_type,name,init_type) \
460 BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_##object_type##_t); \
461 BELLE_SIP_INSTANCIATE_VPTR( belle_sip_##object_type##_t\
462 , belle_sip_##super_type##_t\
463 , belle_sip_##object_type##_destroy\
464 , belle_sip_##object_type##_clone\
465 , belle_sip_##object_type##_marshal, TRUE); \
466 belle_sip_##object_type##_t* belle_sip_##object_type##_new () { \
467 belle_sip_##object_type##_t* l_object = belle_sip_object_new(belle_sip_##object_type##_t);\
468 belle_sip_##super_type##_init((belle_sip_##super_type##_t*)l_object); \
469 belle_sip_##init_type##_init((belle_sip_##init_type##_t*) l_object); \
470 if (name) belle_sip_header_set_name(BELLE_SIP_HEADER(l_object),name);\
471 return l_object;\
472 }
473 struct belle_sip_param_pair {
474 int ref;
475 char* name;
476 char* value;
477 } ;
478
479 void belle_sip_param_pair_destroy(belle_sip_param_pair_t* pair) ;
480
481 int belle_sip_param_pair_comp_func(const belle_sip_param_pair_t *a, const char*b) ;
482 int belle_sip_param_pair_case_comp_func(const belle_sip_param_pair_t *a, const char*b) ;
483
484 belle_sip_param_pair_t* belle_sip_param_pair_ref(belle_sip_param_pair_t* obj);
485
486 void belle_sip_param_pair_unref(belle_sip_param_pair_t* obj);
487
488
489
490
491 /*calss header*/
492 struct _belle_sip_header {
493 belle_sip_object_t base;
494 belle_sip_header_t* next;
495 char *name;
496 char *unparsed_value;
497 };
498
499
500 void belle_sip_response_fill_for_dialog(belle_sip_response_t *obj, belle_sip_request_t *req);
501 void belle_sip_util_copy_headers(belle_sip_message_t *orig, belle_sip_message_t *dest, const char*header, int multiple);
502
503 void belle_sip_header_init(belle_sip_header_t* obj);
504 /*class parameters*/
505 struct _belle_sip_parameters {
506 belle_sip_header_t base;
507 belle_sip_list_t* param_list;
508 belle_sip_list_t* paramnames_list;
509 };
510
511 void belle_sip_parameters_init(belle_sip_parameters_t *obj);
512
513 /*
514 * Listening points
515 */
516
517 #include "listeningpoint_internal.h"
518
519
520 struct belle_sip_hop{
521 belle_sip_object_t base;
522 char *cname;
523 char *host;
524 char *transport;
525 int port;
526 };
527
528
529 /*
530 belle_sip_stack_t
531 */
532 struct belle_sip_stack{
533 belle_sip_object_t base;
534 belle_sip_main_loop_t *ml;
535 belle_sip_timer_config_t timer_config;
536 int transport_timeout;
537 int inactive_transport_timeout;
538 int dns_timeout;
539 int tx_delay; /*used to simulate network transmission delay, for tests*/
540 int send_error; /* used to simulate network error. if <0, channel_send will return this value*/
541 int resolver_tx_delay; /*used to simulate network transmission delay, for tests*/
542 int resolver_send_error; /* used to simulate network error*/
543 int dscp;
544 char *dns_user_hosts_file; /* used to load additional hosts file for tests */
545 char *dns_resolv_conf; /*used to load custom resolv.conf, for tests*/
546 belle_sip_list_t *dns_servers; /*used when dns servers are supplied by app layer*/
547 /*http proxy stuff to be used by both http and sip provider*/
548 char *http_proxy_host;
549 int http_proxy_port;
550 char *http_proxy_username; /*for future use*/
551 char *http_proxy_passwd; /*for future use*/
552
553 unsigned char dns_srv_enabled;
554 unsigned char dns_search_enabled;
555 };
556
557 BELLESIP_EXPORT belle_sip_hop_t* belle_sip_hop_new(const char* transport, const char *cname, const char* host,int port);
558 BELLESIP_EXPORT belle_sip_hop_t* belle_sip_hop_new_from_uri(const belle_sip_uri_t *uri);
559 BELLESIP_EXPORT belle_sip_hop_t* belle_sip_hop_new_from_generic_uri(const belle_generic_uri_t *uri);
560
561 BELLESIP_EXPORT belle_sip_hop_t * belle_sip_stack_get_next_hop(belle_sip_stack_t *stack, belle_sip_request_t *req);
562
563 /*
564 belle_sip_provider_t
565 */
566
567 struct belle_sip_provider{
568 belle_sip_object_t base;
569 belle_sip_stack_t *stack;
570 belle_sip_list_t *lps; /*listening points*/
571 belle_sip_list_t *listeners;
572 belle_sip_list_t *internal_listeners; /*for transaction internaly managed by belle-sip. I.E by refreshers*/
573 belle_sip_list_t *client_transactions;
574 belle_sip_list_t *server_transactions;
575 belle_sip_list_t *dialogs;
576 belle_sip_list_t *auth_contexts;
577 unsigned char rport_enabled; /*0 if rport should not be set in via header*/
578 unsigned char nat_helper;
579 unsigned char unconditional_answer_enabled;
580 unsigned short unconditional_answer;
581 };
582
583 BELLESIP_EXPORT belle_sip_provider_t *belle_sip_provider_new(belle_sip_stack_t *s, belle_sip_listening_point_t *lp);
584 void belle_sip_provider_add_client_transaction(belle_sip_provider_t *prov, belle_sip_client_transaction_t *t);
585 belle_sip_client_transaction_t *belle_sip_provider_find_matching_client_transaction(belle_sip_provider_t *prov, belle_sip_response_t *resp);
586 void belle_sip_provider_remove_client_transaction(belle_sip_provider_t *prov, belle_sip_client_transaction_t *t);
587 void belle_sip_provider_add_server_transaction(belle_sip_provider_t *prov, belle_sip_server_transaction_t *t);
588 BELLESIP_EXPORT belle_sip_server_transaction_t * belle_sip_provider_find_matching_server_transaction(belle_sip_provider_t *prov,belle_sip_request_t *req);
589 void belle_sip_provider_remove_server_transaction(belle_sip_provider_t *prov, belle_sip_server_transaction_t *t);
590 void belle_sip_provider_set_transaction_terminated(belle_sip_provider_t *p, belle_sip_transaction_t *t);
591 void *belle_sip_transaction_get_application_data_internal(const belle_sip_transaction_t *t);
592 belle_sip_channel_t * belle_sip_provider_get_channel(belle_sip_provider_t *p, const belle_sip_hop_t *hop);
593 void belle_sip_provider_add_dialog(belle_sip_provider_t *prov, belle_sip_dialog_t *dialog);
594 void belle_sip_provider_remove_dialog(belle_sip_provider_t *prov, belle_sip_dialog_t *dialog);
595 void belle_sip_provider_release_channel(belle_sip_provider_t *p, belle_sip_channel_t *chan);
596 void belle_sip_provider_add_internal_sip_listener(belle_sip_provider_t *p, belle_sip_listener_t *l, int prepend);
597 void belle_sip_provider_remove_internal_sip_listener(belle_sip_provider_t *p, belle_sip_listener_t *l);
598 belle_sip_client_transaction_t * belle_sip_provider_find_matching_client_transaction_from_req(belle_sip_provider_t *prov, belle_sip_request_t *req);
599 belle_sip_dialog_t *belle_sip_provider_find_dialog_from_message(belle_sip_provider_t *prov, belle_sip_message_t *msg, int as_uas);
600 /*for testing purpose only:*/
601 BELLESIP_EXPORT void belle_sip_provider_dispatch_message(belle_sip_provider_t *prov, belle_sip_message_t *msg);
602
603 typedef struct listener_ctx{
604 belle_sip_listener_t *listener;
605 void *data;
606 }listener_ctx_t;
607
608 #define BELLE_SIP_PROVIDER_INVOKE_LISTENERS_FOR_TRANSACTION(t,callback,event) \
609 BELLE_SIP_PROVIDER_INVOKE_LISTENERS((t)->is_internal?(t)->provider->internal_listeners:(t)->provider->listeners,callback,event)
610
611 #define BELLE_SIP_PROVIDER_INVOKE_LISTENERS_FOR_DIALOG(d,callback,event) \
612 BELLE_SIP_PROVIDER_INVOKE_LISTENERS((d)->is_internal?(d)->provider->internal_listeners:(d)->provider->listeners,callback,event)
613
614 #define BELLE_SIP_PROVIDER_INVOKE_LISTENERS(listeners,callback,event) \
615 BELLE_SIP_INVOKE_LISTENERS_ARG((listeners),belle_sip_listener_t,callback,(event))
616
617 /*
618 * http provider
619 */
620 belle_http_provider_t *belle_http_provider_new(belle_sip_stack_t *s, const char *bind_ip);
621
622
623 /*
624 * SIP and http messages
625 **/
626 #define BELLESIP_MULTIPART_BOUNDARY "---------------------------14737809831466499882746641449"
627
628 void belle_sip_message_init(belle_sip_message_t *message);
629
630 struct _belle_sip_message {
631 belle_sip_object_t base;
632 belle_sip_list_t* header_list;
633 belle_sip_body_handler_t *body_handler;
634 };
635
636 struct _belle_sip_request {
637 belle_sip_message_t base;
638 char* method;
639 belle_sip_uri_t* uri;
640 belle_generic_uri_t *absolute_uri;
641 belle_sip_dialog_t *dialog;/*set if request was created by a dialog to avoid to search in dialog list*/
642 char *rfc2543_branch; /*computed 'branch' id in case we receive this request from an old RFC2543 stack*/
643 unsigned char dialog_queued;
644 };
645
646
647 /** HTTP request**/
648
649 struct belle_http_request{
650 belle_sip_message_t base;
651 belle_generic_uri_t *req_uri;
652 char* method;
653 belle_http_request_listener_t *listener;
654 belle_generic_uri_t *orig_uri;/*original uri before removing host and user/passwd*/
655 belle_http_response_t *response;
656 belle_sip_channel_t *channel;
657 int auth_attempt_count;
658 int background_task_id;
659 int cancelled;
660 };
661
662 void belle_http_request_set_listener(belle_http_request_t *req, belle_http_request_listener_t *l);
663 void belle_http_request_set_channel(belle_http_request_t *req, belle_sip_channel_t *chan);
664 void belle_http_request_set_response(belle_http_request_t *req, belle_http_response_t *resp);
665 /*
666 belle_sip_transaction_t
667 */
668
669 struct belle_sip_transaction{
670 belle_sip_object_t base;
671 belle_sip_provider_t *provider; /*the provider that created this transaction */
672 belle_sip_request_t *request;
673 belle_sip_response_t *last_response;
674 belle_sip_channel_t *channel;
675 belle_sip_dialog_t *dialog;
676 belle_sip_source_t *call_repair_timer;
677 char *branch_id;
678 belle_sip_transaction_state_t state;
679 void *appdata;
680 unsigned char is_internal;
681 unsigned char timed_out;
682 unsigned char sent_by_dialog_queue;
683 unsigned long bg_task_id;
684 };
685
686
687 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_transaction_t,belle_sip_object_t)
688 void (*on_terminate)(belle_sip_transaction_t *obj);
689 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
690
belle_sip_transaction_get_timer_config(belle_sip_transaction_t * obj)691 static BELLESIP_INLINE const belle_sip_timer_config_t * belle_sip_transaction_get_timer_config(belle_sip_transaction_t *obj){
692 return belle_sip_stack_get_timer_config(obj->provider->stack);
693 }
694
belle_sip_transaction_start_timer(belle_sip_transaction_t * obj,belle_sip_source_t * timer)695 static BELLESIP_INLINE void belle_sip_transaction_start_timer(belle_sip_transaction_t *obj, belle_sip_source_t *timer){
696 belle_sip_main_loop_add_source(obj->provider->stack->ml,timer);
697 }
698 /** */
belle_sip_transaction_stop_timer(belle_sip_transaction_t * obj,belle_sip_source_t * timer)699 static BELLESIP_INLINE void belle_sip_transaction_stop_timer(belle_sip_transaction_t *obj, belle_sip_source_t *timer){
700 belle_sip_main_loop_remove_source(obj->provider->stack->ml,timer);
701 }
702
703 int belle_sip_client_transaction_is_notify_matching_pending_subscribe(belle_sip_client_transaction_t *trans
704 , belle_sip_request_t *notify);
705
706 void belle_sip_transaction_notify_timeout(belle_sip_transaction_t *t);
707
708 void belle_sip_transaction_set_dialog(belle_sip_transaction_t *t, belle_sip_dialog_t *dialog);
709
710 void belle_sip_transaction_set_state(belle_sip_transaction_t *t, belle_sip_transaction_state_t state);
711
712 /*
713 *
714 *
715 * Client transaction
716 *
717 *
718 */
719
720 struct belle_sip_client_transaction{
721 belle_sip_transaction_t base;
722 belle_sip_uri_t* preset_route; /*use to store outbound proxy, will be helpful for refresher*/
723 belle_sip_hop_t* next_hop; /*use to send cancel request*/
724 };
725
726 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_client_transaction_t,belle_sip_transaction_t)
727 void (*send_request)(belle_sip_client_transaction_t *);
728 void (*on_response)(belle_sip_client_transaction_t *obj, belle_sip_response_t *resp);
729 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
730
731 void belle_sip_client_transaction_init(belle_sip_client_transaction_t *obj, belle_sip_provider_t *prov, belle_sip_request_t *req);
732 void belle_sip_client_transaction_add_response(belle_sip_client_transaction_t *t, belle_sip_response_t *resp);
733 void belle_sip_client_transaction_notify_response(belle_sip_client_transaction_t *t, belle_sip_response_t *resp);
734
735 struct belle_sip_ict{
736 belle_sip_client_transaction_t base;
737 belle_sip_source_t *timer_A;
738 belle_sip_source_t *timer_B;
739 belle_sip_source_t *timer_D;
740 belle_sip_source_t *timer_M;
741 belle_sip_request_t *ack;
742 };
743
744 typedef struct belle_sip_ict belle_sip_ict_t;
745
746 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_ict_t,belle_sip_client_transaction_t)
747 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
748
749 belle_sip_ict_t * belle_sip_ict_new(belle_sip_provider_t *prov, belle_sip_request_t *req);
750
751 struct belle_sip_nict{
752 belle_sip_client_transaction_t base;
753 belle_sip_source_t *timer_F;
754 belle_sip_source_t *timer_E;
755 belle_sip_source_t *timer_K;
756 };
757
758 typedef struct belle_sip_nict belle_sip_nict_t;
759
760 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_nict_t,belle_sip_client_transaction_t)
761 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
762
763 belle_sip_nict_t * belle_sip_nict_new(belle_sip_provider_t *prov, belle_sip_request_t *req);
764
765
766 /*
767 *
768 *
769 * Server transaction
770 *
771 *
772 */
773
774 struct belle_sip_server_transaction{
775 belle_sip_transaction_t base;
776 char to_tag[8];
777 };
778
779 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_server_transaction_t,belle_sip_transaction_t)
780 int (*send_new_response)(belle_sip_server_transaction_t *, belle_sip_response_t *resp);
781 void (*on_request_retransmission)(belle_sip_server_transaction_t *obj);
782 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
783
784 void belle_sip_server_transaction_init(belle_sip_server_transaction_t *t, belle_sip_provider_t *prov,belle_sip_request_t *req);
785 void belle_sip_server_transaction_on_request(belle_sip_server_transaction_t *t, belle_sip_request_t *req);
786
787 struct belle_sip_ist{
788 belle_sip_server_transaction_t base;
789 belle_sip_source_t *timer_G;
790 belle_sip_source_t *timer_H;
791 belle_sip_source_t *timer_I;
792 belle_sip_source_t *timer_L;
793 };
794
795 typedef struct belle_sip_ist belle_sip_ist_t;
796
797 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_ist_t,belle_sip_server_transaction_t)
798 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
799
800 belle_sip_ist_t * belle_sip_ist_new(belle_sip_provider_t *prov, belle_sip_request_t *req);
801 /* returns 0 if the ack should be notified to TU, or -1 otherwise*/
802 int belle_sip_ist_process_ack(belle_sip_ist_t *obj, belle_sip_message_t *ack);
803
804 struct belle_sip_nist{
805 belle_sip_server_transaction_t base;
806 belle_sip_source_t *timer_J;
807 };
808
809 typedef struct belle_sip_nist belle_sip_nist_t;
810
811 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_nist_t,belle_sip_server_transaction_t)
812 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
813
814 belle_sip_nist_t * belle_sip_nist_new(belle_sip_provider_t *prov, belle_sip_request_t *req);
815
816
817 typedef enum belle_sip_dialog_type{
818 BELLE_SIP_DIALOG_INVITE,
819 BELLE_SIP_DIALOG_SUBSCRIBE_NOTIFY
820 }belle_sip_dialog_type_t;
821 /*
822 * Dialogs
823 */
824 struct belle_sip_dialog{
825 belle_sip_object_t base;
826 void *appdata;
827 belle_sip_dialog_type_t type;
828 belle_sip_provider_t *provider;
829 belle_sip_request_t *last_out_invite;
830 belle_sip_request_t *last_out_ack; /*so that it can be retransmitted when needed*/
831 belle_sip_response_t *last_200Ok;
832 belle_sip_source_t *timer_200Ok;
833 belle_sip_source_t *timer_200Ok_end;
834 belle_sip_dialog_state_t state;
835 belle_sip_dialog_state_t previous_state;
836 belle_sip_header_call_id_t *call_id;
837 belle_sip_header_address_t *local_party;
838 belle_sip_header_address_t *remote_party;
839 belle_sip_list_t *route_set;
840 belle_sip_header_address_t *remote_target;
841 belle_sip_source_t *expiration_timer;
842 char *local_tag;
843 char *remote_tag;
844 unsigned int local_cseq;
845 unsigned int remote_cseq;
846 belle_sip_transaction_t* last_transaction;
847 belle_sip_header_privacy_t* privacy;
848 belle_sip_list_t *queued_ct;/* queued client transactions*/
849 unsigned int remote_invite_cseq; /*needed because multiple trans can be handled whithin invite transaction (I.E UPDATE, PRACK,etc*/
850 unsigned char is_server;
851 unsigned char is_secure;
852 unsigned char terminate_on_bye;
853 unsigned char needs_ack;
854 unsigned char is_expired;
855 unsigned char pending_trans_checking_enabled; /*use to disabled pending transaction check at request creation (testing)*/
856 unsigned char is_internal; /*Internal dialogs are those created by refreshers. */
857 };
858
859 belle_sip_dialog_t *belle_sip_dialog_new(belle_sip_transaction_t *t);
860 belle_sip_dialog_t * belle_sip_provider_create_dialog_internal(belle_sip_provider_t *prov, belle_sip_transaction_t *t,unsigned int check_last_resp);
861 int belle_sip_dialog_is_authorized_transaction(const belle_sip_dialog_t *dialog,const char* method) ;
862 /*returns 1 if message belongs to the dialog, 0 otherwise */
863 int belle_sip_dialog_is_null_dialog_with_matching_subscribe(belle_sip_dialog_t *obj, const char *call_id, const char *local_tag, belle_sip_request_t *notify);
864 int _belle_sip_dialog_match(belle_sip_dialog_t *obj, const char *call_id, const char *local_tag, const char *remote_tag);
865 int belle_sip_dialog_match(belle_sip_dialog_t *obj, belle_sip_message_t *msg, int as_uas);
866 int belle_sip_dialog_update(belle_sip_dialog_t *obj,belle_sip_transaction_t* transaction, int as_uas);
867 void belle_sip_dialog_check_ack_sent(belle_sip_dialog_t*obj);
868 int belle_sip_dialog_handle_ack(belle_sip_dialog_t *obj, belle_sip_request_t *ack);
869 void belle_sip_dialog_queue_client_transaction(belle_sip_dialog_t *dialog, belle_sip_client_transaction_t *tr);
870 void belle_sip_dialog_stop_200Ok_retrans(belle_sip_dialog_t *obj);
871
872
873 /*
874 belle_sip_response_t
875 */
876 belle_sip_hop_t* belle_sip_response_get_return_hop(belle_sip_response_t *msg);
877
878
879 /*********************************************************
880 * SDP
881 */
882 #define BELLE_SDP_PARSE(object_type) \
883 belle_sdp_##object_type##_t* belle_sdp_##object_type##_parse (const char* value) { \
884 pANTLR3_INPUT_STREAM input; \
885 pbelle_sdpLexer lex; \
886 pANTLR3_COMMON_TOKEN_STREAM tokens; \
887 pbelle_sdpParser parser; \
888 belle_sdp_##object_type##_t* l_parsed_object; \
889 input = ANTLR_STREAM_NEW(object_type, value,strlen(value));\
890 lex = belle_sdpLexerNew (input);\
891 tokens = antlr3CommonTokenStreamSourceNew (ANTLR3_SIZE_HINT, TOKENSOURCE(lex));\
892 parser = belle_sdpParserNew (tokens);\
893 l_parsed_object = parser->object_type(parser).ret;\
894 parser ->free(parser);\
895 tokens ->free(tokens);\
896 lex ->free(lex);\
897 input ->close(input);\
898 if (l_parsed_object == NULL) belle_sip_error(#object_type" parser error for [%s]",value);\
899 return l_parsed_object;\
900 }
901 #define BELLE_SDP_NEW(object_type,super_type) \
902 BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sdp_##object_type##_t); \
903 BELLE_SIP_INSTANCIATE_VPTR( belle_sdp_##object_type##_t\
904 , super_type##_t\
905 , belle_sdp_##object_type##_destroy\
906 , belle_sdp_##object_type##_clone\
907 , belle_sdp_##object_type##_marshal, TRUE); \
908 belle_sdp_##object_type##_t* belle_sdp_##object_type##_new () { \
909 belle_sdp_##object_type##_t* l_object = belle_sip_object_new(belle_sdp_##object_type##_t);\
910 super_type##_init((super_type##_t*)l_object); \
911 return l_object;\
912 }
913 #define BELLE_SDP_NEW_WITH_CTR(object_type,super_type) \
914 BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sdp_##object_type##_t); \
915 BELLE_SIP_INSTANCIATE_VPTR( belle_sdp_##object_type##_t\
916 , super_type##_t\
917 , belle_sdp_##object_type##_destroy\
918 , belle_sdp_##object_type##_clone\
919 , belle_sdp_##object_type##_marshal,TRUE); \
920 belle_sdp_##object_type##_t* belle_sdp_##object_type##_new () { \
921 belle_sdp_##object_type##_t* l_object = belle_sip_object_new(belle_sdp_##object_type##_t);\
922 super_type##_init((super_type##_t*)l_object); \
923 belle_sdp_##object_type##_init(l_object); \
924 return l_object;\
925 }
926
927
928
929 struct belle_sip_dialog_terminated_event{
930 belle_sip_provider_t *source;
931 belle_sip_dialog_t *dialog;
932 int is_expired;
933 };
934
935 struct belle_sip_io_error_event{
936 belle_sip_object_t *source; /*the object impacted by this error*/
937 const char *transport;
938 const char *host;
939 unsigned int port;
940 };
941
942 struct belle_sip_request_event{
943 belle_sip_object_t *source;
944 belle_sip_server_transaction_t *server_transaction;
945 belle_sip_dialog_t *dialog;
946 belle_sip_request_t *request;
947 };
948
949 struct belle_sip_response_event{
950 belle_sip_object_t *source;
951 belle_sip_client_transaction_t *client_transaction;
952 belle_sip_dialog_t *dialog;
953 belle_sip_response_t *response;
954 };
955
956 struct belle_sip_timeout_event{
957 belle_sip_object_t *source;
958 belle_sip_transaction_t *transaction;
959 int is_server_transaction;
960 };
961
962 struct belle_sip_transaction_terminated_event{
963 belle_sip_provider_t *source;
964 belle_sip_transaction_t *transaction;
965 int is_server_transaction;
966 };
967
968 struct belle_sip_auth_event {
969 belle_sip_object_t *source;
970 belle_sip_auth_mode_t mode;
971 char* username;
972 char* userid;
973 char* realm;
974 char* passwd;
975 char* ha1;
976 char* domain;
977 char* distinguished_name;
978 belle_sip_certificates_chain_t * cert;
979 belle_sip_signing_key_t* key;
980 };
981
982 belle_sip_auth_event_t* belle_sip_auth_event_create(belle_sip_object_t *source, const char* realm,const belle_sip_uri_t * from_uri);
983
984 void belle_sip_auth_event_set_distinguished_name(belle_sip_auth_event_t* event,const char* value);
985
986 /*
987 * refresher
988 * */
989 belle_sip_refresher_t* belle_sip_refresher_new(belle_sip_client_transaction_t* transaction);
990
991
992 /*
993 * returns a char, even if entry is escaped*/
994 size_t belle_sip_get_char (const char*a,char*out);
995 /*return an escaped string*/
996 BELLESIP_EXPORT char* belle_sip_uri_to_escaped_username(const char* buff) ;
997 BELLESIP_EXPORT char* belle_sip_uri_to_escaped_userpasswd(const char* buff) ;
998 BELLESIP_EXPORT char* belle_sip_uri_to_escaped_parameter(const char* buff) ;
999 BELLESIP_EXPORT char* belle_sip_uri_to_escaped_header(const char* buff) ;
1000
1001
1002 /*(uri RFC 2396)*/
1003
1004 BELLESIP_EXPORT char* belle_generic_uri_to_escaped_query(const char* buff);
1005 BELLESIP_EXPORT char* belle_generic_uri_to_escaped_path(const char* buff);
1006
1007 #define BELLE_SIP_SOCKET_TIMEOUT 30000
1008
1009 #define BELLE_SIP_BRANCH_ID_LENGTH 10
1010 /*Shall not be less than 32bit */
1011 #define BELLE_SIP_TAG_LENGTH 6
1012 #define BELLE_SIP_MAX_TO_STRING_SIZE 2048
1013
1014 void belle_sip_header_contact_set_unknown(belle_sip_header_contact_t *a, int value);
1015 void belle_sip_request_set_dialog(belle_sip_request_t *req, belle_sip_dialog_t *dialog);
1016 void belle_sip_request_set_rfc2543_branch(belle_sip_request_t *req, const char *rfc2543branch);
1017 void belle_sip_dialog_update_request(belle_sip_dialog_t *dialog, belle_sip_request_t *req);
1018
1019 belle_sip_error_code belle_sip_headers_marshal(belle_sip_message_t *message, char* buff, size_t buff_size, size_t *offset);
1020
1021 #define SET_OBJECT_PROPERTY(obj,property_name,new_value) \
1022 if (new_value) belle_sip_object_ref(new_value); \
1023 if (obj->property_name){ \
1024 belle_sip_object_unref(obj->property_name); \
1025 }\
1026 obj->property_name=new_value;
1027
1028 #include "parserutils.h"
1029
1030 /******************************
1031 *
1032 * private Extension header inherit from header
1033 *
1034 ******************************/
1035 typedef struct _belle_sip_header_extension belle_sip_header_extension_t;
1036
1037 belle_sip_header_extension_t* belle_sip_header_extension_new(void);
1038
1039 belle_sip_header_extension_t* belle_sip_header_extension_parse (const char* extension) ;
1040 belle_sip_header_extension_t* belle_sip_header_extension_create (const char* name,const char* value);
1041 BELLESIP_EXPORT const char* belle_sip_header_extension_get_value(const belle_sip_header_extension_t* extension);
1042 void belle_sip_header_extension_set_value(belle_sip_header_extension_t* extension,const char* value);
1043 #define BELLE_SIP_HEADER_EXTENSION(t) BELLE_SIP_CAST(t,belle_sip_header_extension_t)
1044
1045
1046 /****************
1047 * belle_sip_body_handler_t object
1048 ***************/
1049
1050
1051 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_body_handler_t,belle_sip_object_t)
1052 void (*begin_recv_transfer)(belle_sip_body_handler_t *obj);
1053 void (*begin_send_transfer)(belle_sip_body_handler_t *obj);
1054 void (*end_transfer)(belle_sip_body_handler_t *obj);
1055 void (*chunk_recv)(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, off_t offset, uint8_t *buf, size_t size);
1056 int (*chunk_send)(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, off_t offset, uint8_t *buf, size_t * size);
1057 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
1058
1059 void belle_sip_body_handler_begin_recv_transfer(belle_sip_body_handler_t *obj);
1060 void belle_sip_body_handler_begin_send_transfer(belle_sip_body_handler_t *obj);
1061 void belle_sip_body_handler_recv_chunk(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, uint8_t *buf, size_t size);
1062 int belle_sip_body_handler_send_chunk(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, uint8_t *buf, size_t *size);
1063 void belle_sip_body_handler_end_transfer(belle_sip_body_handler_t *obj);
1064
1065
1066 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_memory_body_handler_t,belle_sip_body_handler_t)
1067 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
1068
1069 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_user_body_handler_t,belle_sip_body_handler_t)
1070 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
1071
1072 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_file_body_handler_t,belle_sip_body_handler_t)
1073 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
1074
1075 BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_multipart_body_handler_t,belle_sip_body_handler_t)
1076 BELLE_SIP_DECLARE_CUSTOM_VPTR_END
1077
1078 void belle_sip_multipart_body_handler_progress_cb(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, void *user_data, size_t transfered, size_t expected_total);
1079
1080 /**
1081 * file manipulation
1082 */
1083 /**
1084 * Parse a directory and return all files in it.
1085 *
1086 * @param[in] path The directory to be parsed
1087 * @param[in] file_type if not NULL return only the file with the given extension, must include the '.', ex:".pem"
1088 * @return a belle_sip list containing all found file or NULL if no file were found or directory doesn't exist. List must be destroyed using belle_sip_list_free_with_data(<ret_list>, belle_sip_free)
1089 */
1090 belle_sip_list_t *belle_sip_parse_directory(const char *path, const char *file_type);
1091
1092 typedef struct authorization_context authorization_context_t;
1093 BELLESIP_EXPORT void belle_sip_authorization_destroy(authorization_context_t* object);
1094
1095
1096 #endif
1097