*>(this)),
std::mem_fn(&HybridObject<_CType, _CppType>::constUnref));
mSelf = sp;
if (!withTransfer){
sp->ref();
}
}else{
if (withTransfer){
belle_sip_fatal("This HybridObject already has shared_ptr<> instances pointing to it.");
}
}
return sp;
}
mutable std::weak_ptr<_CppType> mSelf;
};
}//end of namespace
extern "C" {
BELLE_SIP_DECLARE_VPTR(belle_sip_cpp_object_t);
}
#endif //belle_sip_object_plusplus_h
belle-sip-5.2.0+dfsg/include/belle-sip/object.h 0000664 0000000 0000000 00000056040 14346131365 0021242 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef belle_sip_object_h
#define belle_sip_object_h
#include "belle-sip/defs.h"
#include "belle-sip/utils.h"
#include "belle-sip/list.h"
/*
* typedefs, macros and functions for object definition and manipulation.
*/
#define BELLE_SIP_DEFAULT_BUFSIZE_HINT 0
#define BELLE_SIP_TYPE_ID(_type) _type##_id
typedef unsigned int belle_sip_type_id_t;
#define BELLE_SIP_DECLARE_TYPES_BEGIN(namezpace,unique_namespace_id) \
enum namezpace##type_ids{\
namezpace##type_id_first=unique_namespace_id,
#define BELLE_SIP_DECLARE_TYPES_END };
#define BELLE_SIP_OBJECT_VPTR_NAME(object_type) object_type##_vptr
#define BELLE_SIP_OBJECT_GET_VPTR_FUNC(object_type) object_type##_vptr_get
#define BELLE_SIP_OBJECT_VPTR_TYPE(object_type) object_type##_vptr_t
#define BELLE_SIP_DECLARE_VPTR(object_type) \
typedef belle_sip_object_vptr_t BELLE_SIP_OBJECT_VPTR_TYPE(object_type);\
BELLESIP_EXPORT BELLE_SIP_OBJECT_VPTR_TYPE(object_type) * BELLE_SIP_OBJECT_GET_VPTR_FUNC(object_type)(void);
#define BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(object_type, parent_type) \
typedef struct object_type##_vptr_struct BELLE_SIP_OBJECT_VPTR_TYPE(object_type);\
BELLESIP_EXPORT BELLE_SIP_OBJECT_VPTR_TYPE(object_type) * BELLE_SIP_OBJECT_GET_VPTR_FUNC(object_type)(void); \
struct object_type##_vptr_struct{\
BELLE_SIP_OBJECT_VPTR_TYPE(parent_type) base;
#define BELLE_SIP_DECLARE_VPTR_NO_EXPORT(object_type) \
typedef belle_sip_object_vptr_t BELLE_SIP_OBJECT_VPTR_TYPE(object_type);\
BELLE_SIP_OBJECT_VPTR_TYPE(object_type) * BELLE_SIP_OBJECT_GET_VPTR_FUNC(object_type)(void);
#define BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN_NO_EXPORT(object_type, parent_type) \
typedef struct object_type##_vptr_struct BELLE_SIP_OBJECT_VPTR_TYPE(object_type);\
BELLE_SIP_OBJECT_VPTR_TYPE(object_type) * BELLE_SIP_OBJECT_GET_VPTR_FUNC(object_type)(void); \
struct object_type##_vptr_struct{\
BELLE_SIP_OBJECT_VPTR_TYPE(parent_type) base;
#define BELLE_SIP_DECLARE_CUSTOM_VPTR_END };
#define BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(object_type) \
extern BELLE_SIP_OBJECT_VPTR_TYPE(object_type) BELLE_SIP_OBJECT_VPTR_NAME(object_type);\
BELLE_SIP_OBJECT_VPTR_TYPE(object_type) * BELLE_SIP_OBJECT_GET_VPTR_FUNC(object_type)(void){\
return &BELLE_SIP_OBJECT_VPTR_NAME(object_type); \
}\
BELLE_SIP_OBJECT_VPTR_TYPE(object_type) BELLE_SIP_OBJECT_VPTR_NAME(object_type)={
#define BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END };
#define BELLE_SIP_VPTR_INIT(object_type,parent_type,unowned) \
BELLE_SIP_TYPE_ID(object_type), \
sizeof(object_type), \
#object_type,\
unowned,\
(belle_sip_object_get_vptr_t)BELLE_SIP_OBJECT_GET_VPTR_FUNC(parent_type), \
(belle_sip_interface_desc_t**)object_type##interfaces_table
#define BELLE_SIP_INSTANCIATE_VPTR3(object_type,parent_type,destroy,clone,marshal,on_first_ref,on_last_ref,unowned,is_cpp) \
static BELLE_SIP_OBJECT_VPTR_TYPE(object_type) BELLE_SIP_OBJECT_VPTR_NAME(object_type)={ \
BELLE_SIP_VPTR_INIT(object_type,parent_type,unowned), \
(belle_sip_object_destroy_t)destroy, \
(belle_sip_object_clone_t)clone, \
(belle_sip_object_marshal_t)marshal,\
(belle_sip_object_on_first_ref_t)on_first_ref,\
(belle_sip_object_on_last_ref_t)on_last_ref,\
BELLE_SIP_DEFAULT_BUFSIZE_HINT,\
is_cpp, 0\
}; \
BELLE_SIP_OBJECT_VPTR_TYPE(object_type) * BELLE_SIP_OBJECT_GET_VPTR_FUNC(object_type)(void){\
return &BELLE_SIP_OBJECT_VPTR_NAME(object_type); \
}
#define BELLE_SIP_INSTANCIATE_VPTR2(object_type,parent_type,destroy,clone,marshal,on_first_ref,on_last_ref,unowned) \
BELLE_SIP_INSTANCIATE_VPTR3(object_type,parent_type,destroy,clone,marshal,on_first_ref,on_last_ref,unowned,FALSE)
#define BELLE_SIP_INSTANCIATE_VPTR(object_type,parent_type,destroy,clone,marshal,unowned) \
BELLE_SIP_INSTANCIATE_VPTR2(object_type, parent_type, destroy, clone, marshal, NULL, NULL, unowned)
/**
* belle_sip_object_t is the base object.
* It is the base class for all belle sip non trivial objects.
* It owns a reference count which allows to trigger the destruction of the object when the last
* user of it calls belle_sip_object_unref().
*
* It contains a generic data store that allows users to store named data in it and retrieve them afterwards.
*
* About object lifecycle
* In belle-sip, objects can be, depending on their types, initially owned, meaning that they are created with a ref count of 1, or
* initially unowned, meaning that they are created with reference count of 0. Such objets are also referred as "floating object". They are automatically destroyed
* by the main loop iteration, so a floating object can be seen as a temporary object, until someones calls belle_sip_object_ref() on it.
*
* In order to know whether a kind of object is initially owned or initially unowned, you can use the test program tester/belle_sip_object_describe.
* This tool gives the hierarchy and properties of the object type whose name is supplied in argument. For example:
*
* ./tester/belle_sip_object_describe belle_sip_request_t
*
* The object memory management depends slightly on whether an object type is created initially owned or not.
* In order not to be lost and make memory fault or leaks, consider the following rules:
*
* When an object is of type initially unowned:
* * call belle_sip_object_ref() on it only if you need a pointer to this object to be used outside the scope of the current function.
* * call belle_sip_object_unref() on it only if you previously called belle_sip_object_ref().
*
* When an object is of type initially owned:
* * you can safely store its pointer.
* * use belle_sip_object_unref() when you no longer need it.
*
* Also, keep in mind that most objects of belle-sip are initially unowned, especially
* * all objects who are usually required to be used inside another object (for example: an URI is part of a from header, a contact header is part of a message)
* * all objects whose lifecyle is maintained by the stack: transactions, dialogs.
*
* On the contrary, top level objects whose lifecyle belongs only to the application are initially owned:
* * belle_sip_provider_t, belle_sip_stack_t, belle_sip_source_t.
*
* Internally, belle-sip objects containing pointers to other objects must take a reference count on the other objects they hold; and leave this reference
* when they no longer need it. This rule must be strictly followed by developers doing things inside belle-sip.
**/
typedef struct _belle_sip_object belle_sip_object_t;
//cpp object differ only in vptr, just typedef to belle_sip_object_t for simplicity
typedef struct _belle_sip_object belle_sip_cpp_object_t;
typedef void (*belle_sip_object_destroy_t)(belle_sip_object_t*);
typedef void (*belle_sip_object_clone_t)(belle_sip_object_t* obj, const belle_sip_object_t *orig);
typedef belle_sip_error_code (*belle_sip_object_marshal_t)(belle_sip_object_t* obj, char* buff, size_t buff_size, size_t *offset);
typedef struct _belle_sip_object_vptr *(*belle_sip_object_get_vptr_t)(void);
typedef void (*belle_sip_object_on_first_ref_t)(belle_sip_object_t*);
typedef void (*belle_sip_object_on_last_ref_t)(belle_sip_object_t*);
struct _belle_sip_object_vptr{
belle_sip_type_id_t id;
size_t size; /*the size of the object - not the vptr size*/
const char *type_name;
int initially_unowned;
belle_sip_object_get_vptr_t get_parent;
struct belle_sip_interface_desc **interfaces; /*NULL terminated table of */
belle_sip_object_destroy_t destroy;
belle_sip_object_clone_t clone;
belle_sip_object_marshal_t marshal;
belle_sip_object_on_first_ref_t on_first_ref; /*called when object is ref'd for the first time*/
belle_sip_object_on_last_ref_t on_last_ref; /*called in unref() when the last reference of the object remains*/
int tostring_bufsize_hint; /*optimization: you can suggest here the typical size for a to_string() result.*/
int is_cpp; /*indicates whether this object kind is defined in c++*/
int cpp_offset; /*offset to apply to the belle_sip_object_t to find the pointer to the corresponding bellesip::Object, if any*/
};
typedef struct _belle_sip_object_vptr belle_sip_object_vptr_t;
struct _belle_sip_object{
belle_sip_object_vptr_t *vptr;
int ref;
char* name;
struct weak_ref *weak_refs;
struct belle_sip_object_pool *pool;
belle_sip_list_t *pool_iterator;
belle_sip_list_t *data_store;
};
BELLE_SIP_BEGIN_DECLS
BELLESIP_EXPORT belle_sip_object_t * _belle_sip_object_new(size_t objsize, belle_sip_object_vptr_t *vptr);
#ifdef __cplusplus
#define belle_sip_object_new(_type) reinterpret_cast<_type*>(static_cast(_belle_sip_object_new(sizeof(_type),(belle_sip_object_vptr_t*)BELLE_SIP_OBJECT_GET_VPTR_FUNC(_type)())))
#else
#define belle_sip_object_new(_type) (_type*)_belle_sip_object_new(sizeof(_type),(belle_sip_object_vptr_t*)BELLE_SIP_OBJECT_GET_VPTR_FUNC(_type)())
#endif
/**
* Activates checks on object marshalling.
* Useful for debug purposes.
* @param enable TRUE to enable, FALSE to disable.
**/
BELLESIP_EXPORT void belle_sip_object_enable_marshal_check(int enable);
/**
* Activates an object leak detector. When enabled, belle-sip will reference all created objects.
* At program termination, application can check if objects remain alive using belle_sip_object_get_object_count() and dump them with
* belle_sip_object_dump_active_objects().
* @warning this must not be used in multi-threaded programs (when multiple threads can access belle-sip at the same time)
* Useful for debug purposes.
* @param enable TRUE to enable, FALSE to disable.
**/
BELLESIP_EXPORT void belle_sip_object_enable_leak_detector(int enable);
BELLESIP_EXPORT int belle_sip_object_get_object_count(void);
BELLESIP_EXPORT void belle_sip_object_flush_active_objects(void);
BELLESIP_EXPORT void belle_sip_object_dump_active_objects(void);
/*
* Might be used to explicitly remove an object from leak detector.
*/
BELLESIP_EXPORT void belle_sip_object_remove_from_leak_detector(belle_sip_object_t *obj);
/**
* Suspend leak detector from this point. If the leak detector wasn't activated, this function does nothing.
* This can be useful to make object allocation that have to remain active beyond the scope of a test.
**/
BELLESIP_EXPORT void belle_sip_object_inhibit_leak_detector(int yes);
int belle_sip_object_is_unowed(const belle_sip_object_t *obj);
/**
* Increments reference counter, which prevents the object from being destroyed.
* If the object is initially unowed, this acquires the first reference.
*
**/
BELLESIP_EXPORT belle_sip_object_t * belle_sip_object_ref(void *obj);
/**
* Decrements the reference counter. When it drops to zero, the object is destroyed.
**/
BELLESIP_EXPORT void belle_sip_object_unref(void *obj);
/**
* Decrements the reference counter. When it drops to zero, the object is destroyed and returns TRUE. Otherwise returns FALSE.
**/
BELLESIP_EXPORT int belle_sip_object_unref_2(void *obj);
typedef void (*belle_sip_object_destroy_notify_t)(void *userpointer, belle_sip_object_t *obj_being_destroyed);
/**
* Add a weak reference to object.
* When object will be destroyed, then the destroy_notify callback will be called.
* This allows another object to be informed when object is destroyed, and then possibly
* cleanups pointer it holds to this object.
**/
BELLESIP_EXPORT belle_sip_object_t *belle_sip_object_weak_ref(void *obj, belle_sip_object_destroy_notify_t destroy_notify, void *userpointer);
/**
* Remove a weak reference to object.
**/
BELLESIP_EXPORT void belle_sip_object_weak_unref(void *obj, belle_sip_object_destroy_notify_t destroy_notify, void *userpointer);
/**
* Set object name.
**/
BELLESIP_EXPORT void belle_sip_object_set_name(belle_sip_object_t *obj,const char* name);
/**
* Get object name.
**/
BELLESIP_EXPORT const char* belle_sip_object_get_name(belle_sip_object_t *obj);
/*copy the content of ref object to new object, for the part they have in common in their inheritence diagram*/
void _belle_sip_object_copy(belle_sip_object_t *newobj, const belle_sip_object_t *ref);
/**
* Clone an object.
*
* This clone function makes a deep copy of all object internal structure, so that the new object and the reference object have no dependencies at all.
*
**/
BELLESIP_EXPORT belle_sip_object_t *belle_sip_object_clone(const belle_sip_object_t *obj);
/**
* Same as #belle_sip_object_clone but with ref count set to 1
*
**/
belle_sip_object_t *belle_sip_object_clone_and_ref(const belle_sip_object_t *obj);
typedef void (*belle_sip_data_destroy)(void* data);
typedef void* (*belle_sip_data_clone)(const char* name, void* data);
/**
* Add an entry to the object's embedded data store, with the key name specified.
* The destroy function is used when the data is cleaned.
*
* If an entry already exists, the existing data will be cleaned by calling its destroy function and the new data will be placed instead.
*
* Returns -1 in case of error, 0 in case the insertion was successful, and 1 if existing data was present.
**/
BELLESIP_EXPORT int belle_sip_object_data_set( belle_sip_object_t *obj, const char* name, void* data, belle_sip_data_destroy destroy_func );
/**
* Retrieve data that has been stored in the object data store.
**/
BELLESIP_EXPORT void* belle_sip_object_data_get( belle_sip_object_t *obj, const char* name );
/**
* Return 1 if the key exists in the data store, 0 otherwise
**/
BELLESIP_EXPORT int belle_sip_object_data_exists( const belle_sip_object_t *obj, const char* name );
/**
* Destroys the named data associated by the name provided.
*
* Returns 0 for success, -1 for error
**/
BELLESIP_EXPORT int belle_sip_object_data_remove( belle_sip_object_t *obj, const char* name);
/**
* Retrieve the data from the data store and removes it from the data store, without calling the destructor.
* This transfers ownership of the data to the caller, which will be in charge of releasing it.
**/
BELLESIP_EXPORT void* belle_sip_object_data_grab( belle_sip_object_t* obj, const char* name);
/**
* Clears all data in the object's storage, invoking the destroy_func when possible
**/
BELLESIP_EXPORT void belle_sip_object_data_clear( belle_sip_object_t* obj );
/**
* clones the object's data store to another one, using the provided clone function to clone individual data items.
*
* The destination data store will be cleaned before pushing the source data into it.
* For a merge, use #belle_sip_object_data_merge.
* This is equivalent to the following code:
* {
* belle_sip_object_data_clear(dst);
* belle_sip_object_data_merge(src, dst, clone_func);
* }
*
* Note that providing NULL as a cloning function will simply assign the src object's data to the dst object.
*
**/
BELLESIP_EXPORT void belle_sip_object_data_clone( const belle_sip_object_t* src, belle_sip_object_t* dst, belle_sip_data_clone clone_func);
/**
* Merge the source data store into the destination data store.
*
* Same function as #belle_sip_object_data_clone, except the destination data store is not cleared before inserting the source data.
* This overwrites common keys, and keeps existing keys.
*/
BELLESIP_EXPORT void belle_sip_object_data_merge( const belle_sip_object_t* src, belle_sip_object_t* dst, belle_sip_data_clone clone_func);
/**
* Apply a function for each entry in the data store
*/
BELLESIP_EXPORT void belle_sip_object_data_foreach( const belle_sip_object_t* obj, void (*apply_func)(const char* key, void* data, void* userdata), void* userdata);
/**
* Returns a string describing the inheritance diagram and implemented interfaces of object obj.
**/
char *belle_sip_object_describe(void *obj);
/**
* Returns a string describing the inheritance diagram and implemented interfaces of an object given its type name.
**/
BELLESIP_EXPORT char *belle_sip_object_describe_type_from_name(const char *name);
BELLESIP_EXPORT void *belle_sip_object_cast(belle_sip_object_t *obj, belle_sip_type_id_t id, const char *castname, const char *file, int fileno);
/**
* Returns a newly allocated string representing the object.
* WHen the object is a sip header, uri or message, this is the textual representation of the header, uri or message.
* This function internally calls belle_sip_object_marshal().
**/
BELLESIP_EXPORT char* belle_sip_object_to_string(const void* obj);
/**
* Writes a string representation of the object into the supplied buffer.
* Same as belle_sip_object_to_string(), but without allocating space for the output string.
**/
BELLESIP_EXPORT belle_sip_error_code belle_sip_object_marshal(belle_sip_object_t* obj, char* buff, size_t buff_size, size_t *offset);
/* use BELLE_SIP_OBJECT_IS_INSTANCE_OF macro(), this function is for use by the macro only*/
BELLESIP_EXPORT int _belle_sip_object_is_instance_of(belle_sip_object_t * obj,belle_sip_type_id_t id);
BELLE_SIP_END_DECLS
#define BELLE_SIP_CAST(obj,_type) ((_type*)belle_sip_object_cast((belle_sip_object_t *)(obj), _type##_id, #_type, __FILE__, __LINE__))
#define BELLE_SIP_OBJECT(obj) BELLE_SIP_CAST(obj,belle_sip_object_t)
#define BELLE_SIP_OBJECT_IS_INSTANCE_OF(obj,_type) _belle_sip_object_is_instance_of((belle_sip_object_t*)obj,_type##_id)
#define BELLE_SIP_OBJECT_VPTR(obj,object_type) ((BELLE_SIP_OBJECT_VPTR_TYPE(object_type)*)(((belle_sip_object_t*)obj)->vptr))
/*deprecated*/
#define BELLE_SIP_IS_INSTANCE_OF(obj,_type) BELLE_SIP_OBJECT_IS_INSTANCE_OF(obj,_type)
#define belle_sip_object_describe_type(type) \
belle_sip_object_describe_type_from_name(#type)
/*
* typedefs, macros and functions for interface definition and manipulation.
*/
#define BELLE_SIP_INTERFACE_ID(_interface) _interface##_id
typedef unsigned int belle_sip_interface_id_t;
BELLE_SIP_BEGIN_DECLS
BELLESIP_EXPORT void *belle_sip_object_interface_cast(belle_sip_object_t *obj, belle_sip_interface_id_t id, const char *castname, const char *file, int fileno);
int belle_sip_object_implements(belle_sip_object_t *obj, belle_sip_interface_id_t id);
BELLE_SIP_END_DECLS
#define BELLE_SIP_INTERFACE_METHODS_TYPE(interface_name) methods_##interface_name
#define BELLE_SIP_INTERFACE_CAST(obj,_iface) ((_iface*)belle_sip_object_interface_cast((belle_sip_object_t*)(obj),_iface##_id,#_iface,__FILE__,__LINE__))
#define BELLE_SIP_IMPLEMENTS(obj,_iface) belle_sip_object_implements((belle_sip_object_t*)obj,_iface##_id)
typedef struct belle_sip_interface_desc{
belle_sip_interface_id_t id;
const char *ifname;
}belle_sip_interface_desc_t;
#define BELLE_SIP_DECLARE_INTERFACE_BEGIN(interface_name) \
typedef struct struct##interface_name interface_name;\
typedef struct struct_methods_##interface_name BELLE_SIP_INTERFACE_METHODS_TYPE(interface_name);\
struct struct_methods_##interface_name {\
belle_sip_interface_desc_t desc;\
#define BELLE_SIP_DECLARE_INTERFACE_END };
#define BELLE_SIP_IMPLEMENT_INTERFACE_BEGIN(object_type,interface_name) \
static BELLE_SIP_INTERFACE_METHODS_TYPE(interface_name) methods_##object_type##_##interface_name={\
{ BELLE_SIP_INTERFACE_ID(interface_name),\
#interface_name },
#define BELLE_SIP_IMPLEMENT_INTERFACE_END };
#define BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(object_type)\
static belle_sip_interface_desc_t * object_type##interfaces_table[]={\
NULL \
}
#define BELLE_SIP_DECLARE_IMPLEMENTED_INTERFACES_1(object_type,iface1) \
static belle_sip_interface_desc_t * object_type##interfaces_table[]={\
(belle_sip_interface_desc_t*)&methods_##object_type##_##iface1, \
NULL \
}
#define BELLE_SIP_DECLARE_IMPLEMENTED_INTERFACES_2(object_type,iface1,iface2) \
static belle_sip_interface_desc_t * object_type##interfaces_table[]={\
(belle_sip_interface_desc_t*)&methods_##object_type##_##iface1, \
(belle_sip_interface_desc_t*)&methods_##object_type##_##iface2, \
NULL \
}
/**
* Object holding unowned objects - used as a kind of garbage collector for temporary objects.
**/
typedef struct belle_sip_object_pool belle_sip_object_pool_t;
BELLE_SIP_BEGIN_DECLS
/**
* Push a new object pool for use for creation of new objects.
* When no longer needed, this pool can be destroyed with belle_sip_object_unref().
**/
BELLESIP_EXPORT belle_sip_object_pool_t * belle_sip_object_pool_push(void);
belle_sip_object_pool_t * belle_sip_object_pool_get_current(void);
int belle_sip_object_pool_cleanable(belle_sip_object_pool_t *pool);
void belle_sip_object_pool_clean(belle_sip_object_pool_t *obj);
BELLE_SIP_DECLARE_VPTR(belle_sip_object_t)
BELLE_SIP_END_DECLS
/**
* Adding a new type in belle-sip in 5 steps
* =========================================
*
* Let's suppose you want to add an object called belle_sip_something_t
* 1) Declare the type in the enum in belle-sip.h:
* BELLE_SIP_TYPE_ID(belle_sip_something_t)
* 2) Declare the api of the new object in .h, including a typedef and a cast macro:
* typedef struct belle_sip_something belle_sip_something_t;
* #define BELLE_SIP_SOMETHING(obj) BELLE_SIP_CAST(obj,belle_sip_something_t)
*
* belle_sip_something_t *belle_sip_something_create(int arg1, int arg2);
* void belle_sip_something_do_cooking(belle_sip_something_t *obj);
* Do not add any destructor, belle_sip_object_unref() does it for all objects.
*
* 3) in the c file contaning the object's implementation, define the internal structure for your object.
* The first field of the struct must be the parent type.
* struct belle_sip_something{
* belle_sip_object_t base;
* int myint1;
* int myint2;
* char *mychar;
* };
* 4) still in the C file contaning the object's implementation, define a destructor and all functions of its API:
* The destructor must only manage the fields from the type, not the parent.
* static void belle_sip_something_destroy(belle_sip_something_t *obj){
* if (obj->mychar) belle_sip_free(obj->mychar);
* }
*
* belle_sip_something_t *belle_sip_something_create(int arg1, int arg2){
* belle_sip_something_t *obj=belle_sip_object_new(belle_sip_something_t);
* obj->myint1=arg1;
* obj->myint2=arg2;
* obj->mychar=belle_sip_strdup("Hello world");
* return obj;
* }
* Declare the interfaces implemented by the object (to be documented) and instanciate its "vptr", necessary for dynamic casting.
* BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_something_t);
* BELLE_SIP_INSTANCIATE_VPTR(belle_sip_something_t, belle_sip_object_t,belle_sip_something_destroy, NULL, NULL,FALSE);
*
* 5) in .h file included everywhere in the source (typically belle_sip_internal.h), declare the vptr
* BELLE_SIP_DECLARE_VPTR(belle_sip_dns_srv_t);
*/
#if defined(__cplusplus) && defined(BELLE_SIP_USE_STL)
#include
inline std::ostream&
operator<<( std::ostream& __os, const belle_sip_object_t* object)
{
char* object_as_string = belle_sip_object_to_string((void*)object);
__os << object_as_string;
belle_sip_free(object_as_string);
return __os;
}
#endif
#endif
belle-sip-5.2.0+dfsg/include/belle-sip/parameters.h 0000664 0000000 0000000 00000005504 14346131365 0022136 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef PARAMETERS_H_
#define PARAMETERS_H_
#include "belle-sip/utils.h"
#include "belle-sip/list.h"
BELLE_SIP_BEGIN_DECLS
/***
* parameters
*
*/
belle_sip_parameters_t* belle_sip_parameters_new(void);
/*
* remove all parameters */
BELLESIP_EXPORT void belle_sip_parameters_clean(belle_sip_parameters_t* params);
/*BELLESIP_EXPORT void belle_sip_parameters_destroy(belle_sip_parameters_t* params);*/
BELLESIP_EXPORT const char* belle_sip_parameters_get_parameter(const belle_sip_parameters_t* obj,const char* name);
/*
* same as #belle_sip_parameters_get_parameter but name is case insensitive */
BELLESIP_EXPORT const char* belle_sip_parameters_get_case_parameter(const belle_sip_parameters_t* params,const char* name);
/**
* returns 0 if not found
*/
BELLESIP_EXPORT unsigned int belle_sip_parameters_has_parameter(const belle_sip_parameters_t* obj,const char* name);
BELLESIP_EXPORT void belle_sip_parameters_set_parameter(belle_sip_parameters_t* obj,const char* name,const char* value);
/**
* Assign a full set of parameters to the belle_sip_parameters_t object.
* Parameters are given as string of key=value pairs separated with semicolons, where value is optional.
* @example belle_sip_parameters_set(parameters,"param1=value1;param2;param3=value3");
**/
BELLESIP_EXPORT void belle_sip_parameters_set(belle_sip_parameters_t *parameters, const char* params);
BELLESIP_EXPORT const belle_sip_list_t * belle_sip_parameters_get_parameter_names(const belle_sip_parameters_t* obj);
BELLESIP_EXPORT const belle_sip_list_t * belle_sip_parameters_get_parameters(const belle_sip_parameters_t* obj);
BELLESIP_EXPORT void belle_sip_parameters_remove_parameter(belle_sip_parameters_t* obj,const char* name);
BELLESIP_EXPORT belle_sip_error_code belle_sip_parameters_marshal(const belle_sip_parameters_t* obj, char* buff, size_t buff_size, size_t *offset);
BELLESIP_EXPORT void belle_sip_parameters_copy_parameters_from(belle_sip_parameters_t *params, const belle_sip_parameters_t *orig);
#define BELLE_SIP_PARAMETERS(obj) BELLE_SIP_CAST(obj,belle_sip_parameters_t)
BELLE_SIP_END_DECLS
#endif /*PARAMETERS_H_*/
belle-sip-5.2.0+dfsg/include/belle-sip/provider.h 0000664 0000000 0000000 00000016775 14346131365 0021641 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef belle_sip_provider_h
#define belle_sip_provider_h
#define BELLE_SIP_BRANCH_MAGIC_COOKIE "z9hG4bK"
BELLE_SIP_BEGIN_DECLS
BELLESIP_EXPORT belle_sip_uri_t *belle_sip_provider_create_inbound_record_route(belle_sip_provider_t *p, belle_sip_request_t *req);
BELLESIP_EXPORT int belle_sip_provider_is_us(belle_sip_provider_t *p, belle_sip_uri_t*);
BELLESIP_EXPORT int belle_sip_provider_add_listening_point(belle_sip_provider_t *p, belle_sip_listening_point_t *lp);
BELLESIP_EXPORT void belle_sip_provider_remove_listening_point(belle_sip_provider_t *p, belle_sip_listening_point_t *lp);
BELLESIP_EXPORT belle_sip_listening_point_t *belle_sip_provider_get_listening_point(belle_sip_provider_t *p, const char *transport);
BELLESIP_EXPORT const belle_sip_list_t *belle_sip_provider_get_listening_points(belle_sip_provider_t *p);
BELLESIP_EXPORT void belle_sip_provider_add_sip_listener(belle_sip_provider_t *p, belle_sip_listener_t *l);
BELLESIP_EXPORT void belle_sip_provider_remove_sip_listener(belle_sip_provider_t *p, belle_sip_listener_t *l);
BELLESIP_EXPORT belle_sip_header_call_id_t * belle_sip_provider_create_call_id(const belle_sip_provider_t *prov);
BELLESIP_EXPORT belle_sip_dialog_t *belle_sip_provider_create_dialog(belle_sip_provider_t *prov, belle_sip_transaction_t *t);
BELLESIP_EXPORT belle_sip_client_transaction_t *belle_sip_provider_create_client_transaction(belle_sip_provider_t *p, belle_sip_request_t *req);
BELLESIP_EXPORT belle_sip_server_transaction_t *belle_sip_provider_create_server_transaction(belle_sip_provider_t *p, belle_sip_request_t *req);
BELLESIP_EXPORT belle_sip_stack_t *belle_sip_provider_get_sip_stack(belle_sip_provider_t *p);
BELLESIP_EXPORT void belle_sip_provider_send_request(belle_sip_provider_t *p, belle_sip_request_t *req);
BELLESIP_EXPORT void belle_sip_provider_send_response(belle_sip_provider_t *p, belle_sip_response_t *resp);
BELLESIP_EXPORT void belle_sip_provider_clean_channels(belle_sip_provider_t *p);
/* Close connections for which no data was received at all during last X seconds period of time.
* This is useful because some routers don't send ICMP or TCP connection reset when they reallocate a port.
* For the client, the connection is presumed to be alive, but in practice it is not and there will never be any error.
* As a workaround, simply close these connections, and let the stack re-establish new ones, while refreshing registration for example.
* The time period after which a channel is considered as "unreliable" is configured with
* belle_sip_stack_set_unreliable_connection_timeout(belle_sip_stack_t *stack);
*/
BELLESIP_EXPORT void belle_sip_provider_clean_unreliable_channels(belle_sip_provider_t *p);
/**
* Add auth info to the request if found
* @param p object
* @param request to be updated
* @param resp response to take authentication values from, might be NULL
* @param from_uri optional - an uri to use instead of the from of the request, which can be anonymous.
* @param auth_infos optional - A newly allocated belle_sip_auth_info_t object is added to this list. These object contains useful information like realm and username.
* @param realm optional - If an outbound proxy realm is used, nounce can be reused from previous request to avoid re-authentication.
* @returns 0 in case of success,
*
**/
BELLESIP_EXPORT int belle_sip_provider_add_authorization(belle_sip_provider_t *p, belle_sip_request_t* request,belle_sip_response_t *resp, belle_sip_uri_t *from_uri, belle_sip_list_t** auth_infos, const char* realm);
/**
* Provides access to a specific dialog
* @param prov object
* @param call_if of the dialog
* @param local_tag of the dialog
* @param remote_tag of the dialog
* @returns dialog corresponding to this parameter or NULL if not found
*
**/
BELLESIP_EXPORT belle_sip_dialog_t* belle_sip_provider_find_dialog(const belle_sip_provider_t *prov, const char* call_id,const char* local_tag,const char* remote_tag);
/**
* Provides access to a specific dialog
* @param prov object
* @param call_if of the dialog
* @param remote_tag of the dialog
* @returns dialog that correspond to these parameters or NULL if not found
*
**/
BELLESIP_EXPORT belle_sip_dialog_t* belle_sip_provider_find_dialog_with_remote_tag(const belle_sip_provider_t *prov, const char* call_id,const char* remote_tag);
/**
* Enable rport in via header. Enabled by default
* @param prov
* @return enable 0 to disable
**/
BELLESIP_EXPORT void belle_sip_provider_enable_rport(belle_sip_provider_t *prov, int enable);
/**
* get Enable rport in via header. Enabled by default
* @param prov
* @param enable 0 to disable
**/
BELLESIP_EXPORT int belle_sip_provider_is_rport_enabled(belle_sip_provider_t *prov);
/**
* Enable discovery of NAT's public address and port during SIP exchanges.
* When activated, automatic contacts ( see belle_sip_header_contact_set_automatic() )
* will use discovered public IP address and port (if any) instead of local ones.
* NAT public address and port are discovered using received and rport parameters in via header of responses.
* As a result, disabling rport ( see belle_sip_provider_enable_rport() ) will also break this feature.
**/
BELLESIP_EXPORT void belle_sip_provider_enable_nat_helper(belle_sip_provider_t *prov, int enabled);
/**
* Returns if nat helper behavior is enabled.
* @see belle_sip_provider_enable_nat_helper()
**/
BELLESIP_EXPORT int belle_sip_provider_nat_helper_enabled(const belle_sip_provider_t *prov);
/*
* Following functions are used for tests ONLY
*/
/**
* Can be used to simulate network recv error, for tests.
* @param prov
* @param recv_error if <=0, will cause channel error to be reported
**/
BELLESIP_EXPORT void belle_sip_provider_set_recv_error(belle_sip_provider_t *prov, int recv_error);
/**
* Can be used to unconditionally answer to incoming sip messages. By default 480 is answered.
* Can be enhanced by a new method belle_sip_provider_set_unconditional_answer to allows user to provide answer code
* @param prov
* @param enable 0 to disable
**/
BELLESIP_EXPORT void belle_sip_provider_enable_unconditional_answer(belle_sip_provider_t *prov, int enable);
/**
* Can be used to choose unconditionally answer to incoming sip messages.
* use belle_sip_provider_enable_unconditional_answer to enable/disable
* @param prov
* @param code 0 to sip response code
**/
BELLESIP_EXPORT void belle_sip_provider_set_unconditional_answer(belle_sip_provider_t *prov, unsigned short code);
/**
* Check integrity of responses. By default it is true, however for testing purpose it might be useful
* to receive and get notified of invalid responses.
*/
BELLESIP_EXPORT void belle_sip_provider_enable_response_integrity_checking(belle_sip_provider_t *prov, int value);
/*
* End of test features.
*/
BELLE_SIP_END_DECLS
#define BELLE_SIP_PROVIDER(obj) BELLE_SIP_CAST(obj,belle_sip_provider_t)
#endif
belle-sip-5.2.0+dfsg/include/belle-sip/refresher.h 0000664 0000000 0000000 00000011126 14346131365 0021755 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef REFRESHER_HELPER_H_
#define REFRESHER_HELPER_H_
#define BELLE_SIP_REFRESHER_REUSE_EXPIRES -1
BELLE_SIP_BEGIN_DECLS
typedef struct belle_sip_refresher belle_sip_refresher_t;
/**
* Refresher listener invoked every time a refresh action is performed
* @param refresher corresponding refresher object.
* @param user_pointer user pointer
* @param status_code status code for the last refresh action
* @param reason_phrase
* @param will_retry a boolean indicating wether the refresher is going to retry the request automatically.
* */
typedef void (*belle_sip_refresher_listener_t) (belle_sip_refresher_t* refresher
,void* user_pointer
,unsigned int status_code
,const char* reason_phrase, int will_retry);
/**
* add a refresher listener
*/
BELLESIP_EXPORT void belle_sip_refresher_set_listener(belle_sip_refresher_t* refresher, belle_sip_refresher_listener_t listener,void* user_pointer);
/**
* start the refresher
*/
int belle_sip_refresher_start(belle_sip_refresher_t* refresher);
/**
* stop refresher.
* If a transaction is pending, it will be terminated.
*/
BELLESIP_EXPORT void belle_sip_refresher_stop(belle_sip_refresher_t* refresher);
/**
* Manually initiate a new transaction .
* @param refresher object
* @param expires #BELLE_SIP_REFRESHER_REUSE_EXPIRES means value extracted from the transaction
* @return 0 if succeed
*/
BELLESIP_EXPORT int belle_sip_refresher_refresh(belle_sip_refresher_t* refresher,int expires);
/**
* returns current expires value;
*/
BELLESIP_EXPORT int belle_sip_refresher_get_expires(const belle_sip_refresher_t* refresher);
/**
* returns delay in ms after which the refresher will retry in case of recoverable error (I.E 408, 480, 503, 504, io error);
*/
BELLESIP_EXPORT int belle_sip_refresher_get_retry_after(const belle_sip_refresher_t* refresher);
/**
* Delay in ms after which the refresher will retry in case of recoverable error (I.E 408, 480, 503, 504, io error);
*/
BELLESIP_EXPORT void belle_sip_refresher_set_retry_after(belle_sip_refresher_t* refresher, int delay_ms);
/**
* returns realm of the outbound proxy used for authentication, if any
*/
BELLESIP_EXPORT const char* belle_sip_refresher_get_realm(const belle_sip_refresher_t* refresher);
/**
* Realm of the outbound proxy used for authentication, if any
*/
BELLESIP_EXPORT void belle_sip_refresher_set_realm(belle_sip_refresher_t* refresher, const char* realm);
/**
* get current client transaction
* @param refresher object
* @return transaction
*/
BELLESIP_EXPORT const belle_sip_client_transaction_t* belle_sip_refresher_get_transaction(const belle_sip_refresher_t* refresher);
/**
* Get current list of auth info if any. Contains the list of filled #belle_sip_auth_event_t in case of a 401 or 407 is repported to the #belle_sip_refresher_listener_t ;
* @param refresher object
* @return list of #belle_sip_auth_info_t
*/
BELLESIP_EXPORT const belle_sip_list_t* belle_sip_refresher_get_auth_events(const belle_sip_refresher_t* refresher);
/**
* Enable manual mode: only belle_sip_refresher_refresh() called by application will cause requests to be resubmitted.
**/
BELLESIP_EXPORT void belle_sip_refresher_enable_manual_mode(belle_sip_refresher_t *refresher, int enabled);
/**
* Retrieve current local address used by the underlying refresher's channel.
**/
BELLESIP_EXPORT const char * belle_sip_refresher_get_local_address(belle_sip_refresher_t* refresher, int *port);
/**
* Retrieve current public address used by the underlying refresher's channel.
**/
BELLESIP_EXPORT const char * belle_sip_refresher_get_public_address(belle_sip_refresher_t* refresher, int *port);
/**
* Retrieve last know contact header if known. Only available after a successful registration.
**/
BELLESIP_EXPORT belle_sip_header_contact_t* belle_sip_refresher_get_contact(const belle_sip_refresher_t* refresher);
BELLE_SIP_END_DECLS
#endif /* REFRESHER_HELPER_H_ */
belle-sip-5.2.0+dfsg/include/belle-sip/resolver.h 0000664 0000000 0000000 00000015314 14346131365 0021634 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef belle_sip_resolver_h
#define belle_sip_resolver_h
typedef struct belle_sip_dns_srv belle_sip_dns_srv_t;
#define BELLE_SIP_DNS_SRV(obj) BELLE_SIP_CAST(obj,belle_sip_dns_srv_t)
typedef struct belle_sip_resolver_context belle_sip_resolver_context_t;
#define BELLE_SIP_RESOLVER_CONTEXT(obj) BELLE_SIP_CAST(obj,belle_sip_resolver_context_t)
typedef struct belle_sip_resolver_results belle_sip_resolver_results_t;
#define BELLE_SIP_RESOLVER_RESULTS(obj) BELLE_SIP_CAST(obj,belle_sip_resolver_results_t)
/**
* Callback prototype for asynchronous DNS SRV resolution.
* The srv_list contains struct dns_srv elements that must be taken and (possibly later) freed by the callee, using belle_sip_free().
*/
typedef void (*belle_sip_resolver_srv_callback_t)(void *data, const char *name, belle_sip_list_t *srv_list, uint32_t ttl);
/**
* Callback prototype for asynchronous DNS A and AAAA resolution.
* The 'results' object must be acquired (ref'd) in order for being accessed outside of the callback.
* The results object provides SRV records list and addrinfo list.
**/
typedef void (*belle_sip_resolver_callback_t)(void *data, belle_sip_resolver_results_t *results);
BELLE_SIP_BEGIN_DECLS
BELLESIP_EXPORT const char *belle_sip_dns_srv_get_target(const belle_sip_dns_srv_t *obj);
BELLESIP_EXPORT unsigned short belle_sip_dns_srv_get_priority(const belle_sip_dns_srv_t *obj);
BELLESIP_EXPORT unsigned short belle_sip_dns_srv_get_weight(const belle_sip_dns_srv_t *obj);
BELLESIP_EXPORT unsigned short belle_sip_dns_srv_get_port(const belle_sip_dns_srv_t *obj);
/**
* Find the belle_sip_dns_srv_t object associated with a particular addrinfo.
* The srv_list and the addrinfo must be the ones given by the belle_sip_resolver_callback_t callback invoked consecutively to a call
* to belle_sip_stack_resolve().
**/
BELLESIP_EXPORT const belle_sip_dns_srv_t * belle_sip_resolver_results_get_srv_from_addrinfo(const belle_sip_resolver_results_t *obj, const struct addrinfo *ai);
BELLESIP_EXPORT const bctbx_list_t *belle_sip_resolver_results_get_srv_records(const belle_sip_resolver_results_t *obj);
BELLESIP_EXPORT const struct addrinfo *belle_sip_resolver_results_get_addrinfos(const belle_sip_resolver_results_t *obj);
BELLESIP_EXPORT int belle_sip_resolver_results_get_ttl(const belle_sip_resolver_results_t *obj);
BELLESIP_EXPORT const char * belle_sip_resolver_results_get_name(const belle_sip_resolver_results_t *obj);
/**
* Asynchronously performs DNS SRV followed A/AAAA query. Automatically fallbacks to A/AAAA if SRV isn't found.
* @param stack the belle_sip_stack_t, used to schedule asynchronous execution.
* @param service the queried service ("sip", "stun", "turn"...)
* @param transport the queried transport ("udp", "tcp", "tls")
* @param name the SIP domain name
* @param port a port that will be filled in the addrinfo list returned by the callback, for the case where no SRV records are found.
* @param family address family expected in the addrinfo result list. AF_INET or AF_INET6. If AF_INET6 is used but no IPv6 records are found, the IPv4 addresses
* will be returned as IPv6 with v4 mapping (AI_V4MAPPED).
* @param cb a callback function that will be called to notify the results.
* @param data a user pointer passed through the callback as first argument.
* @return a #belle_sip_resolver_context_t that can be used to cancel the resolution if needed. The context must have been ref'd with belle_sip_object_ref().
**/
BELLESIP_EXPORT belle_sip_resolver_context_t * belle_sip_stack_resolve(belle_sip_stack_t *stack, const char *service, const char *transport, const char *name, int port, int family,
belle_sip_resolver_callback_t cb, void *data);
/**
* Asynchronously performs DNS A or AAAA query.
* @param stack the belle_sip_stack_t, used to schedule asynchronous execution.
* @param name the SIP domain name
* @param port a port that will be filled in the addrinfo list returned by the callback, for the case where no SRV records are found.
* @param family address family expected in the addrinfo result list. AF_INET or AF_INET6. If AF_INET6 is used but no IPv4 records are found, the IPv4 addresses
* will be returned as IPv6 with v4 mapping (AI_V4MAPPED).
* @param cb a callback function that will be called to notify the results.
* @param data a user pointer passed through the callback as first argument.
* @return a #belle_sip_resolver_context_t that can be used to cancel the resolution if needed. The context must have been ref'd with belle_sip_object_ref().
**/
BELLESIP_EXPORT belle_sip_resolver_context_t * belle_sip_stack_resolve_a(belle_sip_stack_t *stack, const char *name, int port, int family, belle_sip_resolver_callback_t cb, void *data);
/**
* Asynchronously performs DNS SRV query.
* @return a #belle_sip_resolver_context_t that can be used to cancel the resolution if needed. The context must have been ref'd with belle_sip_object_ref().
**/
BELLESIP_EXPORT belle_sip_resolver_context_t * belle_sip_stack_resolve_srv(belle_sip_stack_t *stack, const char *service, const char *transport, const char *name, belle_sip_resolver_srv_callback_t cb, void *data);
/**
* Cancel a pending asynchronous DNS query. The context is unref'd automatically, as a result the context shall no longer be used after this call.
* If the query is already performed, cancellation has no effect, but context is unref'd anyway.
**/
BELLESIP_EXPORT void belle_sip_resolver_context_cancel(belle_sip_resolver_context_t *ctx);
/**
* Lookups the source address from local interface that can be used to connect to a destination address.
* local_port is only used to be assigned into the result source address.
* This function always puts something in src and srclen (the loopback address) even if anything fails.
* The return code is 0 if successful, or -errno if an error was encoutered. Typical error is -ENETUNREACH when IPv6 network is not reachable.
**/
BELLESIP_EXPORT int belle_sip_get_src_addr_for(const struct sockaddr *dest, socklen_t destlen, struct sockaddr *src, socklen_t *srclen, int local_port);
BELLE_SIP_END_DECLS
#endif
belle-sip-5.2.0+dfsg/include/belle-sip/sip-uri.h 0000664 0000000 0000000 00000021402 14346131365 0021356 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef BELLE_SIP_URI_H_
#define BELLE_SIP_URI_H_
#include "belle-sip/defs.h"
#include "belle-sip/list.h"
#include "belle-sip/utils.h"
#include "belle-sip/types.h"
BELLE_SIP_BEGIN_DECLS
/**
*
*/
BELLESIP_EXPORT belle_sip_uri_t* belle_sip_uri_new(void);
/**
*
*/
BELLESIP_EXPORT belle_sip_uri_t* belle_sip_uri_parse (const char* uri) ;
/**
*
*/
BELLESIP_EXPORT belle_sip_uri_t* belle_sip_fast_uri_parse (const char* uri) ;
/**
* same as belle_sip_uri_parse but with much less checks
*/
BELLESIP_EXPORT belle_sip_uri_t* belle_sip_fast_uri_parse (const char* uri) ;
/**
*
*/
BELLESIP_EXPORT belle_sip_uri_t* belle_sip_uri_create (const char* username,const char* host) ;
/**
* Returns the value of the named header, or null if it is not set.
*
*/
BELLESIP_EXPORT const char* belle_sip_uri_get_header(const belle_sip_uri_t* uri,const char* name);
/**
* Returns all URI headers
*
*/
BELLESIP_EXPORT const belle_sip_parameters_t* belle_sip_uri_get_headers(const belle_sip_uri_t* uri);
/**
* Remove all headers
*
*/
BELLESIP_EXPORT void belle_sip_uri_headers_clean(belle_sip_uri_t* uri);
/**
* Returns an Iterator over the const char*names of all headers present in this SipURI.
*
*/
BELLESIP_EXPORT const belle_sip_list_t* belle_sip_uri_get_header_names(const belle_sip_uri_t* uri) ;
/**
* Returns the host part of this SipURI.
*
*/
BELLESIP_EXPORT const char* belle_sip_uri_get_host(const belle_sip_uri_t* uri) ;
/**
* Returns the value of the maddr parameter, or null if this is not set.
*
*/
BELLESIP_EXPORT const char* belle_sip_uri_get_maddr_param(const belle_sip_uri_t* uri) ;
/**
* Returns the value of the method parameter, or null if this is not set.
*
*/
BELLESIP_EXPORT const char* belle_sip_uri_get_method_param(const belle_sip_uri_t* uri) ;
/**
* Returns the port part of this SipURI.
*
*/
BELLESIP_EXPORT int belle_sip_uri_get_port(const belle_sip_uri_t* uri) ;
/**
* Returns the port of the uri, if not specified in the uri returns the well known port according to the transport.
**/
BELLESIP_EXPORT int belle_sip_uri_get_listening_port(const belle_sip_uri_t *uri);
/**
* Returns the value of the "transport" parameter, or null if this is not set.
*
*/
BELLESIP_EXPORT const char* belle_sip_uri_get_transport_param(const belle_sip_uri_t* uri) ;
/**
* Returns the value of the "ttl" parameter, or -1 if this is not set.
*
*/
BELLESIP_EXPORT int belle_sip_uri_get_ttl_param(const belle_sip_uri_t* uri) ;
/**
* Returns the user part of this SipURI.
*
*/
BELLESIP_EXPORT const char* belle_sip_uri_get_user(const belle_sip_uri_t* uri) ;
/**
* Returns the value of the userParam, or null if this is not set.
*
*/
BELLESIP_EXPORT const char* belle_sip_uri_get_user_param(const belle_sip_uri_t* uri) ;
/**
* Gets user password of SipURI, or null if it is not set.
*
*/
BELLESIP_EXPORT const char* belle_sip_uri_get_user_password(const belle_sip_uri_t* uri) ;
/**
* Returns whether the the lr parameter is set.
*
*/
BELLESIP_EXPORT unsigned int belle_sip_uri_has_lr_param(const belle_sip_uri_t* uri) ;
/**
*
* Returns true if this SipURI is secure i.e. if this SipURI represents a sips URI.
*
*/
BELLESIP_EXPORT unsigned int belle_sip_uri_is_secure(const belle_sip_uri_t* uri) ;
/**
* Sets the value of the specified header fields to be included in a request constructed from the URI.
*
*/
BELLESIP_EXPORT void belle_sip_uri_set_header(belle_sip_uri_t* uri,const char*name, const char*value) ;
/**
* Removes specified header from uri.
**/
BELLESIP_EXPORT void belle_sip_uri_remove_header(belle_sip_uri_t *uri, const char *name);
/**
* Removes the port part of this SipURI.
*
*/
BELLESIP_EXPORT void belle_sip_uri_remove_port(belle_sip_uri_t* uri) ;
/**
* Set the host part of this SipURI to the newly supplied host parameter.
*
*/
BELLESIP_EXPORT void belle_sip_uri_set_host(belle_sip_uri_t* uri,const char*host) ;
/**
* Sets the value of the lr parameter of this SipURI.
*
*/
BELLESIP_EXPORT void belle_sip_uri_set_lr_param(belle_sip_uri_t* uri,unsigned int param) ;
/**
* Sets the value of the maddr parameter of this SipURI.
*
*/
BELLESIP_EXPORT void belle_sip_uri_set_maddr_param(belle_sip_uri_t* uri,const char*mAddr) ;
/**
* Sets the value of the method parameter.
*
*/
BELLESIP_EXPORT void belle_sip_uri_set_method_param(belle_sip_uri_t* uri,const char*method) ;
/**
* Set the port part of this SipURI to the newly supplied port parameter.
*
*/
BELLESIP_EXPORT void belle_sip_uri_set_port(belle_sip_uri_t* uri, int port) ;
/**
* Sets the scheme of this URI to sip or sips depending on whether the argument is true or false.
*
*/
BELLESIP_EXPORT void belle_sip_uri_set_secure(belle_sip_uri_t* uri,unsigned int secure) ;
/**
* Sets the value of the "transport" parameter.
*
*/
BELLESIP_EXPORT void belle_sip_uri_set_transport_param(belle_sip_uri_t* uri,const char*transport) ;
/**
* Sets the value of the ttl parameter.
*
*/
BELLESIP_EXPORT void belle_sip_uri_set_ttl_param(belle_sip_uri_t* uri,int ttl) ;
/**
* Sets the user of SipURI.
*
*/
BELLESIP_EXPORT void belle_sip_uri_set_user(belle_sip_uri_t* uri,const char*user) ;
/**
* Sets the value of the user parameter.
*
*/
BELLESIP_EXPORT void belle_sip_uri_set_user_param(belle_sip_uri_t* uri,const char*userParam) ;
/**
* Sets the user password associated with the user of SipURI.
*
*/
BELLESIP_EXPORT void belle_sip_uri_set_user_password(belle_sip_uri_t* uri,const char*userPassword) ;
/**
* This method returns the URI as a string.
*
*/
BELLESIP_EXPORT char* belle_sip_uri_to_string(const belle_sip_uri_t* uri) ;
belle_sip_error_code belle_sip_uri_marshal(const belle_sip_uri_t* uri, char* buff, size_t buff_size, size_t *offset);
#define BELLE_SIP_URI(obj) BELLE_SIP_CAST(obj,belle_sip_uri_t)
/**define URI equality as using comparison rules from RFC3261 section 19.1.4
* @param belle_sip_uri_t* uri_a
* @param belle_sip_uri_t* uri_a
* @return 0 if not matched.
*
* */
BELLESIP_EXPORT int belle_sip_uri_equals(const belle_sip_uri_t* uri_a,const belle_sip_uri_t* uri_b);
/**define URI equality as belle_sip_uri_equals but allows URI omitting for the port
* @param belle_sip_uri_t* uri_a
* @param belle_sip_uri_t* uri_a
* @return 0 if not matched.
*
* */
BELLESIP_EXPORT int belle_sip_uri_equals_with_uri_omitting(const belle_sip_uri_t* uri_a,const belle_sip_uri_t* uri_b);
/**
* returns 0 if uri does follows components requirement for being a request uri
* */
BELLESIP_EXPORT int belle_sip_uri_check_components_from_request_uri(const belle_sip_uri_t* uri);
/**
* returns 0 if uri does follows components requirement for a given method/header
*/
BELLESIP_EXPORT int belle_sip_uri_check_components_from_context(const belle_sip_uri_t* uri,const char* method,const char* header_name);
BELLE_SIP_END_DECLS
#ifndef BELLE_SIP_USE_STL
#define BELLE_SIP_USE_STL 1
#endif
#if __cplusplus >= 201103L && BELLE_SIP_USE_STL
#include
inline std::ostream&
operator<<( std::ostream& __os, const belle_sip_uri_t* uri)
{
char* uri_as_string = belle_sip_uri_to_string(uri);
__os << uri_as_string;
belle_sip_free(uri_as_string);
return __os;
}
namespace std {
template <> struct hash {
size_t operator()(const belle_sip_uri_t *x ) const {
hash H;
size_t h=0;
if (belle_sip_uri_get_user(x))
h = H(belle_sip_uri_get_user(x));
if (belle_sip_uri_get_host(x))
h ^=H(belle_sip_uri_get_host(x));
if (belle_sip_uri_get_port(x)>0) {
std::hash H2;
h ^=H2(belle_sip_uri_get_port(x));
}
if (belle_sip_uri_get_transport_param(x)) {
h ^=H(belle_sip_uri_get_transport_param(x));
}
if (belle_sip_uri_is_secure(x))
h+=1;
return h;
}
};
template <> struct equal_to {
bool operator()(const belle_sip_uri_t* lhs, const belle_sip_uri_t* rhs) const {
return belle_sip_uri_equals(lhs,rhs);
}
};
}
#endif
#endif /*BELLE_SIP_URI_H_*/
belle-sip-5.2.0+dfsg/include/belle-sip/sipstack.h 0000664 0000000 0000000 00000026640 14346131365 0021620 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef belle_sip_stack_h
#define belle_sip_stack_h
struct belle_sip_timer_config{
int T1;
int T2;
int T3;
int T4;
};
typedef struct belle_sip_timer_config belle_sip_timer_config_t;
typedef struct belle_sip_digest_authentication_policy belle_sip_digest_authentication_policy_t;
BELLE_SIP_BEGIN_DECLS
BELLESIP_EXPORT belle_sip_digest_authentication_policy_t * belle_sip_digest_authentication_policy_new(void);
BELLESIP_EXPORT unsigned char belle_sip_digest_authentication_policy_get_allow_md5(const belle_sip_digest_authentication_policy_t *obj);
BELLESIP_EXPORT void belle_sip_digest_authentication_policy_set_allow_md5(belle_sip_digest_authentication_policy_t *obj, unsigned char value);
BELLESIP_EXPORT unsigned char belle_sip_digest_authentication_policy_get_allow_no_qop(const belle_sip_digest_authentication_policy_t *obj);
BELLESIP_EXPORT void belle_sip_digest_authentication_policy_set_allow_no_qop(belle_sip_digest_authentication_policy_t *obj, unsigned char value);
/**
* This only affects the resolution of SIP URI in absence of port number, and in absence of SRV record for the SIP domain. The well known ports (udp/tcp and tls/dtls) are static.
* @param well known port value
**/
BELLESIP_EXPORT void belle_sip_stack_set_well_known_port (int value);
BELLESIP_EXPORT void belle_sip_stack_set_well_known_port_tls (int value);
BELLESIP_EXPORT int belle_sip_stack_get_well_known_port (void);
BELLESIP_EXPORT int belle_sip_stack_get_well_known_port_tls (void);
BELLESIP_EXPORT belle_sip_stack_t * belle_sip_stack_new(const char *properties);
BELLESIP_EXPORT belle_sip_listening_point_t *belle_sip_stack_create_listening_point(belle_sip_stack_t *s, const char *ipaddress, int port, const char *transport);
BELLESIP_EXPORT void belle_sip_stack_delete_listening_point(belle_sip_stack_t *s, belle_sip_listening_point_t *lp);
BELLESIP_EXPORT belle_sip_provider_t *belle_sip_stack_create_provider(belle_sip_stack_t *s, belle_sip_listening_point_t *lp);
BELLESIP_EXPORT belle_http_provider_t * belle_sip_stack_create_http_provider(belle_sip_stack_t *s, const char *bind_ip);
#define BELLE_SIP_HTTP_TRANSPORT_TCP 0x01
#define BELLE_SIP_HTTP_TRANSPORT_TLS 0x02
/**
* Create a HTTP provider attached to a given stack enabling specific transports
* @param[in] s The stack to attach the transport
* @param[in] bind_ip
* @param[in] transports a mask of authorized transports for this provider, availables are BELLE_SIP_HTTP_TRANSPORT_TCP and BELLE_SIP_HTTP_TRANSPORT_TLS
*
* @return The HTTP provider
*
*/
BELLESIP_EXPORT belle_http_provider_t * belle_sip_stack_create_http_provider_with_transports(belle_sip_stack_t *s, const char *bind_ip, const uint8_t transports);
BELLESIP_EXPORT belle_sip_main_loop_t* belle_sip_stack_get_main_loop(belle_sip_stack_t *stack);
BELLESIP_EXPORT void belle_sip_stack_main(belle_sip_stack_t *stack);
BELLESIP_EXPORT void belle_sip_stack_sleep(belle_sip_stack_t *stack, unsigned int milliseconds);
/*the transport timeout is typically the maximum time given for making a connection*/
BELLESIP_EXPORT void belle_sip_stack_set_transport_timeout(belle_sip_stack_t *stack, int timeout_ms);
BELLESIP_EXPORT int belle_sip_stack_get_transport_timeout(const belle_sip_stack_t *stack);
BELLESIP_EXPORT int belle_sip_stack_get_dns_timeout(const belle_sip_stack_t *stack);
BELLESIP_EXPORT void belle_sip_stack_set_dns_timeout(belle_sip_stack_t *stack, int timeout);
BELLESIP_EXPORT unsigned char belle_sip_stack_dns_srv_enabled(const belle_sip_stack_t *stack);
BELLESIP_EXPORT void belle_sip_stack_enable_dns_srv(belle_sip_stack_t *stack, unsigned char enable);
BELLESIP_EXPORT unsigned char belle_sip_stack_dns_search_enabled(const belle_sip_stack_t *stack);
BELLESIP_EXPORT void belle_sip_stack_enable_dns_search(belle_sip_stack_t *stack, unsigned char enable);
/**
* Override system's DNS servers used for DNS resolving by app-supplied list of dns servers.
* @param stack the stack
* @param servers a list of char*. It is copied internally.
**/
BELLESIP_EXPORT void belle_sip_stack_set_dns_servers(belle_sip_stack_t *stack, const belle_sip_list_t *servers);
/**
* Get the additional DNS hosts file.
* @return The path to the additional DNS hosts file.
**/
BELLESIP_EXPORT const char * belle_sip_stack_get_dns_user_hosts_file(const belle_sip_stack_t *stack);
/**
* Can be used to load an additional DNS hosts file for tests.
* @param stack
* @param hosts_file The path to the additional DNS hosts file to load.
**/
BELLESIP_EXPORT void belle_sip_stack_set_dns_user_hosts_file(belle_sip_stack_t *stack, const char *hosts_file);
/**
* Get the overriding DNS resolv.conf file.
* @return The path to the overriding DNS resolv.conf file.
**/
BELLESIP_EXPORT const char * belle_sip_stack_get_dns_resolv_conf_file(const belle_sip_stack_t *stack);
/**
* Can be used to load an overriding DNS resolv.conf file for tests.
* @param stack
* @param hosts_file The path to the overriding DNS resolv.conf file to load.
**/
BELLESIP_EXPORT void belle_sip_stack_set_dns_resolv_conf_file(belle_sip_stack_t *stack, const char *hosts_file);
/**
* Returns the time interval in seconds after which a connection must be closed when inactive.
**/
BELLESIP_EXPORT int belle_sip_stack_get_inactive_transport_timeout(const belle_sip_stack_t *stack);
/**
* Sets the time interval in seconds after which a connection must be closed when inactive.
* By inactive, it is meant that the connection hasn't been used to send or recv data.
**/
BELLESIP_EXPORT void belle_sip_stack_set_inactive_transport_timeout(belle_sip_stack_t *stack, int seconds);
/**
* Set the time interval in seconds after which a connection is considered to be unreliable because
* no data was received over it.
* The special value 0 means that a connection will never be considered as unreliable.
* See belle_sip_provider_clean_unreliable_channels().
*/
BELLESIP_EXPORT void belle_sip_stack_set_unreliable_connection_timeout(belle_sip_stack_t *stack, int seconds);
/**
* Get the time interval in seconds after which a connection is considered to be unreliable because
* no data was received over it.
* See belle_sip_provider_clean_unreliable_channels().
*/
BELLESIP_EXPORT int belle_sip_stack_get_unreliable_connection_timeout(const belle_sip_stack_t *stack);
/**
* Set the default dscp value to be used for all SIP sockets created and used in the stack.
**/
BELLESIP_EXPORT void belle_sip_stack_set_default_dscp(belle_sip_stack_t *stack, int dscp);
/**
* Get the default dscp value to be used for all SIP sockets created and used in the stack.
**/
BELLESIP_EXPORT int belle_sip_stack_get_default_dscp(belle_sip_stack_t *stack);
/**
* Returns TRUE if TLS support has been compiled into, FALSE otherwise.
**/
BELLESIP_EXPORT int belle_sip_stack_tls_available(belle_sip_stack_t *stack);
/**
* Returns TRUE if the content encoding support has been compiled in, FALSE otherwise.
**/
BELLESIP_EXPORT int belle_sip_stack_content_encoding_available(belle_sip_stack_t *stack, const char *content_encoding);
/*
* returns timer config for this stack
**/
BELLESIP_EXPORT const belle_sip_timer_config_t *belle_sip_stack_get_timer_config(const belle_sip_stack_t *stack);
/*
*
* set sip timer config to be used for this stack
**/
BELLESIP_EXPORT void belle_sip_stack_set_timer_config(belle_sip_stack_t *stack, const belle_sip_timer_config_t *timer_config);
BELLESIP_EXPORT void belle_sip_stack_set_http_proxy_host(belle_sip_stack_t *stack, const char* proxy_addr);
BELLESIP_EXPORT void belle_sip_stack_set_http_proxy_port(belle_sip_stack_t *stack, int port);
BELLESIP_EXPORT const char *belle_sip_stack_get_http_proxy_host(const belle_sip_stack_t *stack);
BELLESIP_EXPORT int belle_sip_stack_get_http_proxy_port(const belle_sip_stack_t *stack);
/**
* Enable the reconnection to the primary server when it is up again as soon as possible.
* When activated, instead of closing if the current server is not in the refreshed priority ordered servers' list
* the bellesip channel will close if the current server is not the first server of this list.
* As a result, it will try to reconnect to the server with the highest priority if it is not the case when records
* are expiring.
* @param prov
* @param enabled 0 to disable
**/
BELLESIP_EXPORT void belle_sip_stack_enable_reconnect_to_primary_asap(belle_sip_stack_t *stack, int enabled);
/**
* Returns if the reconnection to the primary server is enabled.
* @param prov
* @see belle_sip_provider_enable_reconnect_to_primary_asap()
**/
BELLESIP_EXPORT int belle_sip_stack_reconnect_to_primary_asap_enabled(const belle_sip_stack_t *stack);
/**
* Configure security policies for digest authentication.
*/
BELLESIP_EXPORT void belle_sip_stack_set_digest_authentication_policy(belle_sip_stack_t *stack, belle_sip_digest_authentication_policy_t *policy);
BELLESIP_EXPORT const belle_sip_digest_authentication_policy_t *belle_sip_stack_get_digest_authentication_policy(const belle_sip_stack_t *stack);
/*
* The following functions are for testing (non regression tests) ONLY
*/
/**
* Can be used to simulate network transmission delays, for tests.
**/
BELLESIP_EXPORT void belle_sip_stack_set_tx_delay(belle_sip_stack_t *stack, int delay_ms);
/**
* Can be used to simulate network sending error, for tests.
* @param stack
* @param send_error if <0, will cause channel error to be reported
**/
BELLESIP_EXPORT void belle_sip_stack_set_send_error(belle_sip_stack_t *stack, int send_error);
/**
* Can be used to simulate network transmission delays, for tests.
**/
BELLESIP_EXPORT void belle_sip_stack_set_resolver_tx_delay(belle_sip_stack_t *stack, int delay_ms);
/**
* Can be used to simulate network sending error, for tests.
* @param stack
* @param send_error if <0, will cause the resolver to fail with this error code.
**/
BELLESIP_EXPORT void belle_sip_stack_set_resolver_send_error(belle_sip_stack_t *stack, int send_error);
/**
* Requests TCP/TLS client connection to bind a on specific port. This is for test ONLY.
**/
BELLESIP_EXPORT void belle_sip_stack_set_client_bind_port(belle_sip_stack_t *stack, int port);
#define BELLE_SIP_DNS_APPLE_DNS_SERVICE 0x01
#define BELLE_SIP_DNS_DNS_C 0x02
/**
* Set the dns engine to use.
* @param dns_engine Must be one of BELLE_SIP_DNS_APPLE_DNS_SERVICE or BELLE_SIP_DNS_DNS_C
**/
BELLESIP_EXPORT void belle_sip_stack_set_dns_engine(belle_sip_stack_t *stack, unsigned char dns_engine);
/**
* Get the dns engine used
* @return BELLE_SIP_DNS_APPLE_DNS_SERVICE or BELLE_SIP_DNS_DNS_C
**/
BELLESIP_EXPORT unsigned char belle_sip_stack_get_dns_engine(const belle_sip_stack_t *stack);
/**
* Requests the stack to simulate a router that doesn't respond to SRV requests. This is for test ONLY.
**/
BELLESIP_EXPORT void belle_sip_stack_simulate_non_working_srv(belle_sip_stack_t *stack, int yesno);
/*
* End of test functions.
*/
BELLE_SIP_END_DECLS
#endif
belle-sip-5.2.0+dfsg/include/belle-sip/transaction.h 0000664 0000000 0000000 00000012271 14346131365 0022317 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef BELLE_SIP_TRANSACTION_H
#define BELLE_SIP_TRANSACTION_H
typedef enum belle_sip_transaction_state{
BELLE_SIP_TRANSACTION_INIT,
BELLE_SIP_TRANSACTION_CALLING,
BELLE_SIP_TRANSACTION_COMPLETED,
BELLE_SIP_TRANSACTION_CONFIRMED,
BELLE_SIP_TRANSACTION_ACCEPTED, /* BELLE_SIP_TRANSACTION_INIT,
*
BELLE_SIP_TRANSACTION_CALLING,
*
BELLE_SIP_TRANSACTION_PROCEEDING,
*
BELLE_SIP_TRANSACTION_TRYING,
* @param state
* @return 0 if not transient
* */
BELLESIP_EXPORT int belle_sip_transaction_state_is_transient(const belle_sip_transaction_state_t state);
BELLESIP_EXPORT void *belle_sip_transaction_get_application_data(const belle_sip_transaction_t *t);
BELLESIP_EXPORT void belle_sip_transaction_set_application_data(belle_sip_transaction_t *t, void *data);
BELLESIP_EXPORT const char *belle_sip_transaction_get_branch_id(const belle_sip_transaction_t *t);
BELLESIP_EXPORT belle_sip_transaction_state_t belle_sip_transaction_get_state(const belle_sip_transaction_t *t);
BELLESIP_EXPORT const char *belle_sip_transaction_get_method(const belle_sip_transaction_t *t);
BELLESIP_EXPORT void belle_sip_transaction_terminate(belle_sip_transaction_t *t);
BELLESIP_EXPORT belle_sip_request_t *belle_sip_transaction_get_request(const belle_sip_transaction_t *t);
BELLESIP_EXPORT belle_sip_response_t *belle_sip_transaction_get_response(const belle_sip_transaction_t *t);
BELLESIP_EXPORT belle_sip_dialog_t* belle_sip_transaction_get_dialog(const belle_sip_transaction_t *t);
BELLESIP_EXPORT void belle_sip_server_transaction_send_response(belle_sip_server_transaction_t *t, belle_sip_response_t *resp);
BELLESIP_EXPORT belle_sip_request_t * belle_sip_client_transaction_create_cancel(belle_sip_client_transaction_t *t);
BELLESIP_EXPORT int belle_sip_client_transaction_send_request(belle_sip_client_transaction_t *t);
/*
* Same as #belle_sip_client_transaction_send_request but with a predefined route.
* @param t belle_sip_client_transaction_t
* @param outbound_proxy uri use to directly send the request, useful for outbound proxy.
* */
BELLESIP_EXPORT int belle_sip_client_transaction_send_request_to(belle_sip_client_transaction_t *t,belle_sip_uri_t* outbound_proxy);
BELLESIP_EXPORT belle_sip_uri_t *belle_sip_client_transaction_get_route(belle_sip_client_transaction_t *t);
/**
* Creates an a sip refresher for transaction like REGISTER/SUBSCRIBE or INVITE which could be refreshed.
* Transaction must in be in stated BELLE_SIP_TRANSACTION_COMPLETED. Refresher is created and started. A ref is taken on object transaction
* */
BELLESIP_EXPORT belle_sip_refresher_t* belle_sip_client_transaction_create_refresher(belle_sip_client_transaction_t *t);
/**
* Create an authenticated request based on an existing terminated transaction.
*
This function, update cseq, put route set and try to fill authorization headers. Initial request is not cloned.
* @param transaction . must be in state completed
* @param auth_infos if auth infos cannot be added for an authenticate header,
* @param realm optional - If an outbound proxy realm is used, digestion authentication can be optimized.
* a newly allocated belle_sip_auth_info_t object is added to this list. These object contains useful information like realm and username. May be NULL
* */
BELLESIP_EXPORT belle_sip_request_t* belle_sip_client_transaction_create_authenticated_request(belle_sip_client_transaction_t *t,belle_sip_list_t** auth_infos,const char* realm);
/**
* For transactions over unreliable transports, stop retransmissions. This avoids for example to keep sending INVITE retransmissions of a call that has just been terminated, while
* keeping the transaction alive in order to eventually let a response being handled, so that the transaction can be cancelled properly.
**/
BELLESIP_EXPORT void belle_sip_client_transaction_stop_retransmissions(belle_sip_client_transaction_t *t);
#define BELLE_SIP_TRANSACTION(t) BELLE_SIP_CAST(t,belle_sip_transaction_t)
#define BELLE_SIP_SERVER_TRANSACTION(t) BELLE_SIP_CAST(t,belle_sip_server_transaction_t)
#define BELLE_SIP_CLIENT_TRANSACTION(t) BELLE_SIP_CAST(t,belle_sip_client_transaction_t)
BELLE_SIP_END_DECLS
#endif
belle-sip-5.2.0+dfsg/include/belle-sip/types.h 0000664 0000000 0000000 00000022272 14346131365 0021140 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef BELLE_SIP_TYPES_H
#define BELLE_SIP_TYPES_H
#include "belle-sip/defs.h"
#include "belle-sip/object.h"
#include "belle-sip/dict.h"
#ifndef BELLESIP_DEPRECATED
#if defined(_MSC_VER)
#define BELLESIP_DEPRECATED __declspec(deprecated)
#else
#define BELLESIP_DEPRECATED __attribute__ ((deprecated))
#endif
#endif
/**
* This enum declares all object types used in belle-sip (see belle_sip_object_t)
**/
BELLE_SIP_DECLARE_TYPES_BEGIN(belle_sip,1)
BELLE_SIP_TYPE_ID(belle_sip_stack_t),
BELLE_SIP_TYPE_ID(belle_sip_hop_t),
BELLE_SIP_TYPE_ID(belle_sip_object_pool_t),
BELLE_SIP_TYPE_ID(belle_sip_listening_point_t),
BELLE_SIP_TYPE_ID(belle_sip_datagram_listening_point_t),
BELLE_SIP_TYPE_ID(belle_sip_udp_listening_point_t),
BELLE_SIP_TYPE_ID(belle_sip_stream_listening_point_t),
BELLE_SIP_TYPE_ID(belle_sip_tls_listening_point_t),
BELLE_SIP_TYPE_ID(belle_sip_tunnel_listening_point_t),
BELLE_SIP_TYPE_ID(belle_sip_channel_t),
BELLE_SIP_TYPE_ID(belle_sip_udp_channel_t),
BELLE_SIP_TYPE_ID(belle_sip_stream_channel_t),
BELLE_SIP_TYPE_ID(belle_sip_tls_channel_t),
BELLE_SIP_TYPE_ID(belle_sip_tunnel_channel_t),
BELLE_SIP_TYPE_ID(belle_sip_provider_t),
BELLE_SIP_TYPE_ID(belle_sip_main_loop_t),
BELLE_SIP_TYPE_ID(belle_sip_source_t),
BELLE_SIP_TYPE_ID(belle_sip_mdns_source_t),
BELLE_SIP_TYPE_ID(belle_sip_resolver_context_t),
BELLE_SIP_TYPE_ID(belle_sip_transaction_t),
BELLE_SIP_TYPE_ID(belle_sip_server_transaction_t),
BELLE_SIP_TYPE_ID(belle_sip_client_transaction_t),
BELLE_SIP_TYPE_ID(belle_sip_ict_t),
BELLE_SIP_TYPE_ID(belle_sip_nict_t),
BELLE_SIP_TYPE_ID(belle_sip_ist_t),
BELLE_SIP_TYPE_ID(belle_sip_nist_t),
BELLE_SIP_TYPE_ID(belle_sip_dialog_t),
BELLE_SIP_TYPE_ID(belle_sip_header_address_t),
BELLE_SIP_TYPE_ID(belle_sip_header_contact_t),
BELLE_SIP_TYPE_ID(belle_sip_header_from_t),
BELLE_SIP_TYPE_ID(belle_sip_header_to_t),
BELLE_SIP_TYPE_ID(belle_sip_header_via_t),
BELLE_SIP_TYPE_ID(belle_sip_header_diversion_t),
BELLE_SIP_TYPE_ID(belle_sip_uri_t),
BELLE_SIP_TYPE_ID(belle_sip_message_t),
BELLE_SIP_TYPE_ID(belle_sip_request_t),
BELLE_SIP_TYPE_ID(belle_sip_response_t),
BELLE_SIP_TYPE_ID(belle_sip_object_t),
BELLE_SIP_TYPE_ID(belle_sip_parameters_t),
BELLE_SIP_TYPE_ID(belle_sip_header_call_id_t),
BELLE_SIP_TYPE_ID(belle_sip_header_cseq_t),
BELLE_SIP_TYPE_ID(belle_sip_header_content_type_t),
BELLE_SIP_TYPE_ID(belle_sip_header_session_expires_t),
BELLE_SIP_TYPE_ID(belle_sip_header_route_t),
BELLE_SIP_TYPE_ID(belle_sip_header_record_route_t),
BELLE_SIP_TYPE_ID(belle_sip_header_user_agent_t),
BELLE_SIP_TYPE_ID(belle_sip_header_content_length_t),
BELLE_SIP_TYPE_ID(belle_sip_header_t),
BELLE_SIP_TYPE_ID(belle_sip_header_extension_t),
BELLE_SIP_TYPE_ID(belle_sip_header_authorization_t),
BELLE_SIP_TYPE_ID(belle_sip_header_proxy_authorization_t),
BELLE_SIP_TYPE_ID(belle_sip_header_www_authenticate_t),
BELLE_SIP_TYPE_ID(belle_sip_header_proxy_authenticate_t),
BELLE_SIP_TYPE_ID(belle_sip_header_max_forwards_t),
BELLE_SIP_TYPE_ID(belle_sip_header_expires_t),
BELLE_SIP_TYPE_ID(belle_sip_header_allow_t),
BELLE_SIP_TYPE_ID(belle_sdp_attribute_t),
BELLE_SIP_TYPE_ID(belle_sdp_bandwidth_t),
BELLE_SIP_TYPE_ID(belle_sdp_connection_t),
BELLE_SIP_TYPE_ID(belle_sdp_email_t),
BELLE_SIP_TYPE_ID(belle_sdp_info_t),
BELLE_SIP_TYPE_ID(belle_sdp_key_t),
BELLE_SIP_TYPE_ID(belle_sdp_media_t),
BELLE_SIP_TYPE_ID(belle_sdp_media_description_t),
BELLE_SIP_TYPE_ID(belle_sdp_origin_t),
BELLE_SIP_TYPE_ID(belle_sdp_phone_t),
BELLE_SIP_TYPE_ID(belle_sdp_raw_attribute_t),
BELLE_SIP_TYPE_ID(belle_sdp_repeate_time_t),
BELLE_SIP_TYPE_ID(belle_sdp_rtcp_fb_attribute_t),
BELLE_SIP_TYPE_ID(belle_sdp_rtcp_xr_attribute_t),
BELLE_SIP_TYPE_ID(belle_sdp_label_attribute_t),
BELLE_SIP_TYPE_ID(belle_sdp_content_attribute_t),
BELLE_SIP_TYPE_ID(belle_sdp_csup_attribute_t),
BELLE_SIP_TYPE_ID(belle_sdp_creq_attribute_t),
BELLE_SIP_TYPE_ID(belle_sdp_tcap_attribute_t),
BELLE_SIP_TYPE_ID(belle_sdp_acap_attribute_t),
BELLE_SIP_TYPE_ID(belle_sdp_acfg_attribute_t),
BELLE_SIP_TYPE_ID(belle_sdp_pcfg_attribute_t),
BELLE_SIP_TYPE_ID(belle_sdp_session_description_t),
BELLE_SIP_TYPE_ID(belle_sdp_session_name_t),
BELLE_SIP_TYPE_ID(belle_sdp_time_t),
BELLE_SIP_TYPE_ID(belle_sdp_time_description_t),
BELLE_SIP_TYPE_ID(belle_sdp_uri_t),
BELLE_SIP_TYPE_ID(belle_sdp_version_t),
BELLE_SIP_TYPE_ID(belle_sdp_base_description_t),
BELLE_SIP_TYPE_ID(belle_sdp_mime_parameter_t),
BELLE_SIP_TYPE_ID(belle_sip_callbacks_t),
BELLE_SIP_TYPE_ID(belle_sip_refresher_t),
BELLE_SIP_TYPE_ID(belle_sip_header_subscription_state_t),
BELLE_SIP_TYPE_ID(belle_sip_header_service_route_t),
BELLE_SIP_TYPE_ID(belle_sip_header_refer_to_t),
BELLE_SIP_TYPE_ID(belle_sip_header_referred_by_t),
BELLE_SIP_TYPE_ID(belle_sip_header_replaces_t),
BELLE_SIP_TYPE_ID(belle_sip_header_date_t),
BELLE_SIP_TYPE_ID(belle_sip_header_p_preferred_identity_t),
BELLE_SIP_TYPE_ID(belle_sip_header_privacy_t),
BELLE_SIP_TYPE_ID(belle_sip_certificates_chain_t),
BELLE_SIP_TYPE_ID(belle_sip_signing_key_t),
BELLE_SIP_TYPE_ID(belle_sip_dns_srv_t),
BELLE_SIP_TYPE_ID(belle_sip_simple_resolver_context_t),
BELLE_SIP_TYPE_ID(belle_sip_combined_resolver_context_t),
BELLE_SIP_TYPE_ID(belle_sip_dict_t),
BELLE_SIP_TYPE_ID(belle_sip_dual_resolver_context_t),
BELLE_SIP_TYPE_ID(belle_http_provider_t),
BELLE_SIP_TYPE_ID(belle_http_request_t),
BELLE_SIP_TYPE_ID(belle_http_response_t),
BELLE_SIP_TYPE_ID(belle_http_channel_context_t),
BELLE_SIP_TYPE_ID(belle_generic_uri_t),
BELLE_SIP_TYPE_ID(belle_http_callbacks_t),
BELLE_SIP_TYPE_ID(belle_tls_crypto_config_t),
BELLE_SIP_TYPE_ID(belle_http_header_authorization_t),
BELLE_SIP_TYPE_ID(belle_sip_body_handler_t),
BELLE_SIP_TYPE_ID(belle_sip_memory_body_handler_t),
BELLE_SIP_TYPE_ID(belle_sip_user_body_handler_t),
BELLE_SIP_TYPE_ID(belle_sip_file_body_handler_t),
BELLE_SIP_TYPE_ID(belle_sip_multipart_body_handler_t),
BELLE_SIP_TYPE_ID(belle_sip_header_event_t),
BELLE_SIP_TYPE_ID(belle_sip_header_supported_t),
BELLE_SIP_TYPE_ID(belle_sip_header_require_t),
BELLE_SIP_TYPE_ID(belle_sip_header_content_disposition_t),
BELLE_SIP_TYPE_ID(belle_sip_header_accept_t),
BELLE_SIP_TYPE_ID(belle_sip_header_reason_t),
BELLE_SIP_TYPE_ID(belle_sip_header_authentication_info_t),
BELLE_SIP_TYPE_ID(belle_sip_mdns_register_t),
BELLE_SIP_TYPE_ID(belle_sip_resolver_results_t),
BELLE_SIP_TYPE_ID(belle_sip_cpp_object_t),
BELLE_SIP_TYPE_ID(belle_sip_header_retry_after_t),
BELLE_SIP_TYPE_ID(belle_sip_digest_authentication_policy_t)
BELLE_SIP_DECLARE_TYPES_END
enum belle_sip_interface_ids{
belle_sip_interface_id_first=1,
BELLE_SIP_INTERFACE_ID(belle_sip_channel_listener_t),
BELLE_SIP_INTERFACE_ID(belle_sip_listener_t),
BELLE_SIP_INTERFACE_ID(belle_http_request_listener_t)
};
/*these types are declared here because they are widely used in many headers included after*/
typedef struct belle_sip_listening_point belle_sip_listening_point_t;
typedef struct belle_sip_tls_listening_point belle_sip_tls_listening_point_t;
typedef struct belle_sip_stack belle_sip_stack_t;
typedef struct belle_sip_provider belle_sip_provider_t;
typedef struct belle_http_provider belle_http_provider_t;
typedef struct belle_sip_dialog belle_sip_dialog_t;
typedef struct belle_sip_transaction belle_sip_transaction_t;
typedef struct belle_sip_server_transaction belle_sip_server_transaction_t;
typedef struct belle_sip_client_transaction belle_sip_client_transaction_t;
typedef struct _belle_sip_message belle_sip_message_t;
typedef struct _belle_sip_request belle_sip_request_t;
typedef struct _belle_sip_response belle_sip_response_t;
typedef struct belle_http_request belle_http_request_t;
typedef struct belle_http_response belle_http_response_t;
typedef struct belle_sip_hop belle_sip_hop_t;
typedef struct _belle_generic_uri belle_generic_uri_t;
typedef struct _belle_sip_uri belle_sip_uri_t;
typedef struct _belle_sip_parameters belle_sip_parameters_t;
typedef struct belle_sip_param_pair belle_sip_param_pair_t;
typedef struct _belle_sip_header belle_sip_header_t;
typedef struct belle_tls_crypto_config belle_tls_crypto_config_t;
typedef struct belle_tls_crypto_config belle_tls_verify_policy_t; /* belle_tls_verify_policy_t is deprecated, just for backward compatibility */
typedef struct belle_sip_body_handler belle_sip_body_handler_t;
typedef struct belle_sip_memory_body_handler belle_sip_memory_body_handler_t;
typedef struct belle_sip_user_body_handler belle_sip_user_body_handler_t;
typedef struct belle_sip_file_body_handler belle_sip_file_body_handler_t;
typedef struct belle_sip_multipart_body_handler belle_sip_multipart_body_handler_t;
#endif
belle-sip-5.2.0+dfsg/include/belle-sip/utils.h 0000664 0000000 0000000 00000011425 14346131365 0021132 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef BELLE_SIP_UTILS_H
#define BELLE_SIP_UTILS_H
#include
#include
#include
#include
#include "belle-sip/defs.h"
#include "bctoolbox/logging.h"
#include "bctoolbox/vconnect.h"
#define BELLE_SIP_LOG_DOMAIN "belle-sip"
BELLE_SIP_BEGIN_DECLS
#define belle_sip_malloc bctbx_malloc
#define belle_sip_malloc0 bctbx_malloc0
#define belle_sip_realloc bctbx_realloc
#define belle_sip_free bctbx_free
#define belle_sip_strdup bctbx_strdup
BELLE_SIP_END_DECLS
/***************/
/* logging api */
/***************/
#define BELLE_SIP_LOG_FATAL BCTBX_LOG_FATAL
#define BELLE_SIP_LOG_ERROR BCTBX_LOG_ERROR
#define BELLE_SIP_LOG_WARNING BCTBX_LOG_WARNING
#define BELLE_SIP_LOG_MESSAGE BCTBX_LOG_MESSAGE
#define BELLE_SIP_LOG_DEBUG BCTBX_LOG_DEBUG
#define BELLE_SIP_LOG_END BCTBX_LOG_END
#define belle_sip_log_level BctbxLogLevel
#define belle_sip_log_function_t BctbxLogFunc
typedef enum {
BELLE_SIP_NOT_IMPLEMENTED = -2,
BELLE_SIP_BUFFER_OVERFLOW = -1,
BELLE_SIP_OK = 0
} belle_sip_error_code;
#ifdef __GNUC__
#define BELLE_SIP_CHECK_FORMAT_ARGS(m,n) __attribute__((format(printf,m,n)))
#else
#define BELLE_SIP_CHECK_FORMAT_ARGS(m,n)
#endif
BELLE_SIP_BEGIN_DECLS
#define belle_sip_log_level_enabled(level) bctbx_log_level_enabled(BELLE_SIP_LOG_DOMAIN,level)
#ifdef BELLE_SIP_DEBUG_MODE
#define belle_sip_deb(...) bctbx_debug(...)
#else
#define belle_sip_debug(...)
#endif
#ifdef BELLE_SIP_NOMESSAGE_MODE
#define belle_sip_log(...)
#define belle_sip_message(...)
#define belle_sip_warning(...)
#else
#define belle_sip_log bctbx_log
#define belle_sip_message bctbx_message
#define belle_sip_warning bctbx_warning
#define belle_sip_error bctbx_error
#define belle_sip_fatal bctbx_fatal
#define belle_sip_logv bctbx_logv
#endif
BELLESIP_EXPORT void belle_sip_set_log_handler(belle_sip_log_function_t func);
#define belle_sip_strdup_printf bctbx_strdup_printf
#define belle_sip_strcat_vprintf bctbx_strcat_vprintf
#define belle_sip_strcat_printf bctbx_strcat_printf
BELLESIP_EXPORT belle_sip_error_code BELLE_SIP_CHECK_FORMAT_ARGS(4,5) belle_sip_snprintf(char *buff, size_t buff_size, size_t *offset, const char *fmt, ...);
BELLESIP_EXPORT belle_sip_error_code belle_sip_snprintf_valist(char *buff, size_t buff_size, size_t *offset, const char *fmt, va_list args);
#define belle_sip_set_log_level(level) bctbx_set_log_level(BELLE_SIP_LOG_DOMAIN,level);
BELLESIP_EXPORT char * belle_sip_random_token(char *ret, size_t size);
BELLESIP_EXPORT char * belle_sip_random_token_with_charset(char *ret, size_t size, const char * charset, size_t charset_length);
BELLESIP_EXPORT unsigned char * belle_sip_random_bytes(unsigned char *ret, size_t size);
BELLESIP_EXPORT uint32_t belle_sip_random(void);
BELLESIP_EXPORT char * belle_sip_octets_to_text(const unsigned char *hash, size_t hash_len, char *ret, size_t size);
BELLESIP_EXPORT char * belle_sip_create_tag(char *ret, size_t size);
BELLESIP_EXPORT const char* belle_sip_version_to_string(void);
/**
* Returns string without surrounding quotes if any, else just call belle_sip_strdup().
**/
BELLESIP_EXPORT char *belle_sip_unquote_strdup(const char *str);
BELLESIP_EXPORT uint64_t belle_sip_time_ms(void);
/** Connect API */
BELLESIP_EXPORT void belle_sip_set_socket_api(bctbx_vsocket_api_t* my_api);
#if defined(_WIN32)
#include
#include
typedef SOCKET belle_sip_socket_t;
typedef HANDLE belle_sip_fd_t;
#else
#include
#include
#include
typedef int belle_sip_socket_t;
typedef int belle_sip_fd_t;
#endif
typedef void (*belle_sip_background_task_end_callback_t)(void *);
BELLESIP_EXPORT unsigned long belle_sip_begin_background_task(const char *name, belle_sip_background_task_end_callback_t cb, void *data);
BELLESIP_EXPORT void belle_sip_end_background_task(unsigned long id);
BELLESIP_EXPORT char* belle_sip_uri_to_escaped_username(const char* buff);
BELLESIP_EXPORT char* belle_sip_username_unescape_unnecessary_characters(const char* buff);
BELLESIP_EXPORT char* belle_sip_to_unescaped_string(const char* buff);
BELLE_SIP_END_DECLS
#endif
belle-sip-5.2.0+dfsg/include/belle-sip/wakelock.h 0000664 0000000 0000000 00000002577 14346131365 0021602 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef WAKE_LOCK_H
#define WAKE_LOCK_H
#include
#include "belle-sip/defs.h"
BELLE_SIP_BEGIN_DECLS
/**
* Initialize the Android wake lock system inside Belle-SIP.
* This function must be called only once when the program starts.
* @param env A JNI environment
* @parma pm An android.os.PowerManager java object.
*/
BELLESIP_EXPORT void belle_sip_wake_lock_init(JNIEnv *env, jobject pm);
/**
* Uninit the the Android wake lock system. This function may be called
* while the program stopping.
* @param env A JNI environment.
*/
BELLESIP_EXPORT void belle_sip_wake_lock_uninit(JNIEnv *env);
BELLE_SIP_END_DECLS
#endif // WALE_LOCK_H
belle-sip-5.2.0+dfsg/src/ 0000775 0000000 0000000 00000000000 14346131365 0015106 5 ustar 00root root 0000000 0000000 belle-sip-5.2.0+dfsg/src/.DS_Store 0000664 0000000 0000000 00000020004 14346131365 0016565 0 ustar 00root root 0000000 0000000 Bud1 s p o r t s @ € @ € @ € @
t r a n s p o r t sbwspblob Ébplist00×
]ShowStatusBar[ShowPathbar[ShowToolbar[ShowTabView_ContainerShowSidebar\WindowBounds[ShowSidebar _{{121, 102}, {868, 564}} %1=I`myz{|}~™ š
t r a n s p o r t slsvCblob —bplist00Ø
IJ
L_viewOptionsVersion_showIconPreviewWcolumns_calculateAllSizesXtextSizeZsortColumn_useRelativeDatesXiconSize « "&+05:?DÔ
ZidentifierUwidthYascendingWvisibleTname9 Ô
WvisibleUwidthYascending#XubiquityÔ
! µ\dateModifiedÔ
%[dateCreatedÔ
'(
Tsizea Ô
,-
Tkinds Ô
12
Ulabeld Ô
67
WversionK Ô
;<
Xcomments, Ô
ACÈ^dateLastOpenedÔ
E YdateAdded#@( Tname #@0 . @ H \ e p ƒ Œ Ž › ¤ ¯ µ ¿ Ç Ì Ï Ð Ñ Ú â è ò ó õ ö ÿ "#$09>@ABKPRST]cefgpxz{|…Ž‘’“œŸ ¯¸ÂÃÄÅÎÓÔ M Ý
t r a n s p o r t slsvpblob ^bplist00Ø
EF
H_viewOptionsVersion_showIconPreviewWcolumns_calculateAllSizesXtextSizeZsortColumn_useRelativeDatesXiconSize Ù
#(-27
@ 9 Ô %
#@( Tname #@0 . @ H \ e p ƒ Œ Ž ¢ « º Æ Ë Ñ Ö Þ ã ð ù ')+,-68:;<EFHIKTUWXZcdfgirsuvx‚…†ˆ‘’“”¢£ I ¬
t r a n s p o r t svSrnlong E DSDB ` € @ € @ € @ ÈÔ$%µÔ
*, aÔ/
1d Ô
4
6 s Ô9
;K Ô
>
@ 9 Ô %
#@( Tname #@0 . @ H \ e p ƒ Œ Ž ¢ « º Æ Ë Ñ Ö Þ ã ð ù ')+,-68:;<EFHIKTUWXZcdfgirsuvx‚…†ˆ‘’“”¢£ I ¬
t r a n s p o r t svSrnlong belle-sip-5.2.0+dfsg/src/CMakeLists.txt 0000664 0000000 0000000 00000022041 14346131365 0017645 0 ustar 00root root 0000000 0000000 ############################################################################
# CMakeLists.txt
# Copyright (C) 2014 Belledonne Communications, Grenoble France
#
############################################################################
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
############################################################################
function(require_c99 target)
if(CMAKE_C_COMPILER_ID STREQUAL "QCC")
target_compile_options(${target} PRIVATE "-std=gnu99")
else()
if (CMAKE_VERSION VERSION_LESS "3.1")
if (CMAKE_C_COMPILER_ID STREQUAL "GNU")
target_compile_options(${target} PRIVATE "-std=gnu99")
endif()
else()
set_property(TARGET ${target} PROPERTY C_STANDARD 99)
set_property(TARGET ${target} PROPERTY C_STANDARD_REQUIRED TRUE)
endif()
endif()
endfunction()
set(PUBLIC_INCLUDE_DIRS
$
$
$
)
set(PRIVATE_INCLUDE_DIRS
${CMAKE_CURRENT_SOURCE_DIR}/antlr3c/include
${CMAKE_CURRENT_BINARY_DIR}/antlr3c
)
set(LIBS bctoolbox)
if(Threads_FOUND)
if(CMAKE_USE_PTHREADS_INIT AND NOT CMAKE_SYSTEM_NAME MATCHES "QNX" AND NOT ANDROID)
list(APPEND LIBS ${CMAKE_THREAD_LIBS_INIT})
endif()
endif()
if(HAVE_LIBDL)
list(APPEND LIBS dl)
endif()
if(HAVE_LIBRT)
list(APPEND LIBS rt)
endif()
if(HAVE_RESINIT)
list(APPEND LIBS resolv)
endif()
if(ZLIB_FOUND)
list(APPEND LIBS ${ZLIB_LIBRARIES})
endif()
if(DNSSD_FOUND)
list(APPEND LIBS ${DNSSD_LIBRARIES})
endif()
if(WIN32)
list(APPEND LIBS ws2_32)
endif()
list(APPEND LIBS belr)
set(SDP_GENERATED_SOURCE_FILES_C
grammars/belle_sdpLexer.c
grammars/belle_sdpLexer.h
grammars/belle_sdpParser.c
grammars/belle_sdpParser.h
)
set(SIP_MESSAGE_GENERATED_SOURCE_FILES_C
grammars/belle_sip_messageLexer.c
grammars/belle_sip_messageLexer.h
grammars/belle_sip_messageParser.c
grammars/belle_sip_messageParser.h
)
if(ENABLE_TUNNEL)
set(TUNNEL_SOURCE_FILES_C
transports/tunnel_listeningpoint.c
transports/tunnel_channel.c
)
set(TUNNEL_SOURCE_FILES_CXX
transports/tunnel_wrapper.cc
)
list(APPEND LIBS ${TUNNEL_LIBRARIES})
endif()
add_subdirectory(antlr3c)
set(BELLE_SIP_SOURCE_FILES_C
auth_event.c
auth_helper.c
belle_sip_dict.c
belle_sip_headers_impl.c
belle_sip_loop.c
belle_sip_mdns_register.c
belle_sip_object.c
belle_sip_parameters.c
belle_sip_uri_impl.c
belle_sip_utils.c
belle_sip_resolver.c
bodyhandler.c
channel.c
channel.h
clock_gettime.c
clock_gettime.h
dialog.c
dns/dns.c
dns/dns.h
generic-uri.c
http-listener.c
http-message.c
http-provider.c
ict.c
ist.c
listeningpoint.c
listeningpoint_internal.h
md5.c
md5.h
message.c
nict.c
nist.c
parserutils.h
port.c
port.h
provider.c
refresher.c
siplistener.c
sipstack.c
transaction.c
transports/stream_channel.c
transports/stream_channel.h
transports/stream_listeningpoint.c
transports/udp_channel.c
transports/udp_listeningpoint.c
transports/tls_listeningpoint.c
transports/tls_channel.c
${SDP_GENERATED_SOURCE_FILES_C}
${SIP_MESSAGE_GENERATED_SOURCE_FILES_C}
${TUNNEL_SOURCE_FILES_C}
)
add_definitions(
-DBCTBX_LOG_DOMAIN="belle-sip"
)
if(ANDROID)
list(APPEND BELLE_SIP_SOURCE_FILES_C wakelock.c)
endif()
set(BELLE_SIP_SOURCE_FILES_CXX
${TUNNEL_SOURCE_FILES_CXX}
object++.cc
cpp_utils.cc
#cpp_utils.hh
belle_sdp_impl.cc
#belle_sip_internal.h
sdp/parser.cc
#parser/sdp.hh
)
set(GRAMMAR_FILES
sdp/sdp_grammar
)
if(APPLE)
set(BELLE_SIP_SOURCE_FILES_OBJC
backgroundtask.mm
ios_check_version.m
)
endif()
bc_apply_compile_flags(BELLE_SIP_SOURCE_FILES_C STRICT_OPTIONS_CPP STRICT_OPTIONS_C)
bc_apply_compile_flags(BELLE_SIP_SOURCE_FILES_OBJC STRICT_OPTIONS_CPP STRICT_OPTIONS_OBJC)
if(BELLE_SIP_SOURCE_FILES_CXX)
set_source_files_properties(${BELLE_SIP_SOURCE_FILES_CXX} PROPERTIES LANGUAGE CXX)
bc_apply_compile_flags(BELLE_SIP_SOURCE_FILES_CXX STRICT_OPTIONS_CPP STRICT_OPTIONS_CXX)
endif()
if(MSVC)
string(CONCAT DNS_C_COMPILE_FLAGS
" /wd4267" # Disable "possible loss of data" warnings
" /wd4804" # Disable "unsafe use of type 'bool' in operation" warnings
" /wd4244" # Disable "conversion from 'intmax_t' to 'int', possible loss of data" warnings
" /wd4305" # Disable "'initializing': truncation from 'unsigned int' to 'UCHAR'" warnings
" /wd4018" # Disable "signed/unsigned mismatch" warnings
)
set_property(SOURCE dns/dns.c APPEND_STRING PROPERTY COMPILE_FLAGS ${DNS_C_COMPILE_FLAGS})
set_property(SOURCE grammars/belle_sdpParser.c APPEND_STRING PROPERTY COMPILE_FLAGS " /wd4267") # Disable "possible loss of data" warnings
set_property(SOURCE grammars/belle_sip_messageParser.c APPEND_STRING PROPERTY COMPILE_FLAGS " /wd4267") # Disable "possible loss of data" warnings
else()
set_property(SOURCE dns/dns.c APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-override-init -Wno-implicit-fallthrough -Wno-array-bounds")
set_property(SOURCE grammars/belle_sip_messageParser.c APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-sign-compare")
endif()
set(BELLESIP_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/../src/sdp/sdp_grammar")
string(REPLACE ";" " " LINK_FLAGS_STR "${LINK_FLAGS}")
if(ENABLE_STATIC)
add_library(bellesip-static STATIC ${BELLE_SIP_HEADER_FILES} ${BELLE_SIP_SOURCE_FILES_C} ${BELLE_SIP_SOURCE_FILES_CXX} ${BELLE_SIP_SOURCE_FILES_OBJC} ${ANTLR3C_SOURCE_FILES} ${GRAMMAR_FILES})
set_target_properties(bellesip-static PROPERTIES OUTPUT_NAME bellesip)
set_target_properties(bellesip-static PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON)
target_include_directories(bellesip-static INTERFACE ${PUBLIC_INCLUDE_DIRS} PRIVATE ${PRIVATE_INCLUDE_DIRS})
target_link_libraries(bellesip-static PRIVATE ${LIBS})
if(NOT "${LINK_FLAGS_STR}" STREQUAL "")
set_target_properties(bellesip-static PROPERTIES LINK_FLAGS "${LINK_FLAGS_STR}")
endif()
require_c99(bellesip-static)
install(TARGETS bellesip-static EXPORT ${EXPORT_TARGETS_NAME}Targets
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)
endif()
if(ENABLE_SHARED)
add_library(bellesip SHARED ${BELLE_SIP_HEADER_FILES} ${BELLE_SIP_SOURCE_FILES_C} ${BELLE_SIP_SOURCE_FILES_CXX} ${BELLE_SIP_SOURCE_FILES_OBJC} ${ANTLR3C_SOURCE_FILES} ${GRAMMAR_FILES})
set_target_properties(bellesip PROPERTIES SOVERSION ${BELLESIP_SO_VERSION})
set_target_properties(bellesip PROPERTIES LINKER_LANGUAGE CXX)
set_target_properties(bellesip PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON)
target_include_directories(bellesip INTERFACE ${PUBLIC_INCLUDE_DIRS} PRIVATE ${PRIVATE_INCLUDE_DIRS})
target_link_libraries(bellesip PRIVATE ${LIBS})
if(APPLE)
if(IOS)
set(MIN_OS ${LINPHONE_IOS_DEPLOYMENT_TARGET})
else()
set(MIN_OS ${CMAKE_OSX_DEPLOYMENT_TARGET})
endif()
set_target_properties(bellesip PROPERTIES
FRAMEWORK TRUE
MACOSX_FRAMEWORK_IDENTIFIER org.linphone.belle-sip
MACOSX_FRAMEWORK_INFO_PLIST "${PROJECT_SOURCE_DIR}/build/osx/Info.plist.in"
RESOURCE "${BELLESIP_RESOURCES}"
PUBLIC_HEADER "${BELLE_SIP_HEADER_FILES}"
)
SET_TARGET_PROPERTIES(bellesip PROPERTIES OUTPUT_NAME belle-sip)
endif()
if(NOT "${LINK_FLAGS_STR}" STREQUAL "")
set_target_properties(bellesip PROPERTIES LINK_FLAGS "${LINK_FLAGS_STR}")
endif()
require_c99(bellesip)
if(MSVC)
if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
install(FILES $
DESTINATION ${CMAKE_INSTALL_BINDIR}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)
endif()
endif()
if(APPLE)
install(TARGETS bellesip EXPORT ${EXPORT_TARGETS_NAME}Targets
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
FRAMEWORK DESTINATION Frameworks
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)
else()
install(TARGETS bellesip EXPORT ${EXPORT_TARGETS_NAME}Targets
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)
endif()
endif()
install(FILES ${GRAMMAR_FILES}
DESTINATION "${CMAKE_INSTALL_DATADIR}/belr/grammars"
)
#to avoid // build to generate code twice in // leading compilation issues. Might probably be done in a better way
if (ENABLE_SHARED AND ENABLE_STATIC)
add_dependencies(bellesip-static bellesip)
endif()
belle-sip-5.2.0+dfsg/src/Makefile.am 0000775 0000000 0000000 00000003622 14346131365 0017150 0 ustar 00root root 0000000 0000000 SUBDIRS=grammars
AUTOMAKE_OPTIONS = subdir-objects
lib_LTLIBRARIES=libbellesip.la
libbellesip_la_SOURCES= \
clock_gettime.c clock_gettime.h \
port.c port.h \
parserutils.h \
belle_sip_uri_impl.c \
belle_sip_headers_impl.c \
belle_sip_utils.c belle_sip_internal.h \
belle_sip_object.c \
belle_sip_loop.c \
belle_sip_resolver.c \
belle_sip_parameters.c \
belle_sdp_impl.c \
transaction.c \
listeningpoint.c listeningpoint_internal.h \
sipstack.c \
provider.c \
channel.c channel.h \
message.c \
md5.c md5.h \
auth_helper.c \
siplistener.c \
ict.c \
ist.c \
nict.c \
nist.c \
dialog.c \
auth_event.c \
transports/udp_listeningpoint.c \
transports/udp_channel.c \
transports/stream_channel.c \
transports/stream_channel.h \
transports/stream_listeningpoint.c \
transports/tls_listeningpoint.c \
transports/tls_channel.c \
refresher.c \
dns.c dns.h \
belle_sip_dict.c \
generic-uri.c \
http-provider.c \
http-message.c \
http-listener.c \
bodyhandler.c
if BUILD_APPLE
libbellesip_la_SOURCES+=backgroundtask.m
endif
if BUILD_TUNNEL
libbellesip_la_SOURCES+=transports/tunnel_listeningpoint.c \
transports/tunnel_channel.c \
transports/tunnel_wrapper.cc
endif
libbellesip_la_CFLAGS=$(STRICT_OPTIONS) $(STRICT_OPTIONS_CC) $(ANTLR_CFLAGS) $(TLS_CFLAGS) $(TUNNEL_CFLAGS) $(LIBBELLESIP_CFLAGS)
libbellesip_la_CXXFLAGS=$(STRICT_OPTIONS) $(STRICT_OPTIONS_CXX) $(TLS_CFLAGS) $(TUNNEL_CFLAGS) $(LIBBELLESIP_CFLAGS)
libbellesip_la_LIBADD=grammars/libbellesip_generated.la $(ANTLR_LIBS) $(TLS_LIBS) $(TUNNEL_LIBS) $(ZLIB_LIBS)
libbellesip_la_LDFLAGS=-no-undefined -version-info $(BELLESIP_SO_VERSION)
AM_CPPFLAGS=-I$(top_srcdir)/include -I$(builddir)/grammars
discovery:
touch specs.c
$(CC) $(CFLAGS) -include $(top_builddir)/config.h $(ANTLR_CFLAGS) $(BCTOOLBOXTESTER_CFLAGS) $(TLS_CFLAGS) -E -P -v -dD specs.c
belle-sip-5.2.0+dfsg/src/antlr3c/ 0000775 0000000 0000000 00000000000 14346131365 0016454 5 ustar 00root root 0000000 0000000 belle-sip-5.2.0+dfsg/src/antlr3c/CMakeLists.txt 0000664 0000000 0000000 00000007447 14346131365 0021230 0 ustar 00root root 0000000 0000000 ############################################################################
# CMakeLists.txt
# Copyright (C) 2014 Belledonne Communications, Grenoble France
#
############################################################################
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
############################################################################
option(ENABLE_64BIT "Turns on flags that produce 64 bit object code if any are required." OFF)
option(ENABLE_DEBUGGER "Turns on default flags that include the antlr debugger in the runtime. Disable to remove debugger and the socket dependancies." OFF)
if(ENABLE_64BIT)
set(ANTLR3_USE_64BIT 1)
endif(ENABLE_64BIT)
if(NOT ENABLE_DEBUGGER)
set(ANTLR3_NODEBUGGER 1)
endif(NOT ENABLE_DEBUGGER)
include(CheckIncludeFile)
check_include_file("arpa/nameser.h" HAVE_ARPA_NAMESER_H)
check_include_file("ctype.h" HAVE_CTYPE_H)
check_include_file("inttypes.h" HAVE_INTTYPES_H)
check_include_file("malloc.h" HAVE_MALLOC_H)
check_include_file("memory.h" HAVE_MEMORY_H)
check_include_file("netdb.h" HAVE_NETDB_H)
check_include_file("netinet/in.h" HAVE_NETINET_IN_H)
check_include_file("netinet/tcp.h" HAVE_NETINET_TCP_H)
check_include_file("socket.h" HAVE_SOCKET_H)
check_include_file("stdarg.h" HAVE_STDARG_H)
check_include_file("stdint.h" HAVE_STDINT_H)
check_include_file("stdlib.h" HAVE_STDLIB_H)
check_include_file("strings.h" HAVE_STRINGS_H)
check_include_file("string.h" HAVE_STRING_H)
check_include_file("sys/malloc.h" HAVE_SYS_MALLOC_H)
check_include_file("sys/socket.h" HAVE_SYS_SOCKET_H)
check_include_file("sys/stat.h" HAVE_SYS_STAT_H)
check_include_file("sys/types.h" HAVE_SYS_TYPES_H)
check_include_file("unistd.h" HAVE_UNISTD_H)
foreach(KEYWORD "inline" "__inline__" "__inline")
if(NOT DEFINED C_INLINE)
try_compile(C_HAS_${KEYWORD} "${CMAKE_CURRENT_BINARY_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/test_inline.c"
COMPILE_DEFINITIONS "-Dinline=${KEYWORD}")
if(C_HAS_${KEYWORD})
set(C_INLINE TRUE)
if(NOT "${KEYWORD}" STREQUAL "inline")
set(inline ${KEYWORD})
endif(NOT "${KEYWORD}" STREQUAL "inline")
endif(C_HAS_${KEYWORD})
endif(NOT DEFINED C_INLINE)
endforeach(KEYWORD)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/antlr3config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/antlr3config.h)
if(NOT MSVC)
add_definitions("-Wall")
endif()
include_directories(
include
${CMAKE_CURRENT_BINARY_DIR}
)
set(ANTLR3C_SOURCE_FILES
antlr3c/src/antlr3baserecognizer.c
antlr3c/src/antlr3basetree.c
antlr3c/src/antlr3basetreeadaptor.c
antlr3c/src/antlr3bitset.c
antlr3c/src/antlr3collections.c
antlr3c/src/antlr3commontoken.c
antlr3c/src/antlr3commontree.c
antlr3c/src/antlr3commontreeadaptor.c
antlr3c/src/antlr3commontreenodestream.c
antlr3c/src/antlr3convertutf.c
antlr3c/src/antlr3cyclicdfa.c
antlr3c/src/antlr3debughandlers.c
antlr3c/src/antlr3encodings.c
antlr3c/src/antlr3exception.c
antlr3c/src/antlr3filestream.c
antlr3c/src/antlr3inputstream.c
antlr3c/src/antlr3intstream.c
antlr3c/src/antlr3lexer.c
antlr3c/src/antlr3parser.c
antlr3c/src/antlr3rewritestreams.c
antlr3c/src/antlr3string.c
antlr3c/src/antlr3tokenstream.c
antlr3c/src/antlr3treeparser.c
${CMAKE_CURRENT_BINARY_DIR}/antlr3config.h
PARENT_SCOPE
)
belle-sip-5.2.0+dfsg/src/antlr3c/antlr3config.h.cmake 0000664 0000000 0000000 00000004035 14346131365 0022277 0 ustar 00root root 0000000 0000000 /***************************************************************************
* antlr3config.h.cmake
* Copyright (C) 2014 Belledonne Communications, Grenoble France
*
****************************************************************************
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
****************************************************************************/
#cmakedefine PACKAGE "@PACKAGE@"
#cmakedefine PACKAGE_NAME "@PACKAGE_NAME@"
#cmakedefine PACKAGE_VERSION "@PACKAGE_VERSION@"
#cmakedefine PACKAGE_STRING "@PACKAGE_STRING@"
#cmakedefine PACKAGE_TARNAME "@PACKAGE_TARNAME@"
#cmakedefine PACKAGE_BUGREPORT "@PACKAGE_BUGREPORT@"
#cmakedefine PACKAGE_URL "@PACKAGE_URL@"
#cmakedefine VERSION "@VERSION@"
#cmakedefine ANTLR3_NODEBUGGER
#cmakedefine ANTLR3_USE_64BIT
#cmakedefine HAVE_ARPA_NAMESER_H 1
#cmakedefine HAVE_CTYPE_H 1
#cmakedefine HAVE_INTTYPES_H 1
#cmakedefine HAVE_MALLOC_H 1
#cmakedefine HAVE_MEMORY_H 1
#cmakedefine HAVE_NETDB_H 1
#cmakedefine HAVE_NETINET_IN_H 1
#cmakedefine HAVE_NETINET_TCP_H 1
#cmakedefine HAVE_SOCKET_H 1
#cmakedefine HAVE_STDARG_H 1
#cmakedefine HAVE_STDINT_H 1
#cmakedefine HAVE_STDLIB_H 1
#cmakedefine HAVE_STRINGS_H 1
#cmakedefine HAVE_STRING_H 1
#cmakedefine HAVE_SYS_MALLOC_H 1
#cmakedefine HAVE_SYS_SOCKET_H 1
#cmakedefine HAVE_SYS_STAT_H 1
#cmakedefine HAVE_SYS_TYPES_H 1
#cmakedefine HAVE_UNISTD_H 1
#ifndef __cplusplus
#cmakedefine inline @inline@
#endif
belle-sip-5.2.0+dfsg/src/antlr3c/generate_grammar_sources.py 0000775 0000000 0000000 00000003635 14346131365 0024103 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
#
# Copyright (c) 2012-2019 Belledonne Communications SARL.
#
# This file is part of belle-sip.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
import sys
from glob import glob
from subprocess import call
def main():
print("Deleting old sources...")
ret = call("rm -f ../grammars/belle_sdp*.c ../grammars/belle_sdp*.h ../grammars/belle_sip_message*.c ../grammars/belle_sip_message*.h", shell=True)
if ret != 0:
print("An error occured while deleting old sources")
return -1
else:
print("Done")
print("Generating sources from belle_sdp.g...")
ret = call(['java', '-jar', 'antlr-3.4-complete.jar', '-make', '-Xmultithreaded', '-Xconversiontimeout', '10000', '-fo', '../grammars', '../grammars/belle_sdp.g'])
if ret != 0:
print("An error occured while generating sources from belle_sdp.g")
return -1
else:
print("Done")
print("Generating sources from belle_sip_message.g...")
ret = call(['java', '-jar', 'antlr-3.4-complete.jar', '-make', '-Xmultithreaded', '-Xconversiontimeout', '10000', '-fo', '../grammars', '../grammars/belle_sip_message.g'])
if ret != 0:
print("An error occured while generating sources from belle_sip_message.g")
return -1
else:
print("Done")
if __name__ == "__main__":
sys.exit(main())
belle-sip-5.2.0+dfsg/src/antlr3c/test_inline.c 0000664 0000000 0000000 00000001561 14346131365 0021140 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
typedef int foo_t;
static inline foo_t static_foo(){return 0;}
foo_t foo(){return 0;}
int main(int argc, char *argv[]){return 0;} belle-sip-5.2.0+dfsg/src/auth_event.c 0000664 0000000 0000000 00000014051 14346131365 0017415 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "belle-sip/auth-helper.h"
#include "belle_sip_internal.h"
GET_SET_STRING(belle_sip_auth_event,username)
GET_SET_STRING(belle_sip_auth_event,userid)
GET_SET_STRING(belle_sip_auth_event,realm)
GET_SET_STRING(belle_sip_auth_event,domain)
GET_SET_STRING(belle_sip_auth_event,passwd)
GET_SET_STRING(belle_sip_auth_event,ha1)
GET_SET_STRING(belle_sip_auth_event,distinguished_name)
GET_SET_STRING(belle_sip_auth_event, algorithm)
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) {
belle_sip_auth_event_t* result = belle_sip_new0(belle_sip_auth_event_t);
result->source=source;
belle_sip_auth_event_set_realm(result,realm);
if (from_uri){
belle_sip_auth_event_set_username(result,belle_sip_uri_get_user(from_uri));
belle_sip_auth_event_set_domain(result,belle_sip_uri_get_host(from_uri));
}
return result;
}
void belle_sip_auth_event_destroy(belle_sip_auth_event_t* event) {
DESTROY_STRING(event,username);
DESTROY_STRING(event,userid);
DESTROY_STRING(event,realm);
DESTROY_STRING(event,domain);
DESTROY_STRING(event,passwd);
DESTROY_STRING(event,ha1);
DESTROY_STRING(event,distinguished_name);
DESTROY_STRING(event,algorithm);
if (event->cert) belle_sip_object_unref(event->cert);
if (event->key) belle_sip_object_unref(event->key);
belle_sip_free(event);
}
belle_sip_certificates_chain_t* belle_sip_auth_event_get_client_certificates_chain(const belle_sip_auth_event_t* event) {
return event->cert;
}
void belle_sip_auth_event_set_client_certificates_chain(belle_sip_auth_event_t* event, belle_sip_certificates_chain_t* value) {
SET_OBJECT_PROPERTY(event,cert,value);
}
belle_sip_signing_key_t* belle_sip_auth_event_get_signing_key(const belle_sip_auth_event_t* event) {
return event->key;
}
void belle_sip_auth_event_set_signing_key(belle_sip_auth_event_t* event, belle_sip_signing_key_t* value) {
SET_OBJECT_PROPERTY(event,key,value);
}
belle_sip_auth_mode_t belle_sip_auth_event_get_mode(const belle_sip_auth_event_t* event) {
return event->mode;
}
/* deprecated on 2016/02/02 */
belle_tls_verify_policy_t *belle_tls_verify_policy_new(){
return (belle_tls_verify_policy_t *)belle_tls_crypto_config_new();
}
int belle_tls_verify_policy_set_root_ca(belle_tls_verify_policy_t *obj, const char *path) {
return belle_tls_crypto_config_set_root_ca(obj, path);
}
void belle_tls_verify_policy_set_exceptions(belle_tls_verify_policy_t *obj, int flags){
belle_tls_crypto_config_set_verify_exceptions(obj, flags);
}
unsigned int belle_tls_verify_policy_get_exceptions(const belle_tls_verify_policy_t *obj){
return belle_tls_crypto_config_get_verify_exceptions(obj);
}
/* end of deprecated on 2016/02/02 */
static void crypto_config_uninit(belle_tls_crypto_config_t *obj) {
if (obj->root_ca) belle_sip_free(obj->root_ca);
if (obj->root_ca_data) belle_sip_free(obj->root_ca_data);
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_tls_crypto_config_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_tls_crypto_config_t,belle_sip_object_t,crypto_config_uninit,NULL,NULL,FALSE);
belle_tls_crypto_config_t *belle_tls_crypto_config_new(void){
belle_tls_crypto_config_t *obj=belle_sip_object_new(belle_tls_crypto_config_t);
/*default to "system" default root ca, wihtout warranty...*/
#if defined(__ANDROID__)
belle_tls_crypto_config_set_root_ca(obj,"/system/etc/security/cacerts");
#elif defined(__linux__)
belle_tls_crypto_config_set_root_ca(obj,"/etc/ssl/certs");
#elif defined(__APPLE__)
belle_tls_crypto_config_set_root_ca(obj,"/opt/local/share/curl/curl-ca-bundle.crt");
#elif defined(__QNX__)
belle_tls_crypto_config_set_root_ca(obj,"/var/certs/web_trusted@personal@certmgr");
#endif
obj->ssl_config = NULL;
obj->exception_flags = BELLE_TLS_VERIFY_NONE;
return obj;
}
int belle_tls_crypto_config_set_root_ca(belle_tls_crypto_config_t *obj, const char *path){
if (obj->root_ca) {
belle_sip_free(obj->root_ca);
obj->root_ca = NULL;
}
if (path) {
obj->root_ca = belle_sip_strdup(path);
belle_sip_message("Root ca path set to %s", obj->root_ca);
} else {
belle_sip_message("Root ca path disabled");
}
return 0;
}
int belle_tls_crypto_config_set_root_ca_data(belle_tls_crypto_config_t *obj, const char *data) {
if (obj->root_ca) {
belle_sip_free(obj->root_ca);
obj->root_ca = NULL;
}
if (obj->root_ca_data) {
belle_sip_free(obj->root_ca_data);
obj->root_ca_data = NULL;
}
if (data) {
obj->root_ca_data = belle_sip_strdup(data);
belle_sip_message("Root ca data set to %s", obj->root_ca_data);
} else {
belle_sip_message("Root ca data disabled");
}
return 0;
}
void belle_tls_crypto_config_set_verify_exceptions(belle_tls_crypto_config_t *obj, int flags){
obj->exception_flags=flags;
}
unsigned int belle_tls_crypto_config_get_verify_exceptions(const belle_tls_crypto_config_t *obj){
return obj->exception_flags;
}
void belle_tls_crypto_config_set_ssl_config(belle_tls_crypto_config_t *obj, void *ssl_config) {
obj->ssl_config = ssl_config;
}
void belle_tls_crypto_config_set_verify_callback(belle_tls_crypto_config_t *obj, belle_tls_crypto_config_verify_callback_t cb, void *cb_data){
obj->verify_cb = cb;
obj->verify_cb_data = cb_data;
}
void belle_tls_crypto_config_set_postcheck_callback(belle_tls_crypto_config_t *obj, belle_tls_crypto_config_postcheck_callback_t cb, void *cb_data){
obj->postcheck_cb = cb;
obj->postcheck_cb_data = cb_data;
}
belle-sip-5.2.0+dfsg/src/auth_helper.c 0000664 0000000 0000000 00000032323 14346131365 0017555 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "belle-sip/auth-helper.h"
#include "belle_sip_internal.h"
#include
#include "bctoolbox/crypto.h"
#ifndef BELLE_SIP_CNONCE_LENGTH
#define BELLE_SIP_CNONCE_LENGTH 16
#endif
#define CHECK_IS_PRESENT(obj,header_name,name) \
if (!belle_sip_header_##header_name##_get_##name(obj)) {\
belle_sip_error("parameter ["#name"] not found for header ["#header_name"]");\
return-1;\
}
static void belle_sip_auth_helper_clone_authorization(belle_sip_header_authorization_t* authorization, const belle_sip_header_www_authenticate_t* authentication) {
CLONE_STRING_GENERIC(belle_sip_header_www_authenticate,belle_sip_header_authorization,scheme,authorization,authentication)
CLONE_STRING_GENERIC(belle_sip_header_www_authenticate,belle_sip_header_authorization,realm,authorization,authentication)
CLONE_STRING_GENERIC(belle_sip_header_www_authenticate,belle_sip_header_authorization,nonce,authorization,authentication)
CLONE_STRING_GENERIC(belle_sip_header_www_authenticate,belle_sip_header_authorization,algorithm,authorization,authentication)
CLONE_STRING_GENERIC(belle_sip_header_www_authenticate,belle_sip_header_authorization,opaque,authorization,authentication)
}
static void belle_sip_auth_helper_clone_www_authenticate(belle_sip_header_www_authenticate_t* authentication, const belle_sip_header_authorization_t* authorization) {
CLONE_STRING_GENERIC(belle_sip_header_authorization,belle_sip_header_www_authenticate,scheme, authentication, authorization)
CLONE_STRING_GENERIC(belle_sip_header_authorization,belle_sip_header_www_authenticate,realm, authentication, authorization)
CLONE_STRING_GENERIC(belle_sip_header_authorization,belle_sip_header_www_authenticate,nonce, authentication, authorization)
CLONE_STRING_GENERIC(belle_sip_header_authorization,belle_sip_header_www_authenticate,algorithm,authentication ,authorization)
CLONE_STRING_GENERIC(belle_sip_header_authorization,belle_sip_header_www_authenticate,opaque,authentication, authorization)
}
belle_sip_header_authorization_t* belle_sip_auth_helper_create_authorization(const belle_sip_header_www_authenticate_t* authentication) {
belle_sip_header_authorization_t* authorization = belle_sip_header_authorization_new();
belle_sip_auth_helper_clone_authorization(authorization,authentication);
return authorization;
}
belle_sip_header_www_authenticate_t* belle_sip_auth_helper_create_www_authenticate(const belle_sip_header_authorization_t* authorization) {
belle_sip_header_www_authenticate_t* www_authenticate = belle_sip_header_www_authenticate_new();
belle_sip_auth_helper_clone_www_authenticate(www_authenticate, authorization);
return www_authenticate;
}
belle_http_header_authorization_t* belle_http_auth_helper_create_authorization(const belle_sip_header_www_authenticate_t* authentication) {
belle_http_header_authorization_t* authorization = belle_http_header_authorization_new();
belle_sip_auth_helper_clone_authorization(BELLE_SIP_HEADER_AUTHORIZATION(authorization),authentication);
return authorization;
}
belle_sip_header_proxy_authorization_t* belle_sip_auth_helper_create_proxy_authorization(const belle_sip_header_proxy_authenticate_t* proxy_authentication){
belle_sip_header_proxy_authorization_t* authorization = belle_sip_header_proxy_authorization_new();
belle_sip_auth_helper_clone_authorization(BELLE_SIP_HEADER_AUTHORIZATION(authorization),BELLE_SIP_HEADER_WWW_AUTHENTICATE(proxy_authentication));
return authorization;
}
static void belle_sip_auth_choose_method(const char *algo, const char *ask, uint8_t *out, size_t size) {
if ((algo == NULL) || (!strcasecmp(algo, "MD5"))) {
// By default, using MD5 when algorithm is NULL
bctbx_md5((const uint8_t *)ask, strlen(ask), out);
} else if (!strcasecmp(algo, "SHA-256")) {
bctbx_sha256((const uint8_t *)ask, strlen(ask), (uint8_t)size, out);
}
}
int belle_sip_auth_define_size(const char *algo) {
if (algo == NULL || strcasecmp(algo, "MD5") == 0) {
return 33;
} else if (strcasecmp(algo, "SHA-256") == 0) {
return 65;
} else {
return 0;
}
}
int belle_sip_auth_helper_compute_ha1_for_algorithm(const char *userid, const char *realm, const char *password, char *ha1, size_t size, const char *algo) {
size_t compared_size;
compared_size = belle_sip_auth_define_size(algo);
if (compared_size != size) {
belle_sip_error("belle_sip_fill_authorization_header, size of ha1 must be 33 when MD5 or 65 when SHA-256 ");
return -1;
}
size_t length_byte = (size - 1) / 2;
uint8_t out[MAX_LENGTH_BYTE];
size_t di;
char *ask;
if (!userid) {
belle_sip_error("belle_sip_fill_authorization_header, username not found ");
return -1;
}
if (!password) {
belle_sip_error("belle_sip_fill_authorization_header, password not found ");
return -1;
}
if (!realm) {
belle_sip_error("belle_sip_fill_authorization_header, realm not found ");
return -1;
}
ask = bctbx_strdup_printf("%s:%s:%s", userid, realm, password);
belle_sip_auth_choose_method(algo, ask, out, length_byte);
for (di = 0; di < length_byte; ++di)
sprintf(ha1 + di * 2, "%02x", out[di]);
ha1[length_byte * 2] = '\0';
bctbx_free(ask);
return 0;
}
int belle_sip_auth_helper_compute_ha1(const char *userid, const char *realm, const char *password, char ha1[33]) {
belle_sip_auth_helper_compute_ha1_for_algorithm(userid, realm, password, ha1, 33, "MD5");
return 0;
}
int belle_sip_auth_helper_compute_ha2_for_algorithm(const char *method, const char *uri, char *ha2, size_t size, const char *algo) {
size_t compared_size;
compared_size = belle_sip_auth_define_size(algo);
if (compared_size != size) {
belle_sip_error("belle_sip_fill_authorization_header, size of ha1 must be 33 when MD5 or 65 when SHA-256 ");
return -1;
}
size_t length_byte = (size - 1) / 2;
uint8_t out[MAX_LENGTH_BYTE];
size_t di;
char *ask;
ha2[length_byte * 2] = '\0';
/*HA2=MD5(method:uri)*/
ask = bctbx_strdup_printf("%s:%s", method, uri);
belle_sip_auth_choose_method(algo, ask, out, length_byte);
for (di = 0; di < length_byte; ++di)
sprintf(ha2 + di * 2, "%02x", out[di]);
bctbx_free(ask);
return 0;
}
int belle_sip_auth_helper_compute_ha2(const char *method, const char *uri, char ha2[33]) {
belle_sip_auth_helper_compute_ha2_for_algorithm(method, uri, ha2, 33, "MD5");
return 0;
}
int belle_sip_auth_helper_compute_response_for_algorithm(const char *ha1, const char *nonce, const char *ha2, char *response, size_t size, const char *algo) {
size_t compared_size;
compared_size = belle_sip_auth_define_size(algo);
if (compared_size != size) {
belle_sip_error("belle_sip_fill_authorization_header, size of ha1 must be 33 when MD5 or 65 when SHA-256 ");
return -1;
}
size_t length_byte = (size - 1) / 2;
uint8_t out[MAX_LENGTH_BYTE];
size_t di;
char *ask;
response[length_byte * 2] = '\0';
ask = bctbx_strdup_printf("%s:%s:%s", ha1, nonce, ha2);
belle_sip_auth_choose_method(algo, ask, out, length_byte);
/*copy values*/
for (di = 0; di < length_byte; ++di)
sprintf(response + di * 2, "%02x", out[di]);
bctbx_free(ask);
return 0;
}
int belle_sip_auth_helper_compute_response(const char *ha1, const char *nonce, const char *ha2, char response[33]) {
belle_sip_auth_helper_compute_response_for_algorithm(ha1, nonce, ha2, response, 33, "MD5");
return 0;
}
int belle_sip_auth_helper_compute_response_qop_auth_for_algorithm(const char* ha1
, const char* nonce
, unsigned int nonce_count
, const char* cnonce
, const char* qop
, const char* ha2
, char *response
, size_t size, const char* algo) {
size_t compared_size;
compared_size = belle_sip_auth_define_size(algo);
if (compared_size != size) {
belle_sip_error("belle_sip_fill_authorization_header, size of ha1 must be 33 when MD5 or 65 when SHA-256 ");
return -1;
}
size_t length_byte = (size - 1) / 2;
uint8_t out[MAX_LENGTH_BYTE];
size_t di;
char *ask;
char nounce_count_as_string[9];
response[length_byte * 2] = '\0';
snprintf(nounce_count_as_string, sizeof(nounce_count_as_string), "%08x", nonce_count);
/*response=MD5(HA1:nonce:nonce_count:cnonce:qop:HA2)*/
ask = bctbx_strdup_printf("%s:%s:%s:%s:%s:%s", ha1, nonce, nounce_count_as_string, cnonce, qop, ha2);
belle_sip_auth_choose_method(algo, ask, out, length_byte);
/*copy values*/
for (di = 0; di < length_byte; ++di)
sprintf(response + di * 2, "%02x", out[di]);
bctbx_free(ask);
return 0;
}
int belle_sip_auth_helper_compute_response_qop_auth(const char* ha1
, const char* nonce
, unsigned int nonce_count
, const char* cnonce
, const char* qop
, const char* ha2, char response[33]) {
belle_sip_auth_helper_compute_response_qop_auth_for_algorithm(ha1, nonce, nonce_count, cnonce, qop, ha2, response, 33, "MD5");
return 0;
}
int belle_sip_auth_helper_fill_authorization(belle_sip_header_authorization_t* authorization
,const char* method
,const char* ha1) {
const char *algo = belle_sip_header_authorization_get_algorithm(authorization);
size_t size = belle_sip_auth_define_size(algo);
if (!size) {
belle_sip_error("Algorithm [%s] is not supported ", algo);
return -1;
}
int auth_mode=0;
char* uri;
char ha2[MAX_RESPONSE_SIZE];
char response[MAX_RESPONSE_SIZE];
char cnonce[BELLE_SIP_CNONCE_LENGTH + 1];
response[size-1]=ha2[size-1]='\0';
if (belle_sip_header_authorization_get_scheme(authorization) != NULL &&
strcasecmp("Digest",belle_sip_header_authorization_get_scheme(authorization))!=0) {
belle_sip_error("belle_sip_fill_authorization_header, unsupported schema [%s]"
,belle_sip_header_authorization_get_scheme(authorization));
return -1;
}
if (belle_sip_header_authorization_get_qop(authorization)
&& !(auth_mode=strcasecmp("auth",belle_sip_header_authorization_get_qop(authorization))==0)) {
belle_sip_error("belle_sip_fill_authorization_header, unsupported qop [%s], use auth or nothing instead"
,belle_sip_header_authorization_get_qop(authorization));
return -1;
}
CHECK_IS_PRESENT(authorization,authorization,realm)
CHECK_IS_PRESENT(authorization,authorization,nonce)
if (BELLE_SIP_IS_INSTANCE_OF(authorization,belle_http_header_authorization_t)) {
/*http case*/
if (!belle_http_header_authorization_get_uri(BELLE_HTTP_HEADER_AUTHORIZATION(authorization))) {
belle_sip_error("parameter uri not found for http header authorization");
return-1;
}
} else {
CHECK_IS_PRESENT(authorization,authorization,uri)
}
if (auth_mode) {
CHECK_IS_PRESENT(authorization,authorization,nonce_count)
if (!belle_sip_header_authorization_get_cnonce(authorization)) {
belle_sip_header_authorization_set_cnonce(authorization, belle_sip_random_token((cnonce), sizeof(cnonce)));
}
}
if (!method) {
belle_sip_error("belle_sip_fill_authorization_header, method not found ");
return -1;
}
if (BELLE_SIP_IS_INSTANCE_OF(authorization,belle_http_header_authorization_t)) {
/*http case*/
uri=belle_generic_uri_to_string(belle_http_header_authorization_get_uri(BELLE_HTTP_HEADER_AUTHORIZATION(authorization)));
} else {
uri=belle_sip_uri_to_string(belle_sip_header_authorization_get_uri(authorization));
}
belle_sip_auth_helper_compute_ha2_for_algorithm(method,uri,ha2,size,algo);
belle_sip_free(uri);
if (auth_mode) {
/*response=MD5(HA1:nonce:nonce_count:cnonce:qop:HA2)*/
belle_sip_auth_helper_compute_response_qop_auth_for_algorithm(ha1
,belle_sip_header_authorization_get_nonce(authorization)
,belle_sip_header_authorization_get_nonce_count(authorization)
,belle_sip_header_authorization_get_cnonce(authorization)
,belle_sip_header_authorization_get_qop(authorization)
,ha2
,response
,size
,algo);
} else {
/*response=MD5(ha1:nonce:ha2)*/
belle_sip_auth_helper_compute_response_for_algorithm(ha1,belle_sip_header_authorization_get_nonce(authorization),ha2,response,size,algo);
}
belle_sip_header_authorization_set_response(authorization,(const char*)response);
return 0;
}
int belle_sip_auth_helper_fill_proxy_authorization(belle_sip_header_proxy_authorization_t* proxy_authorization
,const char* method
,const char* ha1) {
return belle_sip_auth_helper_fill_authorization(BELLE_SIP_HEADER_AUTHORIZATION(proxy_authorization)
,method, ha1);
}
belle-sip-5.2.0+dfsg/src/backgroundtask.mm 0000664 0000000 0000000 00000004546 14346131365 0020454 0 ustar 00root root 0000000 0000000 /*
belle-sip - SIP (RFC3261) library.
Copyright (C) 2010 Belledonne Communications SARL
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
#ifdef __APPLE__
#include
#endif
#include "belle_sip_internal.h"
#if TARGET_OS_IPHONE
#include
#include "bctoolbox/ios_utils.hh"
using namespace bctoolbox;
unsigned long belle_sip_begin_background_task(const char *name, belle_sip_background_task_end_callback_t cb, void *data){
auto &iOSUtils = IOSUtils::getUtils();
std::function callback;
if (cb) {
callback = std::bind(cb, data);
}
return iOSUtils.beginBackgroundTask(name, callback);
}
void belle_sip_end_background_task(unsigned long id){
auto &iOSUtils = IOSUtils::getUtils();
iOSUtils.endBackgroundTask(id);
}
#else
/*mac*/
#import
static unsigned long dummy_id=0;
static id activity_id=0;
static int activity_refcnt=0;
unsigned long belle_sip_begin_background_task(const char *name, belle_sip_background_task_end_callback_t cb, void *data){
activity_refcnt++;
if (activity_refcnt==1){
NSProcessInfo *pinfo=[NSProcessInfo processInfo];
if (pinfo && [pinfo respondsToSelector:@selector(beginActivityWithOptions:reason:)]){
activity_id=[pinfo beginActivityWithOptions:NSActivityUserInitiatedAllowingIdleSystemSleep reason:@"Processing SIP signaling"];
[activity_id retain];
belle_sip_message("Activity started");
}
}
return ++dummy_id;
}
void belle_sip_end_background_task(unsigned long id){
activity_refcnt--;
if (activity_refcnt==0){
if (activity_id!=0){
NSProcessInfo *pinfo=[NSProcessInfo processInfo];
[pinfo endActivity:activity_id];
[activity_id release];
belle_sip_message("Activity ended");
activity_id=0;
}
}
}
#endif
belle-sip-5.2.0+dfsg/src/belle_sdp_impl.cc 0000664 0000000 0000000 00000260545 14346131365 0020403 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "belle-sip/belle-sip.h"
#include "grammars/belle_sdpParser.h"
#include "grammars/belle_sdpLexer.h"
#include "belle_sip_internal.h"
#include "sdp/parser.hh"
int belle_sdp_use_belr = 1;
struct _belle_sdp_mime_parameter {
belle_sip_object_t base;
int rate;
int channel_count;
int ptime;
int max_ptime;
int media_format;
const char* type;
const char* parameters;
};
static void belle_sip_object_freefunc(void* obj) {
belle_sip_object_unref(BELLE_SIP_OBJECT(obj));
}
static void* belle_sip_object_copyfunc(void* obj) {
return belle_sip_object_clone_and_ref(BELLE_SIP_OBJECT(obj));
}
static void * belle_sip_string_copyfunc(void *obj) {
return (void *)belle_sip_strdup((const char *)obj);
}
/***************************************************************************************
* Attribute
*
**************************************************************************************/
typedef belle_sdp_attribute_t* (*attribute_parse_func)(const char*) ;
struct attribute_name_func_pair {
const char* name;
attribute_parse_func func;
};
static struct attribute_name_func_pair attribute_table[] = {
{ "rtcp-fb", (attribute_parse_func)belle_sdp_rtcp_fb_attribute_parse },
{ "rtcp-xr", (attribute_parse_func)belle_sdp_rtcp_xr_attribute_parse },
{ "content", (attribute_parse_func)belle_sdp_content_attribute_parse },
{ "label", (attribute_parse_func)belle_sdp_label_attribute_parse },
{ "creq", (attribute_parse_func)belle_sdp_creq_attribute_parse },
{ "csup", (attribute_parse_func)belle_sdp_csup_attribute_parse },
{ "tcap", (attribute_parse_func)belle_sdp_tcap_attribute_parse },
{ "acap", (attribute_parse_func)belle_sdp_acap_attribute_parse },
{ "csup", (attribute_parse_func)belle_sdp_csup_attribute_parse },
{ "acfg", (attribute_parse_func)belle_sdp_acfg_attribute_parse },
{ "pcfg", (attribute_parse_func)belle_sdp_pcfg_attribute_parse }
};
struct _belle_sdp_attribute {
belle_sip_object_t base;
const char* name;
char *unparsed_value;
};
void belle_sdp_attribute_destroy(belle_sdp_attribute_t* attribute) {
DESTROY_STRING(attribute,name)
DESTROY_STRING(attribute,unparsed_value)
}
void belle_sdp_attribute_clone(belle_sdp_attribute_t *attribute, const belle_sdp_attribute_t *orig){
CLONE_STRING(belle_sdp_attribute,name,attribute,orig)
}
belle_sip_error_code belle_sdp_attribute_marshal(belle_sdp_attribute_t* attribute, char* buff, size_t buff_size, size_t *offset) {
return belle_sip_snprintf(buff, buff_size, offset, "a=%s", attribute->name);
}
belle_sdp_attribute_t* belle_sdp_attribute_create(const char* name, const char* value) {
belle_sdp_attribute_t* ret;
size_t i;
size_t elements = sizeof(attribute_table) / sizeof(attribute_table[0]);
if (!name || name[0] == '\0') {
belle_sip_error("Cannot create SDP attribute without name");
return NULL;
}
for (i = 0; i < elements; i++) {
if (strcasecmp(attribute_table[i].name, name) == 0) {
char* raw;
if (value)
raw = belle_sip_strdup_printf("a=%s:%s", name, value);
else
raw = belle_sip_strdup_printf("a=%s", name);
ret = attribute_table[i].func(raw);
belle_sip_free(raw);
return ret;
}
}
/* Not a specialized SDP attribute */
return BELLE_SDP_ATTRIBUTE(belle_sdp_raw_attribute_create(name, value));
}
const char *belle_sdp_attribute_get_value(belle_sdp_attribute_t *attribute) {
char *ret;
char *end;
if (attribute->unparsed_value) {
belle_sip_free(attribute->unparsed_value);
attribute->unparsed_value = NULL;
}
attribute->unparsed_value = belle_sip_object_to_string(attribute);
ret = attribute->unparsed_value;
ret += strlen(attribute->name) + 2; /* "a=" + name*/
if (*ret==':') ret++;
for (; *ret == ' '; ret++) {}; /* skip eventual spaces */
return ret;
}
unsigned int belle_sdp_attribute_has_value(belle_sdp_attribute_t* attribute) {
return belle_sdp_attribute_get_value(attribute) != NULL;
}
BELLE_SDP_NEW(attribute,belle_sip_object)
belle_sdp_attribute_t* belle_sdp_attribute_parse (const char* line) {
auto parser = bellesip::SDP::Parser::getInstance();
auto holder = (belle_sdp_attribute_holder_t*)parser->parse(line, "attribute");
if (holder == NULL) belle_sip_error("attribute parser error for [%s]", line);
belle_sdp_attribute_t* attribute = belle_sdp_attribute_holder_get_attribute(holder);
belle_sip_free(holder);
return attribute;
}
GET_SET_STRING(belle_sdp_attribute,name);
/***************************************************************************************
* Attributes Holder
*
**************************************************************************************/
struct _belle_sdp_attribute_holder {
belle_sdp_attribute_t *attribute;
};
belle_sdp_attribute_holder_t* belle_sdp_attribute_holder_new() {
return (belle_sdp_attribute_holder_t*)belle_sip_malloc0(sizeof(belle_sdp_attribute_holder_t));
}
void belle_sdp_attribute_holder_set_attribute(belle_sdp_attribute_holder_t* holder, void* attribute) {
holder->attribute = (belle_sdp_attribute_t*)attribute;
}
belle_sdp_attribute_t* belle_sdp_attribute_holder_get_attribute(belle_sdp_attribute_holder_t* holder) {
return holder->attribute;
}
/***************************************************************************************
* RAW Attribute
*
**************************************************************************************/
struct _belle_sdp_raw_attribute {
belle_sdp_attribute_t base;
const char* value;
};
void belle_sdp_raw_attribute_destroy(belle_sdp_raw_attribute_t* attribute) {
DESTROY_STRING(attribute,value)
}
void belle_sdp_raw_attribute_clone(belle_sdp_raw_attribute_t* attribute, const belle_sdp_raw_attribute_t* orig) {
if (belle_sdp_attribute_get_value(BELLE_SDP_ATTRIBUTE(orig))) {
belle_sdp_raw_attribute_set_value(attribute, belle_sdp_attribute_get_value(BELLE_SDP_ATTRIBUTE(orig)));
}
}
belle_sip_error_code belle_sdp_raw_attribute_marshal(belle_sdp_raw_attribute_t* attribute, char* buff, size_t buff_size, size_t* offset) {
belle_sip_error_code error = belle_sdp_attribute_marshal(BELLE_SDP_ATTRIBUTE(attribute), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
if (attribute->value) {
error = belle_sip_snprintf(buff, buff_size, offset, ":%s", attribute->value);
if (error != BELLE_SIP_OK) return error;
}
return error;
}
BELLE_SDP_NEW(raw_attribute,belle_sdp_attribute)
belle_sdp_raw_attribute_t* belle_sdp_raw_attribute_create(const char* name, const char* value) {
belle_sdp_raw_attribute_t* attribute = belle_sdp_raw_attribute_new();
belle_sdp_attribute_set_name(BELLE_SDP_ATTRIBUTE(attribute), name);
belle_sdp_raw_attribute_set_value(attribute, value);
return attribute;
}
void belle_sdp_raw_attribute_set_value(belle_sdp_raw_attribute_t* attribute, const char* value) {
if (attribute->value != NULL) belle_sip_free((void*)attribute->value);
if (value) {
attribute->value = belle_sip_strdup(value);
} else attribute->value = NULL;
}
void belle_sdp_raw_attribute_set_name(belle_sdp_raw_attribute_t* attribute, const char* name) {
belle_sdp_attribute_set_name(BELLE_SDP_ATTRIBUTE(attribute), name);
}
/***************************************************************************************
* RFC4574 Attributes
*
**************************************************************************************/
struct _belle_sdp_label_attribute {
belle_sdp_attribute_t base;
const char* pointer;
};
static void belle_sdp_label_attribute_init(belle_sdp_label_attribute_t* attribute) {
belle_sdp_attribute_set_name(BELLE_SDP_ATTRIBUTE(attribute), "label");
}
void belle_sdp_label_attribute_destroy(belle_sdp_label_attribute_t* attribute) {
DESTROY_STRING(attribute,pointer)
}
void belle_sdp_label_attribute_clone(belle_sdp_label_attribute_t* attribute, const belle_sdp_label_attribute_t *orig) {
belle_sdp_label_attribute_set_pointer(attribute, belle_sdp_label_attribute_get_pointer(orig));
}
belle_sip_error_code belle_sdp_label_attribute_marshal(belle_sdp_label_attribute_t* attribute, char * buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error = belle_sip_snprintf(
buff, buff_size, offset,
"a=label:%s",
attribute->pointer
);
return error;
}
BELLE_SDP_NEW_WITH_CTR(label_attribute,belle_sdp_attribute)
BELLE_SDP_BELR_PARSE(label_attribute)
GET_SET_STRING(belle_sdp_label_attribute,pointer)
/***************************************************************************************
* RFC4796 Attributes
*
**************************************************************************************/
// content
struct _belle_sdp_content_attribute {
belle_sdp_attribute_t base;
belle_sip_list_t* media_tags;
};
void belle_sdp_content_attribute_destroy(belle_sdp_content_attribute_t* attribute) {
belle_sip_list_free_with_data(attribute->media_tags, belle_sip_free);
}
void belle_sdp_content_attribute_clone(belle_sdp_content_attribute_t* attribute, const belle_sdp_content_attribute_t *orig) {
attribute->media_tags = belle_sip_list_copy_with_data(orig->media_tags, belle_sip_string_copyfunc);
}
belle_sip_error_code belle_sdp_content_attribute_marshal(belle_sdp_content_attribute_t* attribute, char * buff, size_t buff_size, size_t *offset) {
belle_sip_list_t* media_tags=attribute->media_tags;
belle_sip_error_code error = belle_sip_snprintf(buff,buff_size,offset,"a=content:");
if (error != BELLE_SIP_OK) return error;
int i = 0;
for (;media_tags != NULL;media_tags = media_tags->next){
error = belle_sip_snprintf(
buff, buff_size, offset,
"%s%s",
i++ == 0 ? "" : ",",
(const char*)media_tags->data
);
if (error != BELLE_SIP_OK) return error;
}
return error;
}
void belle_sdp_content_attribute_add_media_tag(belle_sdp_content_attribute_t* attribute, const char* media_tag) {
attribute->media_tags = belle_sip_list_append(attribute->media_tags, belle_sip_strdup(media_tag));
}
belle_sip_list_t* belle_sdp_content_attribute_get_media_tags(belle_sdp_content_attribute_t* attribute) {
return attribute->media_tags;
}
static void belle_sdp_content_attribute_init(belle_sdp_content_attribute_t* attribute) {
belle_sdp_attribute_set_name(BELLE_SDP_ATTRIBUTE(attribute), "content");
}
BELLE_SDP_NEW_WITH_CTR(content_attribute,belle_sdp_attribute)
BELLE_SDP_BELR_PARSE(content_attribute)
/***************************************************************************************
* RFC5939 Attributes
*
**************************************************************************************/
// csup
struct _belle_sdp_csup_attribute {
belle_sdp_attribute_t base;
belle_sip_list_t* option_tags;
};
void belle_sdp_csup_attribute_destroy(belle_sdp_csup_attribute_t* attribute) {
belle_sip_list_free_with_data(attribute->option_tags, belle_sip_free);
}
void belle_sdp_csup_attribute_clone(belle_sdp_csup_attribute_t* attribute, const belle_sdp_csup_attribute_t *orig) {
attribute->option_tags = belle_sip_list_copy_with_data(orig->option_tags, belle_sip_string_copyfunc);
}
belle_sip_error_code belle_sdp_csup_attribute_marshal(belle_sdp_csup_attribute_t* attribute, char * buff, size_t buff_size, size_t *offset) {
belle_sip_list_t* option_tags=attribute->option_tags;
belle_sip_error_code error = belle_sip_snprintf(buff,buff_size,offset,"a=csup:");
if (error != BELLE_SIP_OK) return error;
int i = 0;
for (;option_tags != NULL;option_tags = option_tags->next){
error = belle_sip_snprintf(
buff, buff_size, offset,
"%s%s",
i++ == 0 ? "" : ",",
(const char*)option_tags->data
);
if (error != BELLE_SIP_OK) return error;
}
return error;
}
void belle_sdp_csup_attribute_add_option_tag(belle_sdp_csup_attribute_t* attribute, const char* option_tag) {
attribute->option_tags = belle_sip_list_append(attribute->option_tags, belle_sip_strdup(option_tag));
}
belle_sip_list_t* belle_sdp_csup_attribute_get_option_tags(belle_sdp_csup_attribute_t* attribute) {
return attribute->option_tags;
}
static void belle_sdp_csup_attribute_init(belle_sdp_csup_attribute_t* attribute) {
belle_sdp_attribute_set_name(BELLE_SDP_ATTRIBUTE(attribute), "csup");
}
BELLE_SDP_NEW_WITH_CTR(csup_attribute,belle_sdp_attribute)
BELLE_SDP_BELR_PARSE(csup_attribute)
// creq
struct _belle_sdp_creq_attribute {
belle_sdp_attribute_t base;
belle_sip_list_t* option_tags;
};
void belle_sdp_creq_attribute_destroy(belle_sdp_creq_attribute_t* attribute) {
belle_sip_list_free_with_data(attribute->option_tags, belle_sip_free);
}
void belle_sdp_creq_attribute_clone(belle_sdp_creq_attribute_t* attribute, const belle_sdp_creq_attribute_t *orig) {
attribute->option_tags = belle_sip_list_copy_with_data(orig->option_tags, belle_sip_string_copyfunc);
}
belle_sip_error_code belle_sdp_creq_attribute_marshal(belle_sdp_creq_attribute_t* attribute, char * buff, size_t buff_size, size_t *offset) {
belle_sip_list_t* option_tags = attribute->option_tags;
belle_sip_error_code error = belle_sip_snprintf(buff, buff_size, offset, "a=creq:");
if (error != BELLE_SIP_OK) return error;
int i = 0;
for (;option_tags != NULL;option_tags = option_tags->next){
error = belle_sip_snprintf(
buff, buff_size, offset,
"%s%s",
i++ == 0 ? "" : ",",
(const char*)option_tags->data
);
if (error != BELLE_SIP_OK) return error;
}
return error;
}
void belle_sdp_creq_attribute_add_option_tag(belle_sdp_creq_attribute_t* attribute, const char* option_tag) {
attribute->option_tags = belle_sip_list_append(attribute->option_tags, belle_sip_strdup(option_tag));
}
belle_sip_list_t* belle_sdp_creq_attribute_get_option_tags(belle_sdp_creq_attribute_t* attribute) {
return attribute->option_tags;
}
static void belle_sdp_creq_attribute_init(belle_sdp_creq_attribute_t* attribute) {
belle_sdp_attribute_set_name(BELLE_SDP_ATTRIBUTE(attribute), "creq");
}
BELLE_SDP_NEW_WITH_CTR(creq_attribute,belle_sdp_attribute)
BELLE_SDP_BELR_PARSE(creq_attribute)
// tcap
struct _belle_sdp_tcap_attribute {
belle_sdp_attribute_t base;
belle_sip_list_t* protos;
int id;
};
static void belle_sdp_tcap_attribute_init(belle_sdp_tcap_attribute_t* attribute) {
belle_sdp_attribute_set_name(BELLE_SDP_ATTRIBUTE(attribute), "tcap");
}
void belle_sdp_tcap_attribute_destroy(belle_sdp_tcap_attribute_t* attribute) {
belle_sip_list_free_with_data(attribute->protos, belle_sip_free);
}
void belle_sdp_tcap_attribute_clone(belle_sdp_tcap_attribute_t* attribute, const belle_sdp_tcap_attribute_t *orig) {
attribute->protos = belle_sip_list_copy_with_data(orig->protos, belle_sip_string_copyfunc);
attribute->id = orig->id;
}
belle_sip_error_code belle_sdp_tcap_attribute_marshal(belle_sdp_tcap_attribute_t* attribute, char * buff, size_t buff_size, size_t *offset) {
belle_sip_list_t* protos = attribute->protos;
belle_sip_error_code error = belle_sip_snprintf(buff, buff_size, offset, "a=tcap:%d", attribute->id);
if (error != BELLE_SIP_OK) return error;
int i = 0;
for (;protos != NULL;protos = protos->next){
error = belle_sip_snprintf(
buff, buff_size, offset,
" %s",
(const char*)protos->data
);
if (error != BELLE_SIP_OK) return error;
}
return error;
}
void belle_sdp_tcap_attribute_add_proto(belle_sdp_tcap_attribute_t* attribute, const char* proto) {
attribute->protos = belle_sip_list_append(attribute->protos, belle_sip_strdup(proto));
}
belle_sip_list_t* belle_sdp_tcap_attribute_get_protos(belle_sdp_tcap_attribute_t* attribute) {
return attribute->protos;
}
BELLE_SDP_NEW_WITH_CTR(tcap_attribute,belle_sdp_attribute)
BELLE_SDP_BELR_PARSE(tcap_attribute)
GET_SET_INT(belle_sdp_tcap_attribute,id,int)
// acap
struct _belle_sdp_acap_attribute {
belle_sdp_attribute_t base;
int id;
const char* name;
const char* value;
};
static void belle_sdp_acap_attribute_init(belle_sdp_acap_attribute_t* attribute) {
belle_sdp_attribute_set_name(BELLE_SDP_ATTRIBUTE(attribute), "acap");
}
void belle_sdp_acap_attribute_destroy(belle_sdp_acap_attribute_t* attribute) {
DESTROY_STRING(attribute,name)
DESTROY_STRING(attribute,value)
}
void belle_sdp_acap_attribute_clone(belle_sdp_acap_attribute_t* attribute, const belle_sdp_acap_attribute_t *orig) {
attribute->id = orig->id;
belle_sdp_acap_attribute_set_name(attribute, belle_sdp_acap_attribute_get_name(orig));
belle_sdp_acap_attribute_set_value(attribute, belle_sdp_acap_attribute_get_value(orig));
}
belle_sip_error_code belle_sdp_acap_attribute_marshal(belle_sdp_acap_attribute_t* attribute, char * buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error = belle_sip_snprintf(
buff, buff_size, offset,
"a=acap:%d %s:%s",
attribute->id,
attribute->name,
attribute->value
);
return error;
}
BELLE_SDP_NEW_WITH_CTR(acap_attribute,belle_sdp_attribute)
BELLE_SDP_BELR_PARSE(acap_attribute)
GET_SET_INT(belle_sdp_acap_attribute,id,int)
GET_SET_STRING(belle_sdp_acap_attribute,name)
GET_SET_STRING(belle_sdp_acap_attribute,value)
// acfg
struct _belle_sdp_acfg_attribute {
belle_sdp_attribute_t base;
int id;
belle_sip_list_t* configs;
};
static void belle_sdp_acfg_attribute_init(belle_sdp_acfg_attribute_t* attribute) {
belle_sdp_attribute_set_name(BELLE_SDP_ATTRIBUTE(attribute), "acfg");
}
void belle_sdp_acfg_attribute_destroy(belle_sdp_acfg_attribute_t* attribute) {
belle_sip_list_free_with_data(attribute->configs, belle_sip_free);
}
void belle_sdp_acfg_attribute_clone(belle_sdp_acfg_attribute_t* attribute, const belle_sdp_acfg_attribute_t *orig) {
attribute->id = orig->id;
attribute->configs = belle_sip_list_copy_with_data(orig->configs, belle_sip_string_copyfunc);
}
belle_sip_error_code belle_sdp_acfg_attribute_marshal(belle_sdp_acfg_attribute_t* attribute, char * buff, size_t buff_size, size_t *offset) {
belle_sip_list_t* configs = attribute->configs;
belle_sip_error_code error = belle_sip_snprintf(
buff, buff_size, offset,
"a=acfg:%d",
attribute->id
);
if (error != BELLE_SIP_OK) return error;
int i = 0;
for (;configs != NULL; configs = configs->next){
error = belle_sip_snprintf(
buff, buff_size, offset,
" %s",
(const char*)configs->data
);
if (error != BELLE_SIP_OK) return error;
}
return error;
}
void belle_sdp_acfg_attribute_add_config(belle_sdp_acfg_attribute_t* attribute, const char* config) {
attribute->configs = belle_sip_list_append(attribute->configs, belle_sip_strdup(config));
}
belle_sip_list_t* belle_sdp_acfg_attribute_get_configs(const belle_sdp_acfg_attribute_t* attribute) {
return attribute->configs;
}
BELLE_SDP_NEW_WITH_CTR(acfg_attribute,belle_sdp_attribute)
BELLE_SDP_BELR_PARSE(acfg_attribute)
GET_SET_INT(belle_sdp_acfg_attribute,id,int)
// pcfg
struct _belle_sdp_pcfg_attribute {
belle_sdp_attribute_t base;
int id;
belle_sip_list_t* configs;
};
static void belle_sdp_pcfg_attribute_init(belle_sdp_pcfg_attribute_t* attribute) {
belle_sdp_attribute_set_name(BELLE_SDP_ATTRIBUTE(attribute), "pcfg");
}
void belle_sdp_pcfg_attribute_destroy(belle_sdp_pcfg_attribute_t* attribute) {
belle_sip_list_free_with_data(attribute->configs, belle_sip_free);
}
void belle_sdp_pcfg_attribute_clone(belle_sdp_pcfg_attribute_t* attribute, const belle_sdp_pcfg_attribute_t *orig) {
attribute->id = orig->id;
attribute->configs = belle_sip_list_copy_with_data(orig->configs, belle_sip_string_copyfunc);
}
belle_sip_error_code belle_sdp_pcfg_attribute_marshal(belle_sdp_pcfg_attribute_t* attribute, char * buff, size_t buff_size, size_t *offset) {
belle_sip_list_t* configs = attribute->configs;
belle_sip_error_code error = belle_sip_snprintf(
buff, buff_size, offset,
"a=pcfg:%d",
attribute->id
);
int i = 0;
for (;configs != NULL;configs = configs->next){
error = belle_sip_snprintf(
buff, buff_size, offset,
" %s",
(const char*)configs->data
);
if (error != BELLE_SIP_OK) return error;
}
return error;
}
void belle_sdp_pcfg_attribute_add_config(belle_sdp_pcfg_attribute_t* attribute, const char* config) {
attribute->configs = belle_sip_list_append(attribute->configs, belle_sip_strdup(config));
}
belle_sip_list_t* belle_sdp_pcfg_attribute_get_configs(const belle_sdp_pcfg_attribute_t* attribute) {
return attribute->configs;
}
BELLE_SDP_NEW_WITH_CTR(pcfg_attribute,belle_sdp_attribute)
BELLE_SDP_BELR_PARSE(pcfg_attribute)
GET_SET_INT(belle_sdp_pcfg_attribute,id,int)
/***************************************************************************************
* RTCP-FB Attribute
*
**************************************************************************************/
struct _belle_sdp_rtcp_fb_attribute {
belle_sdp_attribute_t base;
belle_sdp_rtcp_fb_val_type_t type;
belle_sdp_rtcp_fb_val_param_t param;
uint32_t smaxpr;
uint16_t trr_int;
int8_t id;
};
BELLESIP_EXPORT unsigned int belle_sdp_rtcp_fb_attribute_has_pli(const belle_sdp_rtcp_fb_attribute_t* attribute);
BELLESIP_EXPORT void belle_sdp_rtcp_fb_attribute_set_pli(belle_sdp_rtcp_fb_attribute_t* attribute, unsigned int enable);
BELLESIP_EXPORT unsigned int belle_sdp_rtcp_fb_attribute_has_sli(const belle_sdp_rtcp_fb_attribute_t* attribute);
BELLESIP_EXPORT void belle_sdp_rtcp_fb_attribute_set_sli(belle_sdp_rtcp_fb_attribute_t* attribute, unsigned int enable);
BELLESIP_EXPORT unsigned int belle_sdp_rtcp_fb_attribute_has_rpsi(const belle_sdp_rtcp_fb_attribute_t* attribute);
BELLESIP_EXPORT void belle_sdp_rtcp_fb_attribute_set_rpsi(belle_sdp_rtcp_fb_attribute_t* attribute, unsigned int enable);
BELLESIP_EXPORT unsigned int belle_sdp_rtcp_fb_attribute_has_app(const belle_sdp_rtcp_fb_attribute_t* attribute);
BELLESIP_EXPORT void belle_sdp_rtcp_fb_attribute_set_app(belle_sdp_rtcp_fb_attribute_t* attribute, unsigned int enable);
void belle_sdp_rtcp_fb_attribute_destroy(belle_sdp_rtcp_fb_attribute_t* attribute) {}
void belle_sdp_rtcp_fb_attribute_clone(belle_sdp_rtcp_fb_attribute_t* attribute, const belle_sdp_rtcp_fb_attribute_t *orig) {
attribute->type = orig->type;
attribute->param = orig->param;
attribute->trr_int = orig->trr_int;
attribute->id = orig->id;
attribute->smaxpr = orig->smaxpr;
}
belle_sip_error_code belle_sdp_rtcp_fb_attribute_marshal(belle_sdp_rtcp_fb_attribute_t* attribute, char * buff, size_t buff_size, size_t *offset) {
int8_t id = belle_sdp_rtcp_fb_attribute_get_id(attribute);
belle_sdp_rtcp_fb_val_type_t type = belle_sdp_rtcp_fb_attribute_get_type(attribute);
belle_sdp_rtcp_fb_val_param_t param = belle_sdp_rtcp_fb_attribute_get_param(attribute);
belle_sip_error_code error = belle_sdp_attribute_marshal(BELLE_SDP_ATTRIBUTE(attribute), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
if (id < 0) {
error = belle_sip_snprintf(buff, buff_size, offset, ":* ");
} else {
error = belle_sip_snprintf(buff, buff_size, offset, ":%u ", id);
}
if (error != BELLE_SIP_OK) return error;
switch (type) {
case BELLE_SDP_RTCP_FB_ACK:
error = belle_sip_snprintf(buff, buff_size, offset, "ack");
if (error != BELLE_SIP_OK) return error;
switch (param) {
default:
case BELLE_SDP_RTCP_FB_NONE:
break;
case BELLE_SDP_RTCP_FB_RPSI:
error = belle_sip_snprintf(buff, buff_size, offset, " rpsi");
break;
case BELLE_SDP_RTCP_FB_APP:
error = belle_sip_snprintf(buff, buff_size, offset, " app");
break;
}
break;
case BELLE_SDP_RTCP_FB_NACK:
error = belle_sip_snprintf(buff, buff_size, offset, "nack");
if (error != BELLE_SIP_OK) return error;
switch (param) {
default:
case BELLE_SDP_RTCP_FB_NONE:
break;
case BELLE_SDP_RTCP_FB_PLI:
error = belle_sip_snprintf(buff, buff_size, offset, " pli");
break;
case BELLE_SDP_RTCP_FB_SLI:
error = belle_sip_snprintf(buff, buff_size, offset, " sli");
break;
case BELLE_SDP_RTCP_FB_RPSI:
error = belle_sip_snprintf(buff, buff_size, offset, " rpsi");
break;
case BELLE_SDP_RTCP_FB_APP:
error = belle_sip_snprintf(buff, buff_size, offset, " app");
break;
}
break;
case BELLE_SDP_RTCP_FB_TRR_INT:
error = belle_sip_snprintf(buff, buff_size, offset, "trr-int %u", belle_sdp_rtcp_fb_attribute_get_trr_int(attribute));
break;
case BELLE_SDP_RTCP_FB_CCM:
error = belle_sip_snprintf(buff, buff_size, offset, "ccm");
if (error != BELLE_SIP_OK) return error;
switch (param) {
case BELLE_SDP_RTCP_FB_FIR:
error = belle_sip_snprintf(buff, buff_size, offset, " fir");
break;
case BELLE_SDP_RTCP_FB_TMMBR:
error = belle_sip_snprintf(buff, buff_size, offset, " tmmbr");
if (belle_sdp_rtcp_fb_attribute_get_smaxpr(attribute) > 0) {
error = belle_sip_snprintf(buff, buff_size, offset, " smaxpr=%u", belle_sdp_rtcp_fb_attribute_get_smaxpr(attribute));
}
break;
default:
break;
}
break;
}
return error;
}
void belle_sdp_rtcp_fb_attribute_set_raw_id(belle_sdp_rtcp_fb_attribute_t* attribute, const char* value) {
attribute->id = strcmp(value, "*") == 0
? -1
: atoi(value);
}
void belle_sdp_rtcp_fb_attribute_set_raw_type(belle_sdp_rtcp_fb_attribute_t* attribute, const char* value) {
if (strcmp(value, "ack") == 0) {
attribute->type = BELLE_SDP_RTCP_FB_ACK;
}
if (strcmp(value, "nack") == 0) {
attribute->type = BELLE_SDP_RTCP_FB_NACK;
}
if (strcmp(value, "ccm") == 0) {
attribute->type = BELLE_SDP_RTCP_FB_CCM;
}
}
void belle_sdp_rtcp_fb_attribute_set_raw_param(belle_sdp_rtcp_fb_attribute_t* attribute, const char* value) {
// Space is required here
if (strcmp(value, " pli") == 0) {
attribute->param = BELLE_SDP_RTCP_FB_PLI;
}
if (strcmp(value, " sli") == 0) {
attribute->param = BELLE_SDP_RTCP_FB_SLI;
}
if (strcmp(value, " rpsi") == 0) {
attribute->param = BELLE_SDP_RTCP_FB_RPSI;
}
if (strcmp(value, "fir") == 0) {
attribute->param = BELLE_SDP_RTCP_FB_FIR;
}
if (strcmp(value, "tmmbr") == 0) {
attribute->param = BELLE_SDP_RTCP_FB_TMMBR;
}
}
static void belle_sdp_rtcp_fb_attribute_init(belle_sdp_rtcp_fb_attribute_t* attribute) {
belle_sdp_attribute_set_name(BELLE_SDP_ATTRIBUTE(attribute), "rtcp-fb");
attribute->id = -1;
attribute->type = BELLE_SDP_RTCP_FB_TRR_INT;
attribute->param = BELLE_SDP_RTCP_FB_NONE;
attribute->trr_int = 0;
attribute->smaxpr = 0;
}
BELLE_SDP_NEW_WITH_CTR(rtcp_fb_attribute,belle_sdp_attribute)
BELLE_SDP_PARSE(rtcp_fb_attribute)
GET_SET_INT(belle_sdp_rtcp_fb_attribute,id,int8_t)
GET_SET_INT(belle_sdp_rtcp_fb_attribute,type,belle_sdp_rtcp_fb_val_type_t)
GET_SET_INT(belle_sdp_rtcp_fb_attribute,param,belle_sdp_rtcp_fb_val_param_t)
GET_SET_INT(belle_sdp_rtcp_fb_attribute,trr_int,uint16_t)
GET_SET_INT(belle_sdp_rtcp_fb_attribute,smaxpr,uint32_t)
/***************************************************************************************
* RTCP-XR Attribute
*
**************************************************************************************/
struct _belle_sdp_rtcp_xr_attribute {
belle_sdp_attribute_t base;
const char* rcvr_rtt_mode;
int rcvr_rtt_max_size;
unsigned int stat_summary;
belle_sip_list_t* stat_summary_flags;
unsigned int voip_metrics;
};
const belle_sip_list_t* belle_sdp_rtcp_xr_attribute_get_stat_summary_flags(const belle_sdp_rtcp_xr_attribute_t* attribute) {
return attribute->stat_summary_flags;
}
void belle_sdp_rtcp_xr_attribute_add_stat_summary_flag(belle_sdp_rtcp_xr_attribute_t* attribute, const char* flag) {
attribute->stat_summary_flags = belle_sip_list_append(attribute->stat_summary_flags, belle_sip_strdup(flag));
}
void belle_sdp_rtcp_xr_attribute_enable_stat_summary(belle_sdp_rtcp_xr_attribute_t* attribute, const char* flag) {
belle_sdp_rtcp_xr_attribute_set_stat_summary(attribute, 1);
}
void belle_sdp_rtcp_xr_attribute_enable_voip_metrics(belle_sdp_rtcp_xr_attribute_t* attribute, const char* flag) {
belle_sdp_rtcp_xr_attribute_set_voip_metrics(attribute, 1);
}
void belle_sdp_rtcp_xr_attribute_destroy(belle_sdp_rtcp_xr_attribute_t* attribute) {
DESTROY_STRING(attribute,rcvr_rtt_mode)
belle_sip_list_free_with_data(attribute->stat_summary_flags, belle_sip_free);
}
void belle_sdp_rtcp_xr_attribute_clone(belle_sdp_rtcp_xr_attribute_t* attribute, const belle_sdp_rtcp_xr_attribute_t *orig) {
CLONE_STRING(belle_sdp_rtcp_xr_attribute,rcvr_rtt_mode,attribute,orig)
attribute->rcvr_rtt_max_size = orig->rcvr_rtt_max_size;
attribute->stat_summary = orig->stat_summary;
attribute->stat_summary_flags = belle_sip_list_copy_with_data(orig->stat_summary_flags, belle_sip_string_copyfunc);
attribute->voip_metrics = orig->voip_metrics;
}
belle_sip_error_code belle_sdp_rtcp_xr_attribute_marshal(belle_sdp_rtcp_xr_attribute_t* attribute, char * buff, size_t buff_size, size_t *offset) {
const char *rcvr_rtt_mode = NULL;
int rcvr_rtt_max_size = -1;
int nb_xr_formats = 0;
belle_sip_error_code error = belle_sdp_attribute_marshal(BELLE_SDP_ATTRIBUTE(attribute), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
rcvr_rtt_mode = belle_sdp_rtcp_xr_attribute_get_rcvr_rtt_mode(attribute);
if (rcvr_rtt_mode != NULL) {
error = belle_sip_snprintf(buff, buff_size, offset, "%srcvr-rtt=%s", nb_xr_formats++ == 0 ? ":" : " ", rcvr_rtt_mode);
if (error != BELLE_SIP_OK) return error;
rcvr_rtt_max_size = belle_sdp_rtcp_xr_attribute_get_rcvr_rtt_max_size(attribute);
if (rcvr_rtt_max_size > 0) {
error = belle_sip_snprintf(buff, buff_size, offset, ":%u", rcvr_rtt_max_size);
if (error != BELLE_SIP_OK) return error;
}
}
if (belle_sdp_rtcp_xr_attribute_has_stat_summary(attribute)) {
belle_sip_list_t* list;
int nb_stat_flags = 0;
error = belle_sip_snprintf(buff, buff_size, offset, "%sstat-summary", nb_xr_formats++ == 0 ? ":" : " ");
if (error != BELLE_SIP_OK) return error;
for (list = attribute->stat_summary_flags; list != NULL; list = list->next) {
error = belle_sip_snprintf(buff, buff_size, offset, "%s%s", nb_stat_flags++ == 0 ? "=" : ",", (const char*)list->data);
if (error != BELLE_SIP_OK) return error;
}
}
if (belle_sdp_rtcp_xr_attribute_has_voip_metrics(attribute)) {
error = belle_sip_snprintf(buff, buff_size, offset, "%svoip-metrics", nb_xr_formats++ == 0 ? ":" : " ");
if (error != BELLE_SIP_OK) return error;
}
return error;
}
static void belle_sdp_rtcp_xr_attribute_init(belle_sdp_rtcp_xr_attribute_t* attribute) {
belle_sdp_attribute_set_name(BELLE_SDP_ATTRIBUTE(attribute), "rtcp-xr");
}
BELLE_SDP_NEW_WITH_CTR(rtcp_xr_attribute,belle_sdp_attribute)
BELLE_SDP_PARSE(rtcp_xr_attribute)
GET_SET_STRING(belle_sdp_rtcp_xr_attribute,rcvr_rtt_mode)
GET_SET_INT(belle_sdp_rtcp_xr_attribute,rcvr_rtt_max_size,int)
GET_SET_BOOL(belle_sdp_rtcp_xr_attribute,stat_summary,has)
GET_SET_BOOL(belle_sdp_rtcp_xr_attribute,voip_metrics,has)
/***************************************************************************************
* Bandwidth
*
**************************************************************************************/
struct _belle_sdp_bandwidth {
belle_sip_object_t base;
const char* type;
int value;
};
void belle_sdp_bandwidth_destroy(belle_sdp_bandwidth_t* bandwidth) {
if (bandwidth->type) belle_sip_free((void*)bandwidth->type);
}
void belle_sdp_bandwidth_clone(belle_sdp_bandwidth_t *bandwidth, const belle_sdp_bandwidth_t *orig){
CLONE_STRING(belle_sdp_bandwidth,type,bandwidth,orig)
bandwidth->value=orig->value;
}
belle_sip_error_code belle_sdp_bandwidth_marshal(belle_sdp_bandwidth_t* bandwidth, char* buff, size_t buff_size, size_t *offset) {
return belle_sip_snprintf(buff,buff_size,offset,"b=%s:%i",bandwidth->type,bandwidth->value);
}
BELLE_SDP_NEW(bandwidth,belle_sip_object)
BELLE_SDP_PARSE(bandwidth)
GET_SET_STRING(belle_sdp_bandwidth,type);
GET_SET_INT(belle_sdp_bandwidth,value,int)
/************************
* connection
***********************/
struct _belle_sdp_connection {
belle_sip_object_t base;
const char* network_type;
const char* address_type;
const char* address;
int ttl;
int range;
};
void belle_sdp_connection_destroy(belle_sdp_connection_t* connection) {
DESTROY_STRING(connection,network_type)
DESTROY_STRING(connection,address_type)
DESTROY_STRING(connection,address)
}
void belle_sdp_connection_clone(belle_sdp_connection_t *connection, const belle_sdp_connection_t *orig){
CLONE_STRING(belle_sdp_connection,network_type,connection,orig)
CLONE_STRING(belle_sdp_connection,address_type,connection,orig)
CLONE_STRING(belle_sdp_connection,address,connection,orig)
connection->range=orig->range;
connection->ttl=orig->ttl;
}
belle_sip_error_code belle_sdp_connection_marshal(belle_sdp_connection_t* connection, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error = belle_sip_snprintf(buff,buff_size,offset,"c=%s %s %s",connection->network_type,connection->address_type,connection->address);
if (error != BELLE_SIP_OK) return error;
if (connection->ttl>0)
error = belle_sip_snprintf(buff,buff_size,offset,"/%i",connection->ttl);
if (error != BELLE_SIP_OK) return error;
if (connection->range>0)
error = belle_sip_snprintf(buff,buff_size,offset,"/%i",connection->range);
return error;
}
BELLE_SDP_NEW(connection,belle_sip_object)
BELLE_SDP_PARSE(connection)
belle_sdp_connection_t* belle_sdp_connection_create(const char* net_type, const char* addr_type, const char* addr) {
belle_sdp_connection_t* connection = belle_sdp_connection_new();
belle_sdp_connection_set_network_type(connection,net_type);
belle_sdp_connection_set_address_type(connection,addr_type);
belle_sdp_connection_set_address(connection,addr);
return connection;
}
GET_SET_STRING(belle_sdp_connection,network_type);
GET_SET_STRING(belle_sdp_connection,address_type);
GET_SET_STRING(belle_sdp_connection,address);
GET_SET_INT(belle_sdp_connection,ttl,int);
GET_SET_INT(belle_sdp_connection,range,int);
/************************
* email
***********************/
struct _belle_sdp_email {
belle_sip_object_t base;
char* value;
};
void belle_sdp_email_destroy(belle_sdp_email_t* email) {
DESTROY_STRING(email,value)
}
void belle_sdp_email_clone(belle_sdp_email_t *email, const belle_sdp_email_t *orig){
CLONE_STRING(belle_sdp_email,value,email,orig)
}
belle_sip_error_code belle_sdp_email_marshal(belle_sdp_email_t* email, char* buff, size_t buff_size, size_t *offset) {
return belle_sip_snprintf(buff,buff_size,offset,"e=%s",email->value);
}
BELLE_SDP_NEW(email,belle_sip_object)
BELLE_SDP_PARSE(email)
GET_SET_STRING(belle_sdp_email,value);
/************************
* info
***********************/
struct _belle_sdp_info {
belle_sip_object_t base;
const char* value;
};
void belle_sdp_info_destroy(belle_sdp_info_t* info) {
DESTROY_STRING(info,value)
}
void belle_sdp_info_clone(belle_sdp_info_t *info, const belle_sdp_info_t *orig){
CLONE_STRING(belle_sdp_info,value,info,orig)
}
belle_sip_error_code belle_sdp_info_marshal(belle_sdp_info_t* info, char* buff, size_t buff_size, size_t *offset) {
return belle_sip_snprintf(buff,buff_size,offset,"i=%s",info->value);
}
BELLE_SDP_NEW(info,belle_sip_object)
BELLE_SDP_PARSE(info)
GET_SET_STRING(belle_sdp_info,value);
/************************
* media
***********************/
struct _belle_sdp_media {
belle_sip_object_t base;
const char* media_type;
int media_port;
belle_sip_list_t* media_formats;
int port_count;
const char* protocol;
const char* raw_fmt;
};
belle_sip_list_t* belle_sdp_media_get_media_formats(const belle_sdp_media_t* media) {
return media->media_formats;
}
void belle_sdp_media_set_media_formats( belle_sdp_media_t* media, belle_sip_list_t* formats) {
/*belle_sip_list_free(media->media_formats); to allow easy list management might be better to add an append format method*/
media->media_formats = formats;
}
void belle_sdp_media_media_formats_add(belle_sdp_media_t* media, const char* fmt) {
media->media_formats = belle_sip_list_append(media->media_formats, (void*)(intptr_t)atoi(fmt));
}
void belle_sdp_media_destroy(belle_sdp_media_t* media) {
DESTROY_STRING(media,media_type)
belle_sip_list_free(media->media_formats);
DESTROY_STRING(media,protocol)
}
static void belle_sdp_media_init(belle_sdp_media_t* media) {
media->port_count=1;
}
void belle_sdp_media_clone(belle_sdp_media_t *media, const belle_sdp_media_t *orig){
CLONE_STRING(belle_sdp_media,media_type,media,orig)
media->media_port=orig->media_port;
media->media_formats = belle_sip_list_copy(orig->media_formats);
media->port_count=orig->port_count;
CLONE_STRING(belle_sdp_media,protocol,media,orig)
}
belle_sip_error_code belle_sdp_media_marshal(belle_sdp_media_t* media, char* buff, size_t buff_size, size_t *offset) {
belle_sip_list_t* list = media->media_formats;
belle_sip_error_code error = belle_sip_snprintf(buff,buff_size,offset,"m=%s %i",media->media_type,media->media_port);
if (error != BELLE_SIP_OK) return error;
if (media->port_count>1) {
error = belle_sip_snprintf(buff,buff_size,offset,"/%i",media->port_count);
if (error != BELLE_SIP_OK) return error;
}
error = belle_sip_snprintf(buff,buff_size,offset," %s",media->protocol);
if (error != BELLE_SIP_OK) return error;
for (;list != NULL;list=list->next){
error = belle_sip_snprintf(buff,buff_size,offset," %li",(long)(intptr_t)list->data);
if (error != BELLE_SIP_OK) return error;
}
return error;
}
BELLE_SDP_NEW_WITH_CTR(media,belle_sip_object)
BELLE_SDP_PARSE(media)
belle_sdp_media_t* belle_sdp_media_create(const char* media_type
,int media_port
,int port_count
,const char* protocol
,belle_sip_list_t* static_media_formats) {
belle_sdp_media_t* media= belle_sdp_media_new();
belle_sdp_media_set_media_type(media,media_type);
belle_sdp_media_set_media_port(media,media_port);
belle_sdp_media_set_port_count(media,port_count);
belle_sdp_media_set_protocol(media,protocol);
if (static_media_formats) belle_sdp_media_set_media_formats(media,static_media_formats);
return media;
}
GET_SET_STRING(belle_sdp_media,media_type);
GET_SET_STRING(belle_sdp_media,protocol);
GET_SET_INT(belle_sdp_media,media_port,int)
GET_SET_INT(belle_sdp_media,port_count,int)
/************************
* base_description
***********************/
typedef struct _belle_sdp_base_description {
belle_sip_object_t base;
belle_sdp_info_t* info;
belle_sdp_connection_t* connection;
belle_sip_list_t* bandwidths;
belle_sip_list_t* attributes;
} belle_sdp_base_description_t;
static void belle_sdp_base_description_destroy(belle_sdp_base_description_t* base_description) {
if (base_description->info) belle_sip_object_unref(BELLE_SIP_OBJECT(base_description->info));
if (base_description->connection) belle_sip_object_unref(BELLE_SIP_OBJECT(base_description->connection));
belle_sip_list_free_with_data(base_description->bandwidths,belle_sip_object_freefunc);
belle_sip_list_free_with_data(base_description->attributes,belle_sip_object_freefunc);
}
static void belle_sdp_base_description_init(belle_sdp_base_description_t* base_description) {}
static void belle_sdp_base_description_clone(belle_sdp_base_description_t *base_description, const belle_sdp_base_description_t *orig){
if (orig->info) base_description->info = BELLE_SDP_INFO(belle_sip_object_clone_and_ref(BELLE_SIP_OBJECT(orig->info)));
if (orig->connection) base_description->connection = BELLE_SDP_CONNECTION(belle_sip_object_clone_and_ref(BELLE_SIP_OBJECT(orig->connection)));
base_description->bandwidths = belle_sip_list_copy_with_data(orig->bandwidths,belle_sip_object_copyfunc);
base_description->attributes = belle_sip_list_copy_with_data(orig->attributes,belle_sip_object_copyfunc);
}
belle_sip_error_code belle_sdp_base_description_marshal(belle_sdp_base_description_t* base_description, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error = BELLE_SIP_OK;
belle_sip_list_t* bandwidths;
if (base_description->info) {
error = belle_sip_object_marshal(BELLE_SIP_OBJECT(base_description->info), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
error = belle_sip_snprintf(buff, buff_size, offset, "\r\n");
if (error != BELLE_SIP_OK) return error;
}
if (base_description->connection) {
error = belle_sip_object_marshal(BELLE_SIP_OBJECT(base_description->connection), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
error = belle_sip_snprintf(buff, buff_size, offset, "\r\n");
if (error != BELLE_SIP_OK) return error;
}
for (bandwidths=base_description->bandwidths;bandwidths != NULL;bandwidths=bandwidths->next){
error = belle_sip_object_marshal(BELLE_SIP_OBJECT(bandwidths->data), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
error = belle_sip_snprintf(buff, buff_size, offset, "\r\n");
if (error != BELLE_SIP_OK) return error;
}
return error;
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sdp_base_description_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_sdp_base_description_t
,belle_sip_object_t
,belle_sdp_base_description_destroy
,belle_sdp_base_description_clone
,belle_sdp_base_description_marshal
,FALSE);
static int belle_sdp_base_description_attribute_comp_func(const belle_sdp_attribute_t* a, const char*b) {
return strcmp(a->name,b);
}
belle_sdp_attribute_t* belle_sdp_base_description_get_attribute(const belle_sdp_base_description_t* base_description, const char* name) {
belle_sip_list_t* attribute;
attribute = belle_sip_list_find_custom(base_description->attributes, (belle_sip_compare_func)belle_sdp_base_description_attribute_comp_func, name);
if (attribute) {
return ((belle_sdp_attribute_t*)attribute->data);
} else {
return NULL;
}
}
const char* belle_sdp_base_description_get_attribute_value(const belle_sdp_base_description_t* base_description, const char* name) {
belle_sdp_attribute_t* attribute = belle_sdp_base_description_get_attribute(base_description,name);
if (attribute) {
return belle_sdp_attribute_get_value(attribute);
} else return NULL;
}
belle_sip_list_t* belle_sdp_base_description_get_attributes(const belle_sdp_base_description_t* base_description) {
return base_description->attributes;
}
belle_sip_list_t* belle_sdp_base_description_find_attributes_with_name(const belle_sdp_base_description_t* base_description, const char* name) {
belle_sip_list_t* matches = NULL;
const belle_sip_list_t* attributes = belle_sdp_base_description_get_attributes(base_description);
for(;attributes!=NULL;attributes=attributes->next){
belle_sdp_attribute_t* attribute = ((belle_sdp_attribute_t*)attributes->data);
if (belle_sdp_base_description_attribute_comp_func(attribute,name)==0) {
matches = belle_sip_list_append(matches,belle_sip_object_ref(attribute));
}
}
return matches;
}
static int belle_sdp_base_description_bandwidth_comp_func(const belle_sdp_bandwidth_t* a, const char*b) {
return strcmp(a->type,b);
}
belle_sdp_bandwidth_t* belle_sdp_base_description_get_bandwidth(const belle_sdp_base_description_t *base_description, const char *name){
belle_sip_list_t* found = belle_sip_list_find_custom(base_description->bandwidths, (belle_sip_compare_func)belle_sdp_base_description_bandwidth_comp_func, name);
if( found ){
return ((belle_sdp_bandwidth_t*)found->data);
} else {
return NULL;
}
}
int belle_sdp_base_description_get_bandwidth_value(const belle_sdp_base_description_t* base_description, const char* name) {
belle_sip_list_t* bandwidth;
bandwidth = belle_sip_list_find_custom(base_description->bandwidths, (belle_sip_compare_func)belle_sdp_base_description_bandwidth_comp_func, name);
if (bandwidth) {
return ((belle_sdp_bandwidth_t*)bandwidth->data)->value;
} else {
return -1;
}
}
void belle_sdp_base_description_remove_attribute(belle_sdp_base_description_t* base_description,const char* name) {
belle_sip_list_t* attribute;
attribute = belle_sip_list_find_custom(base_description->attributes, (belle_sip_compare_func)belle_sdp_base_description_attribute_comp_func, name);
if (attribute) {
belle_sip_object_unref(BELLE_SIP_OBJECT(attribute->data));
base_description->attributes = belle_sip_list_delete_link(base_description->attributes,attribute);
}
}
void belle_sdp_base_description_remove_bandwidth(belle_sdp_base_description_t* base_description,const char* name) {
belle_sip_list_t* bandwidth;
bandwidth = belle_sip_list_find_custom(base_description->bandwidths, (belle_sip_compare_func)belle_sdp_base_description_bandwidth_comp_func, name);
if (bandwidth) {
belle_sip_object_unref(BELLE_SIP_OBJECT(bandwidth->data));
base_description->bandwidths = belle_sip_list_delete_link(base_description->bandwidths,bandwidth);
}
}
void belle_sdp_base_description_set_attribute_value(belle_sdp_base_description_t* base_description, const char* name, const char* value) {
belle_sdp_raw_attribute_t* attribute = belle_sdp_raw_attribute_new();
belle_sdp_attribute_set_name(BELLE_SDP_ATTRIBUTE(attribute),name);
belle_sdp_raw_attribute_set_value(attribute,value);
base_description->attributes = belle_sip_list_append(base_description->attributes,belle_sip_object_ref(attribute));
}
#define SPECIALIZED_ATTRIBUTE_HAS_INCORRECT_TYPE(attribute_ptr, attribute_name, attribute_type)\
(strcmp((attribute_ptr)->name, attribute_name) == 0 && !BELLE_SIP_IS_INSTANCE_OF(attribute_ptr, attribute_type))
void belle_sdp_base_description_add_attribute(belle_sdp_base_description_t* base_description, belle_sdp_attribute_t* attribute) {
/* Sanity check to avoid specialized attributes to be parsed as raw attribute as a fallback.
* The application code will be confused not to be able to cast the attribute in its specialized type.
*/
if (SPECIALIZED_ATTRIBUTE_HAS_INCORRECT_TYPE(attribute, "rtcp-fb", belle_sdp_rtcp_fb_attribute_t)
|| SPECIALIZED_ATTRIBUTE_HAS_INCORRECT_TYPE(attribute, "rtcp-xr", belle_sdp_rtcp_xr_attribute_t)
|| SPECIALIZED_ATTRIBUTE_HAS_INCORRECT_TYPE(attribute, "content", belle_sdp_content_attribute_t)
|| SPECIALIZED_ATTRIBUTE_HAS_INCORRECT_TYPE(attribute, "label", belle_sdp_label_attribute_t)
|| SPECIALIZED_ATTRIBUTE_HAS_INCORRECT_TYPE(attribute, "creq", belle_sdp_creq_attribute_t)
|| SPECIALIZED_ATTRIBUTE_HAS_INCORRECT_TYPE(attribute, "csup", belle_sdp_csup_attribute_t)
|| SPECIALIZED_ATTRIBUTE_HAS_INCORRECT_TYPE(attribute, "tcap", belle_sdp_tcap_attribute_t)
|| SPECIALIZED_ATTRIBUTE_HAS_INCORRECT_TYPE(attribute, "acap", belle_sdp_acap_attribute_t)
|| SPECIALIZED_ATTRIBUTE_HAS_INCORRECT_TYPE(attribute, "csup", belle_sdp_csup_attribute_t)
|| SPECIALIZED_ATTRIBUTE_HAS_INCORRECT_TYPE(attribute, "acfg", belle_sdp_acfg_attribute_t)
|| SPECIALIZED_ATTRIBUTE_HAS_INCORRECT_TYPE(attribute, "pcfg", belle_sdp_pcfg_attribute_t)
){
belle_sip_error("Erroneously parsed attribute with name [%s] and value [%s], skipped",
belle_sdp_attribute_get_name(attribute), belle_sdp_attribute_get_value(attribute));
belle_sip_object_unref(attribute);
return;
}
base_description->attributes = belle_sip_list_append(base_description->attributes,(void*)belle_sip_object_ref(BELLE_SIP_OBJECT(attribute)));
}
#define SET_LIST(list_name,value) \
belle_sip_list_t* list;\
if (list_name) {\
belle_sip_list_free_with_data(list_name,belle_sip_object_unref);\
} \
for (list=value;list != NULL; list=list->next) {\
belle_sip_object_ref(BELLE_SIP_OBJECT(list->data));\
}\
list_name=value;
void belle_sdp_base_description_set_attributes(belle_sdp_base_description_t* base_description, belle_sip_list_t* attributes) {
SET_LIST(base_description->attributes,attributes)
}
void belle_sdp_base_description_set_bandwidth(belle_sdp_base_description_t* base_description, const char* type, int value) {
belle_sdp_bandwidth_t* bandwidth = BELLE_SDP_BANDWIDTH(belle_sdp_base_description_get_bandwidth(base_description, type));
if( bandwidth == NULL ){
bandwidth= belle_sdp_bandwidth_new();
belle_sdp_bandwidth_set_type(bandwidth,type);
belle_sdp_bandwidth_set_value(bandwidth,value);
base_description->bandwidths = belle_sip_list_append(base_description->bandwidths,belle_sip_object_ref(bandwidth));
} else {
belle_sdp_bandwidth_set_value(bandwidth,value);
}
}
void belle_sdp_base_description_add_bandwidth(belle_sdp_base_description_t* base_description, const belle_sdp_bandwidth_t* bandwidth) {
base_description->bandwidths = belle_sip_list_append(base_description->bandwidths,(void *)belle_sip_object_ref((void *)bandwidth));
}
void belle_sdp_base_description_set_bandwidths(belle_sdp_base_description_t* base_description, belle_sip_list_t* bandwidths) {
SET_LIST(base_description->bandwidths,bandwidths)
}
/************************
* media_description
***********************/
struct _belle_sdp_media_description {
belle_sdp_base_description_t base_description;
belle_sdp_media_t* media;
};
void belle_sdp_media_description_destroy(belle_sdp_media_description_t* media_description) {
if (media_description->media) belle_sip_object_unref(BELLE_SIP_OBJECT((media_description->media)));
}
void belle_sdp_media_description_clone(belle_sdp_media_description_t *media_description, const belle_sdp_media_description_t *orig){
if (orig->media) media_description->media = BELLE_SDP_MEDIA(belle_sip_object_clone_and_ref(BELLE_SIP_OBJECT((orig->media))));
}
belle_sip_error_code belle_sdp_media_description_marshal(belle_sdp_media_description_t* media_description, char* buff, size_t buff_size, size_t *offset) {
belle_sip_list_t* attributes;
belle_sip_error_code error = belle_sip_object_marshal(BELLE_SIP_OBJECT(media_description->media), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
error = belle_sip_snprintf(buff, buff_size, offset, "\r\n");
if (error != BELLE_SIP_OK) return error;
error = belle_sdp_base_description_marshal(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
for (attributes=media_description->base_description.attributes;attributes != NULL;attributes=attributes->next){
error = belle_sip_object_marshal(BELLE_SIP_OBJECT(attributes->data), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
error = belle_sip_snprintf(buff, buff_size, offset, "\r\n");
if (error != BELLE_SIP_OK) return error;
}
return error;
}
BELLE_SDP_NEW(media_description,belle_sdp_base_description)
belle_sdp_media_description_t* belle_sdp_media_description_create(const char* media_type
,int media_port
,int port_count
,const char* protocol
,belle_sip_list_t* static_media_formats) {
belle_sdp_media_description_t* media_desc=belle_sdp_media_description_new();
belle_sdp_media_description_set_media(media_desc,belle_sdp_media_create(media_type,media_port,port_count,protocol,static_media_formats));
return media_desc;
}
BELLE_SDP_PARSE(media_description)
void belle_sdp_media_description_add_dynamic_payloads(belle_sdp_media_description_t* media_description, belle_sip_list_t* payloadNames, belle_sip_list_t* payloadValues) {
belle_sip_error("belle_sdp_media_description_add_dynamic_payloads not implemented yet");
}
belle_sdp_attribute_t* belle_sdp_media_description_get_attribute(const belle_sdp_media_description_t* media_description, const char* name) {
return belle_sdp_base_description_get_attribute(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t),name);
}
const char* belle_sdp_media_description_get_attribute_value(const belle_sdp_media_description_t* media_description, const char* name) {
return belle_sdp_base_description_get_attribute_value(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t),name);
}
belle_sip_list_t* belle_sdp_media_description_get_attributes(const belle_sdp_media_description_t* media_description) {
return BELLE_SIP_CAST(media_description,belle_sdp_base_description_t)->attributes;
}
belle_sip_list_t * belle_sdp_media_description_find_attributes_with_name(const belle_sdp_media_description_t *media_description, const char* name) {
return belle_sdp_base_description_find_attributes_with_name(BELLE_SIP_CAST(media_description, belle_sdp_base_description_t), name);
}
int belle_sdp_media_description_get_bandwidth(const belle_sdp_media_description_t* media_description, const char* name) {
return belle_sdp_base_description_get_bandwidth_value(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t),name);
}
belle_sip_list_t* belle_sdp_media_description_get_bandwidths(const belle_sdp_media_description_t* media_description) {
return BELLE_SIP_CAST(media_description,belle_sdp_base_description_t)->bandwidths;
}
belle_sdp_connection_t* belle_sdp_media_description_get_connection(const belle_sdp_media_description_t* media_description) {
return BELLE_SIP_CAST(media_description,belle_sdp_base_description_t)->connection;
}
belle_sdp_info_t* belle_sdp_media_description_get_info(const belle_sdp_media_description_t* media_description) {
return BELLE_SIP_CAST(media_description,belle_sdp_base_description_t)->info;
}
/*belle_sdp_key_t* belle_sdp_media_description_get_key(const belle_sdp_media_description_t* media_description);*/
belle_sdp_media_t* belle_sdp_media_description_get_media(const belle_sdp_media_description_t* media_description) {
return media_description->media;
}
void belle_sdp_media_description_add_attribute_holder(belle_sdp_media_description_t* media_description, belle_sdp_attribute_holder_t *holder) {
belle_sdp_base_description_add_attribute(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t), holder->attribute);
belle_sip_free(holder);
}
struct static_payload {
unsigned char number;
int channel_count;
const char* type;
int rate;
};
#define STATIC_PAYLOAD_LIST_LENTH 8
/*
* rfc 3551
* PT encoding media type clock rate channels
name (Hz)
___________________________________________________
0 PCMU A 8,000 1
1 reserved A
2 reserved A
3 GSM A 8,000 1
4 G723 A 8,000 1
5 DVI4 A 8,000 1
6 DVI4 A 16,000 1
7 LPC A 8,000 1
8 PCMA A 8,000 1
9 G722 A 8,000 1
10 L16 A 44,100 2
11 L16 A 44,100 1
12 QCELP A 8,000 1
13 CN A 8,000 1
14 MPA A 90,000 (see text)
15 G728 A 8,000 1
16 DVI4 A 11,025 1
17 DVI4 A 22,050 1
18 G729 A 8,000 1
Table 4: Payload types (PT) for audio encodings
PT encoding media type clock rate
name (Hz)
_____________________________________________
24 unassigned V
25 CelB V 90,000
26 JPEG V 90,000
27 unassigned V
28 nv V 90,000
29 unassigned V
30 unassigned V
31 H261 V 90,000
32 MPV V 90,000
33 MP2T AV 90,000
34 H263 V 90,000
Table 5: Payload types (PT) for video and combined
encodings
*
* */
const struct static_payload static_payload_list [] ={
/*audio*/
{0,1,"PCMU",8000},
{3,1,"GSM",8000},
{4,1,"G723",8000},
{5,1,"DVI4",8000},
{6,1,"DVI4",16000},
{7,1,"LPC",8000},
{8,1,"PCMA",8000},
{9,1,"G722",8000},
{10,2,"L16",44100},
{11,1,"L16",44100},
{12,1,"QCELP",8000},
{13,1,"CN",8000},
{14,1,"MPA",90000},
{15,1,"G728",8000},
{16,1,"DVI4",11025},
{17,1,"DVI4",22050},
{18,1,"G729",8000},
/*video*/
{25,0,"CelB",90000},
{26,0,"JPEG",90000},
{28,0,"nv",90000},
{31,0,"H261",90000},
{32,0,"MPV",90000},
{33,0,"MP2T",90000},
{34,0,"H263",90000}
};
static const size_t payload_list_elements=sizeof(static_payload_list)/sizeof(struct static_payload);
static int mime_parameter_is_static(const belle_sdp_mime_parameter_t *param){
const struct static_payload* iterator;
size_t i;
for (iterator = static_payload_list,i=0;inumber == param->media_format &&
strcasecmp(iterator->type,param->type)==0 &&
iterator->channel_count==param->channel_count &&
iterator->rate==param->rate ) {
return TRUE;
}
}
return FALSE;
}
static int mime_parameter_fill_from_static(belle_sdp_mime_parameter_t *mime_parameter,int format) {
const struct static_payload* iterator;
size_t i;
for (iterator = static_payload_list,i=0;inumber == format) {
belle_sdp_mime_parameter_set_type(mime_parameter,iterator->type);
belle_sdp_mime_parameter_set_rate(mime_parameter,iterator->rate);
belle_sdp_mime_parameter_set_channel_count(mime_parameter,iterator->channel_count);
break;
}
}
return 0;
}
static int mime_parameter_fill_from_rtpmap(belle_sdp_mime_parameter_t *mime_parameter, const char *rtpmap, int is_audio){
char *mime=belle_sip_strdup(rtpmap);
char *p=strchr(mime,'/');
if (p){
char *chans;
*p='\0';
p++;
chans=strchr(p,'/');
if (chans){
*chans='\0';
chans++;
belle_sdp_mime_parameter_set_channel_count(mime_parameter,atoi(chans));
}else if (is_audio) belle_sdp_mime_parameter_set_channel_count(mime_parameter,1); /*in absence of channel count, 1 is implicit for audio streams*/
belle_sdp_mime_parameter_set_rate(mime_parameter,atoi(p));
}
belle_sdp_mime_parameter_set_type(mime_parameter,mime);
belle_sip_free(mime);
return 0;
}
/* return the value of attr "field" for payload pt at line pos (field=rtpmap,fmtp...)*/
static const char *belle_sdp_media_description_a_attr_value_get_with_pt(const belle_sdp_media_description_t* media_description,int pt,const char *field)
{
int tmppt=0,scanned=0;
const char *tmp;
belle_sdp_attribute_t *attr;
belle_sip_list_t* attribute_list;
for ( attribute_list =belle_sdp_media_description_get_attributes(media_description)
;attribute_list != NULL
;attribute_list=attribute_list->next) {
attr = BELLE_SDP_ATTRIBUTE(attribute_list->data);
if (strcmp(field,belle_sdp_attribute_get_name(attr))==0 && belle_sdp_attribute_get_value(attr) != NULL){
int nb = sscanf(belle_sdp_attribute_get_value(attr),"%i %n",&tmppt,&scanned);
/* the return value may depend on how %n is interpreted by the libc: see manpage*/
if (nb == 1 || nb==2 ){
if (pt==tmppt){
tmp=belle_sdp_attribute_get_value(attr)+scanned;
if (strlen(tmp)>0)
return tmp;
}
}else belle_sip_warning("sdp has a strange a= line (%s) nb=%i",belle_sdp_attribute_get_value(attr),nb);
}
}
return NULL;
}
belle_sip_list_t* belle_sdp_media_description_build_mime_parameters(const belle_sdp_media_description_t* media_description) {
/*First, get media type*/
belle_sdp_media_t* media = belle_sdp_media_description_get_media(media_description);
belle_sip_list_t* mime_parameter_list=NULL;
belle_sip_list_t* media_formats=NULL;
belle_sdp_mime_parameter_t* mime_parameter;
const char* rtpmap=NULL;
const char* fmtp=NULL;
const char* ptime=NULL;
const char* max_ptime=NULL;
int ptime_as_int=-1;
int max_ptime_as_int=-1;
int is_audio=0;
if (!media) {
belle_sip_error("belle_sdp_media_description_build_mime_parameters: no media");
return NULL;
}
if (strcasecmp(belle_sdp_media_get_media_type(media),"audio")==0) is_audio=1;
ptime = belle_sdp_media_description_get_attribute_value(media_description,"ptime");
ptime?ptime_as_int=atoi(ptime):-1;
max_ptime = belle_sdp_media_description_get_attribute_value(media_description,"maxptime");
max_ptime?max_ptime_as_int=atoi(max_ptime):-1;
for (media_formats = belle_sdp_media_get_media_formats(media);media_formats != NULL;media_formats=media_formats->next) {
/*create mime parameters with format*/
mime_parameter = belle_sdp_mime_parameter_new();
belle_sdp_mime_parameter_set_ptime(mime_parameter,ptime_as_int);
belle_sdp_mime_parameter_set_max_ptime(mime_parameter,max_ptime_as_int);
belle_sdp_mime_parameter_set_media_format(mime_parameter,(int)(intptr_t)media_formats->data);
/*get rtpmap*/
rtpmap = belle_sdp_media_description_a_attr_value_get_with_pt(media_description
,belle_sdp_mime_parameter_get_media_format(mime_parameter)
,"rtpmap");
if (rtpmap) {
mime_parameter_fill_from_rtpmap(mime_parameter,rtpmap,is_audio);
}else{
mime_parameter_fill_from_static(mime_parameter,belle_sdp_mime_parameter_get_media_format(mime_parameter));
}
fmtp = belle_sdp_media_description_a_attr_value_get_with_pt(media_description
,belle_sdp_mime_parameter_get_media_format(mime_parameter)
,"fmtp");
if (fmtp) {
belle_sdp_mime_parameter_set_parameters(mime_parameter,fmtp);
}
mime_parameter_list=belle_sip_list_append(mime_parameter_list,mime_parameter);
}
return mime_parameter_list;
}
#define MAX_FMTP_LENGTH 512
void belle_sdp_media_description_append_values_from_mime_parameter(belle_sdp_media_description_t* media_description, const belle_sdp_mime_parameter_t* mime_parameter) {
belle_sdp_media_t* media = belle_sdp_media_description_get_media(media_description);
char atribute_value [MAX_FMTP_LENGTH];
int current_ptime=0;
int current_max_ptime=0;
belle_sdp_media_set_media_formats(media,belle_sip_list_append(belle_sdp_media_get_media_formats(media)
,(void*)(intptr_t)(belle_sdp_mime_parameter_get_media_format(mime_parameter))));
if (belle_sdp_media_description_get_attribute_value(media_description,"ptime")) {
current_ptime=atoi(belle_sdp_media_description_get_attribute_value(media_description,"ptime"));
belle_sdp_media_description_remove_attribute(media_description,"ptime");
}
if (belle_sdp_media_description_get_attribute_value(media_description,"maxptime")) {
current_max_ptime=atoi(belle_sdp_media_description_get_attribute_value(media_description,"maxptime"));
belle_sdp_media_description_remove_attribute(media_description,"maxptime");
}
#ifndef BELLE_SDP_FORCE_RTP_MAP /* defined to for RTP map even for static codec*/
if (!mime_parameter_is_static(mime_parameter)) {
/*dynamic payload*/
#endif
if (belle_sdp_mime_parameter_get_channel_count(mime_parameter)>1) {
snprintf(atribute_value,MAX_FMTP_LENGTH,"%i %s/%i/%i"
,belle_sdp_mime_parameter_get_media_format(mime_parameter)
,belle_sdp_mime_parameter_get_type(mime_parameter)
,belle_sdp_mime_parameter_get_rate(mime_parameter)
,belle_sdp_mime_parameter_get_channel_count(mime_parameter));
} else {
snprintf(atribute_value,MAX_FMTP_LENGTH,"%i %s/%i"
,belle_sdp_mime_parameter_get_media_format(mime_parameter)
,belle_sdp_mime_parameter_get_type(mime_parameter)
,belle_sdp_mime_parameter_get_rate(mime_parameter));
}
belle_sdp_media_description_set_attribute_value(media_description,"rtpmap",atribute_value);
#ifndef BELLE_SDP_FORCE_RTP_MAP
}
#endif
// always include fmtp parameters if available
if (belle_sdp_mime_parameter_get_parameters(mime_parameter)) {
snprintf(atribute_value,MAX_FMTP_LENGTH,"%i %s"
,belle_sdp_mime_parameter_get_media_format(mime_parameter)
,belle_sdp_mime_parameter_get_parameters(mime_parameter));
belle_sdp_media_description_set_attribute_value(media_description,"fmtp",atribute_value);
}
if (belle_sdp_mime_parameter_get_ptime(mime_parameter)>current_ptime) {
current_ptime=belle_sdp_mime_parameter_get_ptime(mime_parameter);
}
if (current_ptime>0){
char ptime[12];
snprintf(ptime,sizeof(ptime),"%i",current_ptime);
belle_sdp_media_description_set_attribute_value(media_description,"ptime",ptime);
}
if (belle_sdp_mime_parameter_get_max_ptime(mime_parameter)>current_max_ptime) {
current_max_ptime=belle_sdp_mime_parameter_get_max_ptime(mime_parameter);
}
if (current_max_ptime>0){
char max_ptime[12];
snprintf(max_ptime,sizeof(max_ptime),"%i",current_max_ptime);
belle_sdp_media_description_set_attribute_value(media_description,"maxptime",max_ptime);
}
}
belle_sip_list_t* belle_sdp_media_description_get_mime_types(const belle_sdp_media_description_t* media_description) {
belle_sip_error("belle_sdp_media_description_get_mime_types: not implemented yet");
return NULL;
}
void belle_sdp_media_description_remove_attribute(belle_sdp_media_description_t* media_description,const char* name) {
belle_sdp_base_description_remove_attribute(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t),name);
}
void belle_sdp_media_description_remove_bandwidth(belle_sdp_media_description_t* media_description,const char* name) {
belle_sdp_base_description_remove_bandwidth(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t),name);
}
void belle_sdp_media_description_set_attribute_value(belle_sdp_media_description_t* media_description, const char* name, const char* value) {
belle_sdp_base_description_set_attribute_value(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t),name,value);
}
void belle_sdp_media_description_set_attributes(belle_sdp_media_description_t* media_description, belle_sip_list_t* value) {
belle_sdp_base_description_set_attributes(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t),value);
}
void belle_sdp_media_description_add_attribute(belle_sdp_media_description_t* media_description, belle_sdp_attribute_t* attribute) {
belle_sdp_base_description_add_attribute(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t),attribute);
}
void belle_sdp_media_description_set_bandwidth(belle_sdp_media_description_t* media_description, const char* type, int value) {
belle_sdp_base_description_set_bandwidth(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t),type,value);
}
void belle_sdp_media_description_add_bandwidth(belle_sdp_media_description_t* media_description, belle_sdp_bandwidth_t* bandwidth) {
belle_sdp_base_description_add_bandwidth(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t),bandwidth);
}
void belle_sdp_media_description_set_bandwidths(belle_sdp_media_description_t* media_description, belle_sip_list_t* bandwidths) {
belle_sdp_base_description_set_bandwidths(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t),bandwidths);
}
#define SET_OBJECT(object,param,param_type) \
param_type** current = &object->param; \
if (param) belle_sip_object_ref(param); \
if (*current) { \
belle_sip_object_unref(BELLE_SIP_OBJECT(*current)); \
} \
*current=param; \
void belle_sdp_media_description_set_connection(belle_sdp_media_description_t* media_description, belle_sdp_connection_t* connection) {
SET_OBJECT(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t),connection,belle_sdp_connection_t)
}
void belle_sdp_media_description_set_info(belle_sdp_media_description_t* media_description,belle_sdp_info_t* info) {
SET_OBJECT(BELLE_SIP_CAST(media_description,belle_sdp_base_description_t),info,belle_sdp_info_t)
}
void belle_sdp_media_description_set_media(belle_sdp_media_description_t* media_description, belle_sdp_media_t* media) {
SET_OBJECT(media_description,media,belle_sdp_media_t)
}
/************************
* origin
***********************/
struct _belle_sdp_origin {
belle_sip_object_t base;
const char* address;
const char* address_type;
const char* network_type;
const char* username;
unsigned int session_id;
unsigned int session_version;
};
void belle_sdp_origin_destroy(belle_sdp_origin_t* origin) {
DESTROY_STRING(origin,address)
DESTROY_STRING(origin,address_type)
DESTROY_STRING(origin,network_type)
DESTROY_STRING(origin,username)
}
void belle_sdp_origin_clone(belle_sdp_origin_t *origin, const belle_sdp_origin_t *orig){
CLONE_STRING(belle_sdp_origin,username,origin,orig);
CLONE_STRING(belle_sdp_origin,address,origin,orig);
CLONE_STRING(belle_sdp_origin,address_type,origin,orig);
CLONE_STRING(belle_sdp_origin,network_type,origin,orig);
origin->session_id = orig->session_id;
origin->session_version = orig->session_version;
}
belle_sip_error_code belle_sdp_origin_marshal(belle_sdp_origin_t* origin, char* buff, size_t buff_size, size_t *offset) {
return belle_sip_snprintf( buff
,buff_size
,offset
,"o=%s %u %u %s %s %s"
,origin->username
,origin->session_id
,origin->session_version
,origin->network_type
,origin->address_type
,origin->address);
}
BELLE_SDP_NEW(origin,belle_sip_object)
belle_sdp_origin_t* belle_sdp_origin_create(const char* user_name
, unsigned int session_id
, unsigned int session_version
, const char* network_type
, const char* addr_type
, const char* address) {
belle_sdp_origin_t* origin=belle_sdp_origin_new();
belle_sdp_origin_set_username(origin,user_name);
belle_sdp_origin_set_session_id(origin,session_id);
belle_sdp_origin_set_session_version(origin,session_version);
belle_sdp_origin_set_network_type(origin,network_type);
belle_sdp_origin_set_address_type(origin,addr_type);
belle_sdp_origin_set_address(origin,address);
return origin;
}
BELLE_SDP_PARSE(origin)
GET_SET_STRING(belle_sdp_origin,username);
GET_SET_STRING(belle_sdp_origin,address);
GET_SET_STRING(belle_sdp_origin,address_type);
GET_SET_STRING(belle_sdp_origin,network_type);
GET_SET_INT(belle_sdp_origin,session_id,unsigned int);
GET_SET_INT(belle_sdp_origin,session_version,unsigned int);
/************************
* session_name
***********************/
struct _belle_sdp_session_name {
belle_sip_object_t base;
const char* value;
};
void belle_sdp_session_name_destroy(belle_sdp_session_name_t* session_name) {
DESTROY_STRING(session_name,value)
}
void belle_sdp_session_name_clone(belle_sdp_session_name_t *session_name, const belle_sdp_session_name_t *orig){
CLONE_STRING(belle_sdp_session_name,value,session_name,orig);
}
belle_sip_error_code belle_sdp_session_name_marshal(belle_sdp_session_name_t* session_name, char* buff, size_t buff_size, size_t *offset) {
return belle_sip_snprintf(buff,buff_size,offset,"s=%s",session_name->value);
}
BELLE_SDP_NEW(session_name,belle_sip_object)
belle_sdp_session_name_t* belle_sdp_session_name_create (const char* name) {
belle_sdp_session_name_t* n=belle_sdp_session_name_new();
belle_sdp_session_name_set_value(n,name);
return n;
}
GET_SET_STRING(belle_sdp_session_name,value);
/************************
* session_description
***********************/
struct _belle_sdp_session_description {
belle_sdp_base_description_t base_description;
belle_sdp_version_t* version;
belle_sip_list_t* emails;
belle_sdp_origin_t* origin;
belle_sdp_session_name_t* session_name;
belle_sip_list_t* phones;
belle_sip_list_t* times;
belle_sdp_uri_t* uri;
belle_sdp_uri_t* zone_adjustments;
belle_sip_list_t* media_descriptions;
};
void belle_sdp_session_description_destroy(belle_sdp_session_description_t* session_description) {
if (session_description->version) belle_sip_object_unref(BELLE_SIP_OBJECT(session_description->version));
belle_sip_list_free_with_data(session_description->emails,belle_sip_object_freefunc);
if (session_description->origin) belle_sip_object_unref(BELLE_SIP_OBJECT(session_description->origin));
if (session_description->session_name) belle_sip_object_unref(BELLE_SIP_OBJECT(session_description->session_name));
belle_sip_list_free_with_data(session_description->phones,belle_sip_object_freefunc);
belle_sip_list_free_with_data(session_description->times,belle_sip_object_freefunc);
if (session_description->uri) belle_sip_object_unref(BELLE_SIP_OBJECT(session_description->uri));
if (session_description->zone_adjustments) belle_sip_object_unref(BELLE_SIP_OBJECT(session_description->zone_adjustments));
belle_sip_list_free_with_data(session_description->media_descriptions,belle_sip_object_freefunc);
}
void belle_sdp_session_description_clone(belle_sdp_session_description_t *session_description, const belle_sdp_session_description_t *orig){
if (orig->version) session_description->version = BELLE_SDP_VERSION(belle_sip_object_clone_and_ref(BELLE_SIP_OBJECT(orig->version)));
session_description->emails = belle_sip_list_copy_with_data(orig->emails,belle_sip_object_copyfunc);
if (orig->origin) session_description->origin = BELLE_SDP_ORIGIN(belle_sip_object_clone_and_ref(BELLE_SIP_OBJECT(orig->origin)));
if (orig->session_name) session_description->session_name = BELLE_SDP_SESSION_NAME(belle_sip_object_clone_and_ref(BELLE_SIP_OBJECT(orig->session_name)));
session_description->phones = belle_sip_list_copy_with_data(orig->phones,belle_sip_object_copyfunc);
session_description->times = belle_sip_list_copy_with_data(orig->times,belle_sip_object_copyfunc);
if (orig->uri) session_description->uri = BELLE_SDP_URI(belle_sip_object_clone_and_ref(BELLE_SIP_OBJECT(orig->uri)));
if (orig->zone_adjustments) session_description->zone_adjustments = BELLE_SDP_URI(belle_sip_object_clone_and_ref(BELLE_SIP_OBJECT(orig->zone_adjustments)));
session_description->media_descriptions = belle_sip_list_copy_with_data(orig->media_descriptions,belle_sip_object_copyfunc);
}
belle_sip_error_code belle_sdp_session_description_marshal(belle_sdp_session_description_t* session_description, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error = BELLE_SIP_OK;
belle_sip_list_t* media_descriptions;
belle_sip_list_t* times;
belle_sip_list_t* attributes;
if (session_description->version) {
error = belle_sip_object_marshal(BELLE_SIP_OBJECT(session_description->version), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
error = belle_sip_snprintf(buff, buff_size, offset, "\r\n");
if (error != BELLE_SIP_OK) return error;
}
if (session_description->origin) {
error = belle_sip_object_marshal(BELLE_SIP_OBJECT(session_description->origin), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
error = belle_sip_snprintf(buff, buff_size, offset, "\r\n");
if (error != BELLE_SIP_OK) return error;
}
if (session_description->session_name) {
error = belle_sip_object_marshal(BELLE_SIP_OBJECT(session_description->session_name), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
error = belle_sip_snprintf(buff, buff_size, offset, "\r\n");
if (error != BELLE_SIP_OK) return error;
}
error = belle_sdp_base_description_marshal((belle_sdp_base_description_t*)(&session_description->base_description),buff,buff_size, offset);
if (error != BELLE_SIP_OK) return error;
error = belle_sip_snprintf(buff, buff_size, offset, "t=");
if (error != BELLE_SIP_OK) return error;
for (times=session_description->times;times != NULL;times=times->next){
error = belle_sip_object_marshal(BELLE_SIP_OBJECT(times->data), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
error = belle_sip_snprintf(buff, buff_size, offset, "\r\n");
if (error != BELLE_SIP_OK) return error;
}
for (attributes=session_description->base_description.attributes;attributes != NULL;attributes=attributes->next){
error = belle_sip_object_marshal(BELLE_SIP_OBJECT(attributes->data), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
error = belle_sip_snprintf(buff, buff_size, offset, "\r\n");
if (error != BELLE_SIP_OK) return error;
}
for (media_descriptions=session_description->media_descriptions;media_descriptions != NULL;media_descriptions=media_descriptions->next){
error = belle_sip_object_marshal(BELLE_SIP_OBJECT(media_descriptions->data), buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
}
return error;
}
BELLE_SDP_NEW(session_description,belle_sdp_base_description)
BELLE_SDP_PARSE(session_description)
belle_sip_list_t * belle_sdp_session_description_get_attributes(const belle_sdp_session_description_t *session_description) {
return belle_sdp_base_description_get_attributes(BELLE_SIP_CAST(session_description, belle_sdp_base_description_t));
}
belle_sip_list_t * belle_sdp_session_description_find_attributes_with_name(const belle_sdp_session_description_t *session_description, const char* name) {
return belle_sdp_base_description_find_attributes_with_name(BELLE_SIP_CAST(session_description, belle_sdp_base_description_t), name);
}
const char* belle_sdp_session_description_get_attribute_value(const belle_sdp_session_description_t* session_description, const char* name) {
return belle_sdp_base_description_get_attribute_value(BELLE_SIP_CAST(session_description,belle_sdp_base_description_t),name);
}
const belle_sdp_attribute_t* belle_sdp_session_description_get_attribute(const belle_sdp_session_description_t* session_description, const char* name) {
return belle_sdp_base_description_get_attribute(BELLE_SIP_CAST(session_description,belle_sdp_base_description_t),name);
}
int belle_sdp_session_description_get_bandwidth(const belle_sdp_session_description_t* session_description, const char* name) {
return belle_sdp_base_description_get_bandwidth_value(BELLE_SIP_CAST(session_description,belle_sdp_base_description_t),name);
}
belle_sip_list_t* belle_sdp_session_description_get_bandwidths(const belle_sdp_session_description_t* session_description) {
return BELLE_SIP_CAST(session_description,belle_sdp_base_description_t)->bandwidths;
}
belle_sdp_connection_t* belle_sdp_session_description_get_connection(const belle_sdp_session_description_t* session_description) {
return BELLE_SIP_CAST(session_description,belle_sdp_base_description_t)->connection;
}
belle_sip_list_t* belle_sdp_session_description_get_emails(const belle_sdp_session_description_t* session_description){
return session_description->emails;
}
belle_sdp_info_t* belle_sdp_session_description_get_info(const belle_sdp_session_description_t* session_description) {
return BELLE_SIP_CAST(session_description,belle_sdp_base_description_t)->info;
}
belle_sip_list_t* belle_sdp_session_description_get_media_descriptions(const belle_sdp_session_description_t* session_description) {
return session_description->media_descriptions;
}
belle_sdp_origin_t* belle_sdp_session_description_get_origin(const belle_sdp_session_description_t* session_description){
return session_description->origin;
}
belle_sip_list_t* belle_sdp_session_description_get_phones(const belle_sdp_session_description_t* session_description) {
return session_description->phones;
}
belle_sdp_session_name_t* belle_sdp_session_description_get_session_name(const belle_sdp_session_description_t* session_description) {
return session_description->session_name;
}
belle_sip_list_t* belle_sdp_session_description_get_time_descriptions(const belle_sdp_session_description_t* session_description) {
return session_description->times;
}
belle_sdp_uri_t* belle_sdp_session_description_get_uri(const belle_sdp_session_description_t* session_description) {
return session_description->uri;
}
belle_sdp_version_t* belle_sdp_session_description_get_version(const belle_sdp_session_description_t* session_description) {
return session_description->version;
}
belle_sdp_uri_t* belle_sdp_session_description_get_zone_adjustments(const belle_sdp_session_description_t* session_description) {
return session_description->zone_adjustments;
}
void belle_sdp_session_description_remove_attribute(belle_sdp_session_description_t* session_description, const char* name) {
belle_sdp_base_description_remove_attribute(BELLE_SIP_CAST(session_description,belle_sdp_base_description_t),name);
}
void belle_sdp_session_description_remove_bandwidth(belle_sdp_session_description_t* session_description, const char* name) {
belle_sdp_base_description_remove_bandwidth(BELLE_SIP_CAST(session_description,belle_sdp_base_description_t),name);
}
void belle_sdp_session_description_set_attribute_value(belle_sdp_session_description_t* session_description, const char* name, const char* value) {
belle_sdp_base_description_set_attribute_value(BELLE_SIP_CAST(session_description,belle_sdp_base_description_t),name,value);
}
void belle_sdp_session_description_set_attributes(belle_sdp_session_description_t* session_description, belle_sip_list_t* attributes) {
belle_sdp_base_description_set_attributes(BELLE_SIP_CAST(session_description,belle_sdp_base_description_t),attributes);
}
void belle_sdp_session_description_add_attribute(belle_sdp_session_description_t* session_description, belle_sdp_attribute_t* attribute) {
belle_sdp_base_description_add_attribute(BELLE_SIP_CAST(session_description,belle_sdp_base_description_t),attribute);
}
void belle_sdp_session_description_set_bandwidth(belle_sdp_session_description_t* session_description, const char* type, int value) {
belle_sdp_base_description_set_bandwidth(BELLE_SIP_CAST(session_description,belle_sdp_base_description_t),type,value);
}
void belle_sdp_session_description_set_bandwidths(belle_sdp_session_description_t* session_description, belle_sip_list_t* bandwidths) {
belle_sdp_base_description_set_bandwidths(BELLE_SIP_CAST(session_description,belle_sdp_base_description_t),bandwidths);
}
void belle_sdp_session_description_add_bandwidth(belle_sdp_session_description_t* session_description, belle_sdp_bandwidth_t* bandwidth) {
belle_sdp_base_description_add_bandwidth(BELLE_SIP_CAST(session_description,belle_sdp_base_description_t),bandwidth);
}
void belle_sdp_session_description_set_connection(belle_sdp_session_description_t* session_description, belle_sdp_connection_t* connection) {
SET_OBJECT(BELLE_SIP_CAST(session_description,belle_sdp_base_description_t),connection,belle_sdp_connection_t)
}
void belle_sdp_session_description_set_emails(belle_sdp_session_description_t* session_description, belle_sip_list_t* emails) {
SET_LIST(session_description->emails,emails)
}
void belle_sdp_session_description_set_info(belle_sdp_session_description_t* session_description, belle_sdp_info_t* info) {
SET_OBJECT(BELLE_SIP_CAST(session_description,belle_sdp_base_description_t),info,belle_sdp_info_t)
}
void belle_sdp_session_description_set_media_descriptions(belle_sdp_session_description_t* session_description, belle_sip_list_t* media_descriptions) {
SET_LIST(session_description->media_descriptions,media_descriptions)
}
void belle_sdp_session_description_add_media_description(belle_sdp_session_description_t* session_description, belle_sdp_media_description_t* media_description) {
session_description->media_descriptions = belle_sip_list_append(session_description->media_descriptions,belle_sip_object_ref(media_description));
}
void belle_sdp_session_description_set_origin(belle_sdp_session_description_t* session_description, belle_sdp_origin_t* origin) {
SET_OBJECT(session_description,origin,belle_sdp_origin_t)
}
void belle_sdp_session_description_set_phones(belle_sdp_session_description_t* session_description, belle_sip_list_t* phones) {
SET_LIST(session_description->phones,phones)
}
void belle_sdp_session_description_set_session_name(belle_sdp_session_description_t* session_description, belle_sdp_session_name_t* session_name) {
SET_OBJECT(session_description,session_name,belle_sdp_session_name_t)
}
void belle_sdp_session_description_set_time_descriptions(belle_sdp_session_description_t* session_description, belle_sip_list_t* times) {
SET_LIST(session_description->times,times)
}
void belle_sdp_session_description_set_time_description(belle_sdp_session_description_t* session_description, belle_sdp_time_description_t* time_desc) {
belle_sdp_session_description_set_time_descriptions(session_description,belle_sip_list_new(time_desc));
}
void belle_sdp_session_description_set_uri(belle_sdp_session_description_t* session_description, belle_sdp_uri_t* uri) {
SET_OBJECT(session_description,uri,belle_sdp_uri_t)
}
void belle_sdp_session_description_set_version(belle_sdp_session_description_t* session_description, belle_sdp_version_t* version) {
SET_OBJECT(session_description,version,belle_sdp_version_t)
}
void belle_sdp_session_description_set_zone_adjustments(belle_sdp_session_description_t* session_description, belle_sdp_uri_t* zone_adjustments) {
SET_OBJECT(session_description,zone_adjustments,belle_sdp_uri_t)
}
void belle_sdp_session_description_add_attribute_holder(belle_sdp_session_description_t* session_description, belle_sdp_attribute_holder_t *holder) {
belle_sdp_base_description_add_attribute(BELLE_SIP_CAST(session_description,belle_sdp_base_description_t), holder->attribute);
belle_sip_free(holder);
}
/************************
* time
***********************/
struct _belle_sdp_time {
belle_sip_object_t base;
long long start;
long long stop;
};
void belle_sdp_time_destroy(belle_sdp_time_t* time) {
}
void belle_sdp_time_clone(belle_sdp_time_t *time, const belle_sdp_time_t *orig){
time->start=orig->start;
time->stop=orig->stop;
}
belle_sip_error_code belle_sdp_time_marshal(belle_sdp_time_t* time, char* buff, size_t buff_size, size_t *offset) {
return belle_sip_snprintf(buff,buff_size,offset,"%lld %lld",time->start,time->stop);
}
BELLE_SDP_NEW(time,belle_sip_object)
GET_SET_INT(belle_sdp_time,start,long long);
GET_SET_INT(belle_sdp_time,stop,long long);
/************************
* time description
***********************/
struct _belle_sdp_time_description {
belle_sip_object_t base;
belle_sdp_time_t* time;
};
void belle_sdp_time_description_destroy(belle_sdp_time_description_t* time_description) {
if (time_description->time) belle_sip_object_unref(BELLE_SIP_OBJECT(time_description->time));
}
void belle_sdp_time_description_clone(belle_sdp_time_description_t *time_description, const belle_sdp_time_description_t *orig){
if (orig->time) time_description->time = BELLE_SDP_TIME(belle_sip_object_clone_and_ref(BELLE_SIP_OBJECT(orig->time)));
}
belle_sip_error_code belle_sdp_time_description_marshal(belle_sdp_time_description_t* time_description, char* buff, size_t buff_size, size_t *offset) {
return belle_sip_object_marshal(BELLE_SIP_OBJECT(time_description->time), buff, buff_size, offset);
}
BELLE_SDP_NEW(time_description,belle_sip_object)
belle_sdp_time_description_t* belle_sdp_time_description_create (long long start,long long stop) {
belle_sdp_time_description_t* time_desc= belle_sdp_time_description_new();
belle_sdp_time_t* time = belle_sdp_time_new();
belle_sdp_time_set_start(time,start);
belle_sdp_time_set_stop(time,stop);
belle_sdp_time_description_set_time(time_desc,time);
return time_desc;
}
belle_sip_list_t* belle_sdp_time_description_get_repeate_times(const belle_sdp_time_description_t* time_description) {
return NULL;
}
belle_sdp_time_t* belle_sdp_time_description_get_time(const belle_sdp_time_description_t* time_description) {
return time_description->time;
}
void belle_sdp_time_description_set_repeate_times(belle_sdp_time_description_t* time_description, belle_sip_list_t* times) {
belle_sip_error("time description repeat time not implemented");
}
void belle_sdp_time_description_set_time(belle_sdp_time_description_t* time_description, belle_sdp_time_t* time) {
SET_OBJECT(time_description,time,belle_sdp_time_t)
}
/************************
* version
***********************/
struct _belle_sdp_version {
belle_sip_object_t base;
int version;
};
void belle_sdp_version_destroy(belle_sdp_version_t* version) {
}
void belle_sdp_version_clone(belle_sdp_version_t *version, const belle_sdp_version_t *orig){
version->version = orig->version;
}
belle_sip_error_code belle_sdp_version_marshal(belle_sdp_version_t* version, char* buff, size_t buff_size, size_t *offset) {
return belle_sip_snprintf(buff,buff_size,offset,"v=%i",version->version);
}
BELLE_SDP_NEW(version,belle_sip_object)
belle_sdp_version_t* belle_sdp_version_create(int version) {
belle_sdp_version_t* v = belle_sdp_version_new();
belle_sdp_version_set_version(v,version);
return v;
}
GET_SET_INT(belle_sdp_version,version,int);
/***************************************************************************************
* mime_parameter
*
**************************************************************************************/
static void belle_sdp_mime_parameter_destroy(belle_sdp_mime_parameter_t *mime_parameter) {
if (mime_parameter->type) belle_sip_free((void*)mime_parameter->type);
if (mime_parameter->parameters) belle_sip_free((void*)mime_parameter->parameters);
}
static void belle_sdp_mime_parameter_clone(belle_sdp_mime_parameter_t *mime_parameter,belle_sdp_mime_parameter_t *orig) {
mime_parameter->rate = orig->rate;
mime_parameter->channel_count = orig->channel_count;
mime_parameter->ptime = orig->ptime;
mime_parameter->max_ptime = orig->max_ptime;
mime_parameter->media_format = orig->media_format;
CLONE_STRING(belle_sdp_mime_parameter,type,mime_parameter,orig);
CLONE_STRING(belle_sdp_mime_parameter,parameters,mime_parameter,orig);
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sdp_mime_parameter_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_sdp_mime_parameter_t
,belle_sip_object_t
,belle_sdp_mime_parameter_destroy
,belle_sdp_mime_parameter_clone
,NULL
,TRUE);
belle_sdp_mime_parameter_t* belle_sdp_mime_parameter_new() {
belle_sdp_mime_parameter_t* l_param = belle_sip_object_new(belle_sdp_mime_parameter_t);
l_param->ptime = -1;
l_param->max_ptime = -1;
return l_param;
}
belle_sdp_mime_parameter_t* belle_sdp_mime_parameter_create(const char* type, int media_format, int rate,int channel_count) {
belle_sdp_mime_parameter_t* mime_param= belle_sdp_mime_parameter_new();
belle_sdp_mime_parameter_set_type(mime_param,type);
belle_sdp_mime_parameter_set_media_format(mime_param,media_format);
belle_sdp_mime_parameter_set_rate(mime_param,rate);
belle_sdp_mime_parameter_set_channel_count(mime_param,channel_count);
return mime_param;
}
GET_SET_INT(belle_sdp_mime_parameter,rate,int);
GET_SET_INT(belle_sdp_mime_parameter,channel_count,int);
GET_SET_INT(belle_sdp_mime_parameter,ptime,int);
GET_SET_INT(belle_sdp_mime_parameter,max_ptime,int);
GET_SET_INT(belle_sdp_mime_parameter,media_format,int);
GET_SET_STRING(belle_sdp_mime_parameter,type);
GET_SET_STRING(belle_sdp_mime_parameter,parameters);
belle-sip-5.2.0+dfsg/src/belle_sip_dict.c 0000664 0000000 0000000 00000007625 14346131365 0020225 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "belle-sip/dict.h"
#include "belle-sip/object.h"
#include "belle-sip/belle-sip.h"
#include "belle_sip_internal.h"
#define BELLE_SIP_DICT(obj) BELLE_SIP_CAST(obj,belle_sip_dict_t)
static void belle_sip_dict_string_destroy( void* data )
{
belle_sip_free(data);
}
static void* belle_sip_dict_string_clone( const char* str, void* data )
{
(void)str;
return belle_sip_strdup((const char*)data);
}
belle_sip_dict_t* belle_sip_dict_create()
{
return belle_sip_object_new(belle_sip_dict_t);
}
static void belle_sip_dict_destroy( belle_sip_dict_t* obj)
{
}
void belle_sip_dict_set_int(belle_sip_dict_t* obj, const char* key, int value)
{
char tmp[30];
snprintf(tmp,sizeof(tmp),"%i",value);
belle_sip_dict_set_string(obj, key, tmp);
}
int belle_sip_dict_get_int(belle_sip_dict_t* obj, const char* key, int default_value)
{
const char *str=belle_sip_object_data_get(BELLE_SIP_OBJECT(obj),key);
if (str!=NULL) {
int ret=0;
if (strstr(str,"0x")==str){
sscanf(str,"%x",&ret);
}else ret=atoi(str);
return ret;
}
else return default_value;
}
void belle_sip_dict_set_string(belle_sip_dict_t* obj, const char*key, const char*value)
{
belle_sip_object_data_set( BELLE_SIP_OBJECT(obj), key, (void*)belle_sip_strdup(value), belle_sip_dict_string_destroy );
}
const char* belle_sip_dict_get_string(belle_sip_dict_t* obj, const char* key, const char* default_value)
{
void* data = belle_sip_object_data_get( BELLE_SIP_OBJECT(obj), key );
if( data ) return (const char *)data;
else return default_value;
}
void belle_sip_dict_set_int64(belle_sip_dict_t* obj, const char* key, int64_t value)
{
char tmp[30];
#if defined (_MSC_VER)
snprintf(tmp,sizeof(tmp),"%I64d",value);
#else
snprintf(tmp,sizeof(tmp),"%" PRId64"",value);
#endif
belle_sip_dict_set_string(obj,key,tmp);
}
int64_t belle_sip_dict_get_int64(belle_sip_dict_t* obj, const char* key, int64_t default_value)
{
const char *str= belle_sip_object_data_get( BELLE_SIP_OBJECT(obj), key );
if (str!=NULL) {
#ifdef _WIN32
return (int64_t)_atoi64(str);
#else
return atoll(str);
#endif
}
else return default_value;
}
int belle_sip_dict_remove(belle_sip_dict_t* obj, const char*key)
{
return belle_sip_object_data_remove(BELLE_SIP_OBJECT(obj), key);
}
void belle_sip_dict_clone( const belle_sip_dict_t* src, belle_sip_dict_t* dst)
{
belle_sip_dict_clear(dst);
belle_sip_dict_merge(src, dst);
}
void belle_sip_dict_merge( const belle_sip_dict_t* src, belle_sip_dict_t* dst)
{
belle_sip_object_data_merge(BELLE_SIP_OBJECT(src), BELLE_SIP_OBJECT(dst), belle_sip_dict_string_clone);
}
int belle_sip_dict_haskey(const belle_sip_dict_t* obj, const char* key)
{
return belle_sip_object_data_exists(BELLE_SIP_OBJECT(obj), key);
}
void belle_sip_dict_foreach(const belle_sip_dict_t* obj, void (*apply_func)(const char*, void*, void*), void* userdata)
{
belle_sip_object_data_foreach(BELLE_SIP_OBJECT(obj),apply_func, userdata);
}
void belle_sip_dict_clear(belle_sip_dict_t* obj)
{
belle_sip_object_data_clear(BELLE_SIP_OBJECT(obj));
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_dict_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_sip_dict_t, belle_sip_object_t,
belle_sip_dict_destroy,
NULL,
NULL,
TRUE);
belle-sip-5.2.0+dfsg/src/belle_sip_headers_impl.c 0000664 0000000 0000000 00000272231 14346131365 0021733 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "belle-sip/headers.h"
#include "belle-sip/parameters.h"
#include
#include
#include
#include "grammars/belle_sip_messageLexer.h"
#include "grammars/belle_sip_messageParser.h"
#include "belle_sip_internal.h"
#include "listeningpoint_internal.h"
/************************
* header
***********************/
GET_SET_STRING(belle_sip_header,name);
#define PROTO_SIP 0x1
#define PROTO_HTTP 0x1<<1
typedef belle_sip_header_t* (*header_parse_func)(const char*);
struct header_name_func_pair {
int protocol;
const char* name;
header_parse_func func;
};
static struct header_name_func_pair header_table[] = {
{PROTO_SIP, "m", (header_parse_func)belle_sip_header_contact_parse}
,{PROTO_SIP, BELLE_SIP_CONTACT, (header_parse_func)belle_sip_header_contact_parse}
,{PROTO_SIP, "f", (header_parse_func)belle_sip_header_from_parse}
,{PROTO_SIP, BELLE_SIP_FROM, (header_parse_func)belle_sip_header_from_parse}
,{PROTO_SIP, "t", (header_parse_func)belle_sip_header_to_parse}
,{PROTO_SIP, BELLE_SIP_TO, (header_parse_func)belle_sip_header_to_parse}
,{PROTO_SIP, "d", (header_parse_func)belle_sip_header_diversion_parse}
,{PROTO_SIP, BELLE_SIP_DIVERSION, (header_parse_func)belle_sip_header_diversion_parse}
,{PROTO_SIP, "i", (header_parse_func)belle_sip_header_call_id_parse}
,{PROTO_SIP, BELLE_SIP_CALL_ID, (header_parse_func)belle_sip_header_call_id_parse}
,{PROTO_SIP, "r", (header_parse_func)belle_sip_header_retry_after_parse}
,{PROTO_SIP, BELLE_SIP_RETRY_AFTER, (header_parse_func)belle_sip_header_retry_after_parse}
,{PROTO_SIP, "l", (header_parse_func)belle_sip_header_content_length_parse}
,{PROTO_SIP|PROTO_HTTP, BELLE_SIP_CONTENT_LENGTH, (header_parse_func)belle_sip_header_content_length_parse}
,{PROTO_SIP, "c", (header_parse_func)belle_sip_header_content_type_parse}
,{PROTO_SIP|PROTO_HTTP, BELLE_SIP_CONTENT_TYPE, (header_parse_func)belle_sip_header_content_type_parse}
,{PROTO_SIP, BELLE_SIP_CSEQ, (header_parse_func)belle_sip_header_cseq_parse}
,{PROTO_SIP, BELLE_SIP_ROUTE, (header_parse_func)belle_sip_header_route_parse}
,{PROTO_SIP, BELLE_SIP_RECORD_ROUTE, (header_parse_func)belle_sip_header_record_route_parse}
,{PROTO_SIP, "v", (header_parse_func)belle_sip_header_via_parse}
,{PROTO_SIP, BELLE_SIP_VIA, (header_parse_func)belle_sip_header_via_parse}
,{PROTO_SIP, "x", (header_parse_func)belle_sip_header_session_expires_parse}
,{PROTO_SIP, BELLE_SIP_SESSION_EXPIRES, (header_parse_func)belle_sip_header_session_expires_parse}
,{PROTO_SIP, BELLE_SIP_AUTHORIZATION, (header_parse_func)belle_sip_header_authorization_parse}
,{PROTO_SIP, BELLE_SIP_PROXY_AUTHORIZATION, (header_parse_func)belle_sip_header_proxy_authorization_parse}
,{PROTO_SIP|PROTO_HTTP, BELLE_SIP_WWW_AUTHENTICATE, (header_parse_func)belle_sip_header_www_authenticate_parse}
,{PROTO_SIP|PROTO_HTTP, BELLE_SIP_PROXY_AUTHENTICATE, (header_parse_func)belle_sip_header_proxy_authenticate_parse}
,{PROTO_SIP, BELLE_SIP_MAX_FORWARDS, (header_parse_func)belle_sip_header_max_forwards_parse}
,{PROTO_SIP|PROTO_HTTP, BELLE_SIP_USER_AGENT, (header_parse_func)belle_sip_header_user_agent_parse}
,{PROTO_SIP, BELLE_SIP_EXPIRES, (header_parse_func)belle_sip_header_expires_parse}
,{PROTO_SIP|PROTO_HTTP, BELLE_SIP_ALLOW, (header_parse_func)belle_sip_header_allow_parse}
,{PROTO_SIP, BELLE_SIP_SUBSCRIPTION_STATE, (header_parse_func)belle_sip_header_subscription_state_parse}
,{PROTO_SIP, BELLE_SIP_SERVICE_ROUTE, (header_parse_func)belle_sip_header_service_route_parse}
,{PROTO_SIP, BELLE_SIP_REFER_TO, (header_parse_func)belle_sip_header_refer_to_parse}
,{PROTO_SIP, BELLE_SIP_REFERRED_BY, (header_parse_func)belle_sip_header_referred_by_parse}
,{PROTO_SIP, BELLE_SIP_REPLACES, (header_parse_func)belle_sip_header_replaces_parse}
,{PROTO_SIP, BELLE_SIP_DATE, (header_parse_func)belle_sip_header_date_parse}
,{PROTO_SIP, BELLE_SIP_P_PREFERRED_IDENTITY, (header_parse_func)belle_sip_header_p_preferred_identity_parse}
,{PROTO_SIP, BELLE_SIP_PRIVACY, (header_parse_func)belle_sip_header_privacy_parse}
,{PROTO_SIP, BELLE_SIP_EVENT, (header_parse_func)belle_sip_header_event_parse}
,{PROTO_SIP, "o", (header_parse_func)belle_sip_header_event_parse}
,{PROTO_SIP, BELLE_SIP_SUPPORTED, (header_parse_func)belle_sip_header_supported_parse}
,{PROTO_SIP, "k", (header_parse_func)belle_sip_header_supported_parse}
,{PROTO_SIP, BELLE_SIP_REQUIRE, (header_parse_func)belle_sip_header_require_parse}
,{PROTO_SIP, BELLE_SIP_CONTENT_DISPOSITION, (header_parse_func)belle_sip_header_content_disposition_parse}
,{PROTO_SIP, BELLE_SIP_ACCEPT, (header_parse_func)belle_sip_header_accept_parse}
,{PROTO_SIP, BELLE_SIP_REASON, (header_parse_func)belle_sip_header_reason_parse}
,{PROTO_SIP, BELLE_SIP_AUTHENTICATION_INFO, (header_parse_func)belle_sip_header_authentication_info_parse}
};
static belle_sip_header_t* belle_header_create(const char* name,const char* value,int protocol) {
size_t i;
belle_sip_header_t* ret;
size_t elements =sizeof(header_table)/sizeof(struct header_name_func_pair);
if (!name || name[0]=='\0') {
belle_sip_error("Cannot create header without name");
return NULL;
}
for(i=0;iname) belle_sip_free(header->name);
if (header->unparsed_value) belle_sip_free(header->unparsed_value);
if (header->next) belle_sip_object_unref(BELLE_SIP_OBJECT(header->next));
}
void belle_sip_header_set_next(belle_sip_header_t* header,belle_sip_header_t* next) {
if (next) belle_sip_object_ref(next);
if (header->next) belle_sip_object_unref(header->next);
header->next = next;
}
belle_sip_header_t* belle_sip_header_get_next(const belle_sip_header_t* header) {
return header->next;
}
const char *belle_sip_header_get_unparsed_value(belle_sip_header_t* obj) {
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(obj,belle_sip_header_extension_t)) {
return belle_sip_header_extension_get_value(BELLE_SIP_HEADER_EXTENSION(obj));
} else {
char *tmp=belle_sip_object_to_string(obj);
char *ret;
char *end;
if (obj->unparsed_value) {
belle_sip_free(obj->unparsed_value);
obj->unparsed_value=NULL;
}
obj->unparsed_value=tmp;
ret=tmp;
ret+=strlen(obj->name)+1; /* name + semicolon*/
for(;*ret==' ';ret++) {};/*skip spaces*/
return ret;
}
}
belle_sip_error_code belle_sip_header_marshal(belle_sip_header_t* header, char* buff, size_t buff_size, size_t *offset) {
if (header->name) {
return belle_sip_snprintf(buff,buff_size,offset,"%s: ",header->name);
} else {
belle_sip_warning("no header name found");
return BELLE_SIP_OK;
}
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_header_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_sip_header_t,belle_sip_object_t,belle_sip_header_destroy,belle_sip_header_clone,belle_sip_header_marshal,TRUE);
BELLE_SIP_PARSE(header)
/************************
* header_address
***********************/
struct _belle_sip_header_address {
belle_sip_parameters_t base;
char* displayname;
belle_sip_uri_t* uri;
belle_generic_uri_t* absolute_uri;
unsigned char automatic;
};
static void belle_sip_header_address_init(belle_sip_header_address_t* object) {
belle_sip_parameters_init((belle_sip_parameters_t*)object); /*super*/
}
static void belle_sip_header_address_destroy(belle_sip_header_address_t* address) {
if (address->displayname) belle_sip_free(address->displayname);
if (address->uri) belle_sip_object_unref(address->uri);
if (address->absolute_uri) belle_sip_object_unref(address->absolute_uri);
}
static void _belle_sip_header_address_clone(belle_sip_header_address_t *addr, const belle_sip_header_address_t *orig) {
CLONE_STRING(belle_sip_header_address,displayname,addr,orig)
if (belle_sip_header_address_get_uri(orig)) {
belle_sip_header_address_set_uri(addr,BELLE_SIP_URI(belle_sip_object_clone(BELLE_SIP_OBJECT(belle_sip_header_address_get_uri(orig)))));
}
if (belle_sip_header_address_get_absolute_uri(orig)) {
belle_sip_header_address_set_absolute_uri(addr,BELLE_GENERIC_URI(belle_sip_object_clone(BELLE_SIP_OBJECT(belle_sip_header_address_get_absolute_uri(orig)))));
}
if (belle_sip_header_address_get_automatic(orig)) {
belle_sip_header_address_set_automatic(addr,belle_sip_header_address_get_automatic(orig));
}
belle_sip_parameters_copy_parameters_from(&addr->base, &orig->base);
}
belle_sip_header_address_t* belle_sip_header_address_clone(const belle_sip_header_address_t* orig) {
belle_sip_header_address_t* new_address = belle_sip_header_address_new();
_belle_sip_header_address_clone(new_address, orig);
return new_address;
}
static belle_sip_error_code _belle_sip_header_address_marshal(belle_sip_header_address_t* header, char* buff, size_t buff_size, size_t *offset, int force_angle_quote) {
belle_sip_error_code error=BELLE_SIP_OK;
/*1 display name*/
if (header->displayname) {
char* escaped_display_name = belle_sip_display_name_to_backslashed_escaped_string(header->displayname);
error=belle_sip_snprintf(buff,buff_size,offset,"\"%s\" ",escaped_display_name);
belle_sip_free(escaped_display_name);
if (error!=BELLE_SIP_OK) return error;
}
if (header->uri || header->absolute_uri) {
/*cases where < is required*/
if (force_angle_quote
|| header->displayname
|| header->absolute_uri
|| belle_sip_parameters_get_parameter_names((belle_sip_parameters_t*)header->uri)
|| belle_sip_uri_get_header_names(header->uri)
|| belle_sip_parameters_get_parameter_names(&header->base)) {
error=belle_sip_snprintf(buff,buff_size,offset,"%s","<");
if (error!=BELLE_SIP_OK) return error;
}
if (header->uri) {
error=belle_sip_uri_marshal(header->uri,buff,buff_size,offset);
} else {
error=belle_generic_uri_marshal(header->absolute_uri,buff,buff_size,offset);
}
if (error!=BELLE_SIP_OK) return error;
if (force_angle_quote
|| header->displayname
|| header->absolute_uri
|| belle_sip_parameters_get_parameter_names((belle_sip_parameters_t*)header->uri)
|| belle_sip_uri_get_header_names(header->uri)
|| belle_sip_parameters_get_parameter_names(&header->base)) {
error=belle_sip_snprintf(buff,buff_size,offset,"%s",">");
if (error!=BELLE_SIP_OK) return error;
}
}
error=belle_sip_parameters_marshal(&header->base,buff,buff_size,offset);
if (error!=BELLE_SIP_OK) return error;
return error;
}
belle_sip_error_code belle_sip_header_address_marshal(belle_sip_header_address_t* header, char* buff, size_t buff_size, size_t *offset) {
return _belle_sip_header_address_marshal(header, buff, buff_size, offset, FALSE);
}
#define belle_sip_header_address_clone _belle_sip_header_address_clone /*because public clone function is not the one to be used internally*/
BELLE_SIP_NEW_HEADER(header_address,parameters,"header_address")
BELLE_SIP_PARSE(header_address)
GET_SET_STRING(belle_sip_header_address,displayname);
void belle_sip_header_address_set_quoted_displayname(belle_sip_header_address_t* address,const char* value) {
if (address->displayname != NULL) belle_sip_free(address->displayname);
if (strlen(value)>2)
address->displayname=_belle_sip_str_dup_and_unquote_string(value);
else
address->displayname=NULL;
}
belle_sip_uri_t* belle_sip_header_address_get_uri(const belle_sip_header_address_t* address) {
return address->uri;
}
void belle_sip_header_address_set_uri(belle_sip_header_address_t* address, belle_sip_uri_t* uri) {
if (uri) belle_sip_object_ref(uri);
if (address->uri) {
belle_sip_object_unref(address->uri);
}
address->uri=uri;
if (address->absolute_uri && uri) {
belle_sip_warning("sip absolute uri [%p] already set for header_address [%p], cleaning it",address->absolute_uri, address);
belle_sip_header_address_set_absolute_uri(address,NULL);
}
}
void belle_sip_header_address_set_automatic(belle_sip_header_address_t *address, int automatic) {
address->automatic = (unsigned char)automatic;
}
int belle_sip_header_address_get_automatic(const belle_sip_header_address_t *address) {
return address->automatic;
}
belle_generic_uri_t* belle_sip_header_address_get_absolute_uri(const belle_sip_header_address_t* address) {
return address->absolute_uri;
}
void belle_sip_header_address_set_absolute_uri(belle_sip_header_address_t* address, belle_generic_uri_t* absolute_uri) {
belle_sip_object_ref(absolute_uri);
if (address->absolute_uri) {
belle_sip_object_unref(address->absolute_uri);
}
address->absolute_uri=absolute_uri;
if (address->uri && absolute_uri) {
belle_sip_warning("sip uri [%p] already set for header_address [%p], cleaning it",address->uri, address);
belle_sip_header_address_set_uri(address,NULL);
}
}
belle_sip_header_address_t* belle_sip_header_address_create(const char* display, belle_sip_uri_t* uri) {
belle_sip_header_address_t* address = belle_sip_header_address_new();
belle_sip_header_address_set_displayname(address,display);
belle_sip_header_address_set_uri(address,uri);
return address;
}
belle_sip_header_address_t* belle_sip_header_address_create2(const char* display, belle_generic_uri_t* uri) {
belle_sip_header_address_t* address = belle_sip_header_address_new();
belle_sip_header_address_set_displayname(address,display);
belle_sip_header_address_set_absolute_uri(address,uri);
return address;
}
int belle_sip_header_address_equals(const belle_sip_header_address_t* addr_a, const belle_sip_header_address_t* addr_b) {
// Addresses are not identical if either is NULL
if (!addr_a | !addr_b) return -1;
belle_sip_uri_t* uri_a = belle_sip_header_address_get_uri(addr_a);
belle_sip_uri_t* uri_b = belle_sip_header_address_get_uri(addr_b);
// URIs are not identical if either is NULL
if (!uri_a | !uri_b) return -1;
const bool_t uri_equal = (belle_sip_uri_equals(uri_a, uri_b) != 0);
const char* displayname_a = belle_sip_header_address_get_displayname(addr_a);
const char* displayname_b = belle_sip_header_address_get_displayname(addr_b);
bool_t displayname_equal = FALSE;
if (displayname_a && displayname_b) {
displayname_equal = (strcmp(displayname_a, displayname_b) == 0);
} else if (!displayname_a & !displayname_b) {
displayname_equal = TRUE;
}
return ((uri_equal && displayname_equal) ? 0 : -1);
}
/*fast header address implemenation*/
typedef belle_sip_header_address_t belle_sip_fast_header_address_t;
#define belle_sip_fast_header_address_parse belle_sip_header_address_fast_parse
BELLE_SIP_PARSE(fast_header_address)
/******************************
* Extension header inherits from header
*
******************************/
struct _belle_sip_header_allow {
belle_sip_header_t header;
const char* method;
};
static void belle_sip_header_allow_clone(belle_sip_header_allow_t *allow, const belle_sip_header_allow_t *orig) {
CLONE_STRING(belle_sip_header_allow,method,allow,orig)
}
static void belle_sip_header_allow_destroy(belle_sip_header_allow_t* allow) {
if (allow->method) belle_sip_free((void*)allow->method);
}
belle_sip_error_code belle_sip_header_allow_marshal(belle_sip_header_allow_t* allow, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(allow), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s",allow->method);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW_HEADER(header_allow,header,"Allow")
BELLE_SIP_PARSE(header_allow)
belle_sip_header_allow_t* belle_sip_header_allow_create (const char* methods) {
belle_sip_header_allow_t* allow = belle_sip_header_allow_new();
belle_sip_header_allow_set_method(allow,methods);
return allow;
}
GET_SET_STRING(belle_sip_header_allow,method);
/************************
* header_contact
***********************/
struct _belle_sip_header_contact {
belle_sip_header_address_t address;
unsigned char wildcard;
unsigned char unknown;
unsigned char pad[2];
};
void belle_sip_header_contact_destroy(belle_sip_header_contact_t* contact) {
}
void belle_sip_header_contact_clone(belle_sip_header_contact_t *contact, const belle_sip_header_contact_t *orig) {
contact->wildcard=orig->wildcard;
}
belle_sip_error_code belle_sip_header_contact_marshal(belle_sip_header_contact_t* contact, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(contact), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
if (contact->wildcard) {
error=belle_sip_snprintf(buff,buff_size,offset,"%s","*");
} else {
error=belle_sip_header_address_marshal(&contact->address, buff, buff_size, offset);
}
return error;
}
BELLE_SIP_NEW_HEADER(header_contact,header_address,BELLE_SIP_CONTACT)
BELLE_SIP_PARSE(header_contact)
belle_sip_header_contact_t* belle_sip_header_contact_create (const belle_sip_header_address_t* contact) {
belle_sip_header_contact_t* header = belle_sip_header_contact_new();
_belle_sip_object_copy(BELLE_SIP_OBJECT(header),BELLE_SIP_OBJECT(contact));
belle_sip_header_set_next(BELLE_SIP_HEADER(header),NULL); /*make sure only one header is kept*/
belle_sip_header_set_name(BELLE_SIP_HEADER(header),BELLE_SIP_CONTACT); /*restaure header name*/
return header;
}
GET_SET_INT_PARAM_PRIVATE(belle_sip_header_contact,expires,int,_)
GET_SET_INT_PARAM_PRIVATE(belle_sip_header_contact,q,float,_);
GET_SET_BOOL(belle_sip_header_contact,wildcard,is);
int belle_sip_header_contact_set_expires(belle_sip_header_contact_t* contact, int expires) {
if (expires < 0 ) {
belle_sip_error("bad expires value [%i] for contact",expires);
return -1;
}
_belle_sip_header_contact_set_expires(contact,expires);
return 0;
}
int belle_sip_header_contact_set_qvalue(belle_sip_header_contact_t* contact, float qValue) {
if (qValue != -1 && qValue < 0 && qValue >1) {
belle_sip_error("bad q value [%f] for contact",qValue);
return -1;
}
_belle_sip_header_contact_set_q(contact,qValue);
return 0;
}
float belle_sip_header_contact_get_qvalue(const belle_sip_header_contact_t* contact) {
return belle_sip_header_contact_get_q(contact);
}
unsigned int belle_sip_header_contact_equals(const belle_sip_header_contact_t* a,const belle_sip_header_contact_t* b) {
if (!a | !b) return 0;
return belle_sip_uri_equals(belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(a))
,belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(b)));
}
unsigned int belle_sip_header_contact_not_equals(const belle_sip_header_contact_t* a,const belle_sip_header_contact_t* b) {
return !belle_sip_header_contact_equals(a,b);
}
unsigned int belle_sip_header_contact_equals_with_uri_omitting(const belle_sip_header_contact_t* a,const belle_sip_header_contact_t* b) {
if (!a | !b) return 0;
return belle_sip_uri_equals_with_uri_omitting(belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(a))
,belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(b)));
}
unsigned int belle_sip_header_contact_not_equals_with_uri_omitting(const belle_sip_header_contact_t* a,const belle_sip_header_contact_t* b) {
return !belle_sip_header_contact_equals_with_uri_omitting(a,b);
}
void belle_sip_header_contact_set_automatic(belle_sip_header_contact_t *a, int enabled) {
belle_sip_header_address_set_automatic((belle_sip_header_address_t*)a, enabled);
}
int belle_sip_header_contact_get_automatic(const belle_sip_header_contact_t *a) {
return belle_sip_header_address_get_automatic((belle_sip_header_address_t*)a);
}
void belle_sip_header_contact_set_unknown(belle_sip_header_contact_t *a, int value) {
a->unknown=value;
}
int belle_sip_header_contact_is_unknown(const belle_sip_header_contact_t *a) {
return a->unknown;
}
/**************************
* From header object inherit from header_address
***************************/
#define BELLE_SIP_FROM_LIKE_MARSHAL(header,force_angle_quote) \
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(header), buff, buff_size, offset);\
if (error!=BELLE_SIP_OK) return error;\
error=_belle_sip_header_address_marshal(&header->address, buff, buff_size, offset, force_angle_quote); \
if (error!=BELLE_SIP_OK) return error;\
return error;
struct _belle_sip_header_from {
belle_sip_header_address_t address;
};
static void belle_sip_header_from_destroy(belle_sip_header_from_t* from) {
}
static void belle_sip_header_from_clone(belle_sip_header_from_t* from, const belle_sip_header_from_t* cloned) {
}
belle_sip_error_code belle_sip_header_from_marshal(belle_sip_header_from_t* from, char* buff, size_t buff_size, size_t *offset) {
BELLE_SIP_FROM_LIKE_MARSHAL(from,FALSE);
}
belle_sip_header_from_t* belle_sip_header_from_create2(const char *uri, const char *tag) {
belle_sip_header_address_t* address = belle_sip_header_address_parse(uri);
if (address) {
belle_sip_header_from_t* from = belle_sip_header_from_create(address,tag);
belle_sip_object_unref(address);
return from;
} else
return NULL;
}
belle_sip_header_from_t* belle_sip_header_from_create(const belle_sip_header_address_t* address, const char *tag) {
belle_sip_header_from_t* header= belle_sip_header_from_new();
belle_sip_uri_t* uri;
_belle_sip_object_copy((belle_sip_object_t*)header,(belle_sip_object_t*)address);
/*clear unwanted uri components*/
if ((uri=belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(header)))) {
belle_sip_parameters_t* params=BELLE_SIP_PARAMETERS(uri);
belle_sip_parameters_remove_parameter(params,"lr");
belle_sip_parameters_remove_parameter(params,"ttl");
belle_sip_parameters_remove_parameter(params,"method");
belle_sip_parameters_remove_parameter(params,"maddr");
belle_sip_parameters_remove_parameter(params,"transport");
belle_sip_uri_set_port(uri,0);
belle_sip_uri_headers_clean(uri);
}
belle_sip_header_set_next(BELLE_SIP_HEADER(header),NULL); /*make sure only one header is kept*/
belle_sip_header_set_name(BELLE_SIP_HEADER(header),BELLE_SIP_FROM); /*restore header name*/
if (tag) belle_sip_header_from_set_tag(header,tag);
return header;
}
BELLE_SIP_NEW_HEADER(header_from,header_address,BELLE_SIP_FROM)
BELLE_SIP_PARSE(header_from)
GET_SET_STRING_PARAM2(belle_sip_header_from,tag,raw_tag);
void belle_sip_header_from_set_random_tag(belle_sip_header_from_t *obj) {
char tmp[BELLE_SIP_TAG_LENGTH];
belle_sip_header_from_set_raw_tag(obj,belle_sip_random_token(tmp,sizeof(tmp)));
}
void belle_sip_header_from_set_tag(belle_sip_header_from_t *obj, const char *tag) {
if (tag==BELLE_SIP_RANDOM_TAG) belle_sip_header_from_set_random_tag(obj);
else belle_sip_header_from_set_raw_tag(obj,tag);
}
const char *belle_sip_header_from_get_tag(const belle_sip_header_from_t *obj) {
return belle_sip_header_from_get_raw_tag(obj);
}
/**************************
* To header object inherits from header_address
***************************/
struct _belle_sip_header_to {
belle_sip_header_address_t address;
};
static void belle_sip_header_to_destroy(belle_sip_header_to_t* to) {
}
void belle_sip_header_to_clone(belle_sip_header_to_t *contact, const belle_sip_header_to_t *orig) {
}
belle_sip_error_code belle_sip_header_to_marshal(belle_sip_header_to_t* to, char* buff, size_t buff_size, size_t *offset) {
BELLE_SIP_FROM_LIKE_MARSHAL(to,FALSE)
}
BELLE_SIP_NEW_HEADER(header_to,header_address,BELLE_SIP_TO)
BELLE_SIP_PARSE(header_to)
GET_SET_STRING_PARAM2(belle_sip_header_to,tag,raw_tag);
belle_sip_header_to_t* belle_sip_header_to_create2(const char *uri, const char *tag) {
belle_sip_header_address_t* address = belle_sip_header_address_parse(uri);
if (address) {
belle_sip_header_to_t* to = belle_sip_header_to_create(address,tag);
belle_sip_object_unref(address);
return to;
} else
return NULL;
}
belle_sip_header_to_t* belle_sip_header_to_create(const belle_sip_header_address_t* address, const char *tag) {
belle_sip_header_to_t* header= belle_sip_header_to_new();
belle_sip_uri_t* uri;
_belle_sip_object_copy((belle_sip_object_t*)header,(belle_sip_object_t*)address);
/*clear unwanted uri components*/
if ((uri=belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(header)))) {
belle_sip_parameters_t* params=BELLE_SIP_PARAMETERS(uri);
belle_sip_parameters_remove_parameter(params,"lr");
belle_sip_parameters_remove_parameter(params,"ttl");
belle_sip_parameters_remove_parameter(params,"method");
belle_sip_parameters_remove_parameter(params,"maddr");
belle_sip_parameters_remove_parameter(params,"transport");
belle_sip_uri_set_port(uri,0);
belle_sip_uri_headers_clean(uri);
}
belle_sip_header_set_next(BELLE_SIP_HEADER(header),NULL); /*make sure only one header is kept*/
belle_sip_header_set_name(BELLE_SIP_HEADER(header),BELLE_SIP_TO); /*restaure header name*/
if (tag) belle_sip_header_to_set_tag(header,tag);
return header;
}
void belle_sip_header_to_set_random_tag(belle_sip_header_to_t *obj) {
char tmp[8];
/*not less than 32bit */
belle_sip_header_to_set_tag(obj,belle_sip_random_token(tmp,sizeof(tmp)));
}
void belle_sip_header_to_set_tag(belle_sip_header_to_t *obj, const char *tag) {
if (tag==BELLE_SIP_RANDOM_TAG) belle_sip_header_to_set_random_tag(obj);
else belle_sip_header_to_set_raw_tag(obj,tag);
}
const char *belle_sip_header_to_get_tag(const belle_sip_header_to_t *obj) {
return belle_sip_header_to_get_raw_tag(obj);
}
/**************************
* Diversion header object inherits from header_address
***************************/
struct _belle_sip_header_diversion {
belle_sip_header_address_t address;
};
static void belle_sip_header_diversion_destroy(belle_sip_header_diversion_t* diversion) {
}
void belle_sip_header_diversion_clone(belle_sip_header_diversion_t *contact, const belle_sip_header_diversion_t *orig) {
}
belle_sip_error_code belle_sip_header_diversion_marshal(belle_sip_header_diversion_t* diversion, char* buff, size_t buff_size, size_t *offset) {
BELLE_SIP_FROM_LIKE_MARSHAL(diversion,FALSE)
}
BELLE_SIP_NEW_HEADER(header_diversion,header_address,BELLE_SIP_DIVERSION)
BELLE_SIP_PARSE(header_diversion)
GET_SET_STRING_PARAM2(belle_sip_header_diversion,tag,raw_tag);
belle_sip_header_diversion_t* belle_sip_header_diversion_create2(const char *uri, const char *tag) {
belle_sip_header_address_t* address = belle_sip_header_address_parse(uri);
if (address) {
belle_sip_header_diversion_t* diversion = belle_sip_header_diversion_create(address,tag);
belle_sip_object_unref(address);
return diversion;
} else
return NULL;
}
belle_sip_header_diversion_t* belle_sip_header_diversion_create(const belle_sip_header_address_t* address, const char *tag) {
belle_sip_header_diversion_t* header= belle_sip_header_diversion_new();
belle_sip_uri_t* uri;
_belle_sip_object_copy((belle_sip_object_t*)header,(belle_sip_object_t*)address);
/*clear unwanted uri components*/
if ((uri=belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(header)))) {
belle_sip_parameters_t* params=BELLE_SIP_PARAMETERS(uri);
belle_sip_parameters_remove_parameter(params,"lr");
belle_sip_parameters_remove_parameter(params,"ttl");
belle_sip_parameters_remove_parameter(params,"method");
belle_sip_parameters_remove_parameter(params,"maddr");
belle_sip_parameters_remove_parameter(params,"transport");
belle_sip_uri_set_port(uri,0);
belle_sip_uri_headers_clean(uri);
}
belle_sip_header_set_name(BELLE_SIP_HEADER(header),BELLE_SIP_DIVERSION); /*restaure header name*/
if (tag) belle_sip_header_diversion_set_tag(header,tag);
return header;
}
void belle_sip_header_diversion_set_random_tag(belle_sip_header_diversion_t *obj) {
char tmp[8];
/*not less than 32bit */
belle_sip_header_diversion_set_tag(obj,belle_sip_random_token(tmp,sizeof(tmp)));
}
void belle_sip_header_diversion_set_tag(belle_sip_header_diversion_t *obj, const char *tag) {
if (tag==BELLE_SIP_RANDOM_TAG) belle_sip_header_diversion_set_random_tag(obj);
else belle_sip_header_diversion_set_raw_tag(obj,tag);
}
const char *belle_sip_header_diversion_get_tag(const belle_sip_header_diversion_t *obj) {
return belle_sip_header_diversion_get_raw_tag(obj);
}
/******************************
* Session-Expires inherits from params
******************************/
struct _belle_sip_header_session_expires {
belle_sip_parameters_t params_list;
int delta;
};
static void belle_sip_header_session_expires_destroy(belle_sip_header_session_expires_t* session_expires) {}
static void belle_sip_header_session_expires_clone(belle_sip_header_session_expires_t* session_expires, const belle_sip_header_session_expires_t* orig) {
session_expires->delta = orig->delta;
belle_sip_header_session_expires_set_refresher_value(session_expires, belle_sip_header_session_expires_get_refresher_value(orig));
}
belle_sip_error_code belle_sip_header_session_expires_marshal(belle_sip_header_session_expires_t* session_expires, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error = belle_sip_header_marshal(BELLE_SIP_HEADER(session_expires), buff, buff_size, offset);
if (session_expires->delta) {
error = belle_sip_snprintf(buff, buff_size, offset, "%i", session_expires->delta);
if (error!=BELLE_SIP_OK) return error;
}
error = belle_sip_parameters_marshal(&session_expires->params_list, buff, buff_size, offset);
if (error != BELLE_SIP_OK) return error;
return error;
}
belle_sip_header_session_expires_t* belle_sip_header_session_expires_create(int delta, belle_sip_header_session_expires_refresher_t refresher) {
belle_sip_header_session_expires_t *session_expires = belle_sip_header_session_expires_new();
belle_sip_header_session_expires_set_delta(session_expires, delta);
if (refresher != BELLE_SIP_HEADER_SESSION_EXPIRES_UNSPECIFIED) {
belle_sip_header_session_expires_set_refresher_value(session_expires, refresher);
}
return session_expires;
}
BELLE_SIP_PARSE(header_session_expires)
BELLE_SIP_NEW_HEADER(header_session_expires, parameters, BELLE_SIP_SESSION_EXPIRES)
GET_SET_STRING_PARAM(belle_sip_header_session_expires, refresher)
GET_SET_INT(belle_sip_header_session_expires, delta, int)
belle_sip_header_session_expires_refresher_t belle_sip_header_session_expires_get_refresher_value(const belle_sip_header_session_expires_t* session_expires) {
const char* refresher_value = belle_sip_header_session_expires_get_refresher(session_expires);
if (refresher_value == NULL) {
return BELLE_SIP_HEADER_SESSION_EXPIRES_UNSPECIFIED;
} else if (strcmp("uac", refresher_value) == 0) {
return BELLE_SIP_HEADER_SESSION_EXPIRES_UAC;
} else if (strcmp("uas", refresher_value) == 0) {
return BELLE_SIP_HEADER_SESSION_EXPIRES_UAS;
}
return BELLE_SIP_HEADER_SESSION_EXPIRES_UNSPECIFIED;
}
void belle_sip_header_session_expires_set_refresher_value(belle_sip_header_session_expires_t* session_expires, belle_sip_header_session_expires_refresher_t refresher_value) {
switch (refresher_value)
{
case BELLE_SIP_HEADER_SESSION_EXPIRES_UNSPECIFIED:
belle_sip_parameters_remove_parameter(BELLE_SIP_PARAMETERS(session_expires), "refresher");
break;
case BELLE_SIP_HEADER_SESSION_EXPIRES_UAC:
belle_sip_header_session_expires_set_refresher(session_expires, "uac");
break;
case BELLE_SIP_HEADER_SESSION_EXPIRES_UAS:
belle_sip_header_session_expires_set_refresher(session_expires, "uas");
break;
}
}
/******************************
* User-Agent header inherits from header
******************************/
struct _belle_sip_header_user_agent {
belle_sip_header_t header;
belle_sip_list_t* products;
};
static void belle_sip_header_user_agent_destroy(belle_sip_header_user_agent_t* user_agent) {
belle_sip_header_user_agent_set_products(user_agent,NULL);
}
static void belle_sip_header_user_agent_clone(belle_sip_header_user_agent_t* user_agent, const belle_sip_header_user_agent_t* orig) {
belle_sip_list_t* list=orig->products;
for(;list!=NULL;list=list->next) {
belle_sip_header_user_agent_add_product(user_agent,(const char *)list->data);
}
}
belle_sip_error_code belle_sip_header_user_agent_marshal(belle_sip_header_user_agent_t* user_agent, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=BELLE_SIP_OK;
belle_sip_list_t* list = user_agent->products;
error=belle_sip_header_marshal(BELLE_SIP_HEADER(user_agent), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
for(;list!=NULL;list=list->next) {
error=belle_sip_snprintf(buff,buff_size,offset,list==user_agent->products ? "%s" : " %s",(const char *)list->data);
if (error!=BELLE_SIP_OK) return error;
}
return error;
}
BELLE_SIP_NEW_HEADER(header_user_agent,header,"User-Agent")
BELLE_SIP_PARSE(header_user_agent)
belle_sip_list_t* belle_sip_header_user_agent_get_products(const belle_sip_header_user_agent_t* user_agent) {
return user_agent->products;
}
void belle_sip_header_user_agent_set_products(belle_sip_header_user_agent_t* user_agent,belle_sip_list_t* products) {
belle_sip_list_t* list;
if (user_agent->products) {
for (list=user_agent->products;list !=NULL; list=list->next) {
belle_sip_free((void*)list->data);
}
belle_sip_list_free(user_agent->products);
}
user_agent->products=products;
}
void belle_sip_header_user_agent_add_product(belle_sip_header_user_agent_t* user_agent,const char* product) {
user_agent->products = belle_sip_list_append(user_agent->products ,belle_sip_strdup(product));
}
int belle_sip_header_user_agent_get_products_as_string(const belle_sip_header_user_agent_t* user_agent,char* value,unsigned int value_size) {
size_t result = 0;
belle_sip_error_code error=BELLE_SIP_OK;
belle_sip_list_t* list = user_agent->products;
for(;list!=NULL;list=list->next) {
error=belle_sip_snprintf(value,value_size,&result,"%s ",(const char *)list->data);
if (error!=BELLE_SIP_OK) return -1;
}
if (result>0) value[result-1]='\0'; /*remove last space */
return (int)result-1;
}
/**************************
* Via header object inherits from parameters
***************************/
struct _belle_sip_header_via {
belle_sip_parameters_t params_list;
char* protocol;
char* transport;
char* host;
int port;
char* received;
};
static void belle_sip_header_via_destroy(belle_sip_header_via_t* via) {
if (via->protocol) belle_sip_free(via->protocol);
if (via->transport) belle_sip_free(via->transport);
if (via->host) belle_sip_free(via->host);
DESTROY_STRING(via,received)
}
static void belle_sip_header_via_clone(belle_sip_header_via_t* via, const belle_sip_header_via_t*orig) {
CLONE_STRING(belle_sip_header_via,protocol,via,orig)
CLONE_STRING(belle_sip_header_via,transport,via,orig)
CLONE_STRING(belle_sip_header_via,host,via,orig)
CLONE_STRING(belle_sip_header_via,received,via,orig)
via->port=orig->port;
}
belle_sip_error_code belle_sip_header_via_marshal(belle_sip_header_via_t* via, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(via), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s/%s",via->protocol,via->transport);
if (error!=BELLE_SIP_OK) return error;
if (via->host) {
if (strchr(via->host,':')) { /*ipv6*/
error=belle_sip_snprintf(buff,buff_size,offset," [%s]",via->host);
} else {
error=belle_sip_snprintf(buff,buff_size,offset," %s",via->host);
}
if (error!=BELLE_SIP_OK) return error;
} else {
belle_sip_warning("no host found in this via");
}
if (via->port > 0) {
error=belle_sip_snprintf(buff,buff_size,offset,":%i",via->port);
if (error!=BELLE_SIP_OK) return error;
}
if (via->received) {
error=belle_sip_snprintf(buff,buff_size,offset,";received=%s",via->received);
if (error!=BELLE_SIP_OK) return error;
}
error=belle_sip_parameters_marshal(&via->params_list, buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
return error;
}
belle_sip_header_via_t* belle_sip_header_via_create(const char *host, int port, const char *transport, const char *branch) {
belle_sip_header_via_t *via=belle_sip_header_via_new();
via->host=belle_sip_strdup(host);
via->port=port;
via->transport=belle_sip_strdup(transport);
via->protocol=belle_sip_strdup("SIP/2.0");
belle_sip_header_via_set_branch(via,branch);
return via;
}
BELLE_SIP_NEW_HEADER(header_via,parameters,BELLE_SIP_VIA)
BELLE_SIP_PARSE(header_via)
GET_SET_STRING(belle_sip_header_via,protocol);
GET_SET_STRING(belle_sip_header_via,transport);
GET_SET_STRING(belle_sip_header_via,host);
GET_SET_STRING(belle_sip_header_via,received);
GET_SET_INT_PRIVATE(belle_sip_header_via,port,int,_);
GET_SET_STRING_PARAM(belle_sip_header_via,branch);
GET_SET_STRING_PARAM(belle_sip_header_via,maddr);
GET_SET_INT_PARAM_PRIVATE(belle_sip_header_via,rport,int,_)
GET_SET_INT_PARAM_PRIVATE(belle_sip_header_via,ttl,int,_)
int belle_sip_header_via_set_rport (belle_sip_header_via_t* obj,int value) {
if (value == -1) {
belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS(obj),"rport",NULL);
return 0;
}
if (value>0 && value<65536) {
_belle_sip_header_via_set_rport(obj,value);
return 0;
} else {
belle_sip_error("bad rport value [%i] for via",value);
return -1;
}
}
int belle_sip_header_via_set_ttl (belle_sip_header_via_t* obj,int value) {
if (value ==-1 || (value>0 && value<=255)) {
_belle_sip_header_via_set_ttl(obj,value);
return 0;
} else {
belle_sip_error("bad ttl value [%i] for via",value);
return -1;
}
}
int belle_sip_header_via_set_port (belle_sip_header_via_t* obj,int value) {
if (value ==-1 || (value>0 && value<65536)) {
_belle_sip_header_via_set_port(obj,value);
return 0;
} else {
belle_sip_error("bad port value [%i] for via",value);
return -1;
}
}
int belle_sip_header_via_get_listening_port(const belle_sip_header_via_t *via) {
int ret=belle_sip_header_via_get_port(via);
if (ret==0) ret=belle_sip_listening_point_get_well_known_port(via->transport);
return ret;
}
const char* belle_sip_header_via_get_transport_lowercase(const belle_sip_header_via_t* via) {
if (strcasecmp("udp",via->transport)==0) return "udp";
else if (strcasecmp("tcp",via->transport)==0) return "tcp";
else if (strcasecmp("tls",via->transport)==0) return "tls";
else if (strcasecmp("dtls",via->transport)==0) return "dtls";
else {
belle_sip_warning("Cannot convert [%s] to lower case",via->transport);
return via->transport;
}
}
/**************************
* call_id header object inherits from object
***************************/
struct _belle_sip_header_call_id {
belle_sip_header_t header;
const char* call_id;
};
static void belle_sip_header_call_id_destroy(belle_sip_header_call_id_t* call_id) {
if (call_id->call_id) belle_sip_free((void*)call_id->call_id);
}
static void belle_sip_header_call_id_clone(belle_sip_header_call_id_t* call_id,const belle_sip_header_call_id_t *orig) {
CLONE_STRING(belle_sip_header_call_id,call_id,call_id,orig);
}
belle_sip_error_code belle_sip_header_call_id_marshal(belle_sip_header_call_id_t* call_id, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(call_id), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s",call_id->call_id);
if (error!=BELLE_SIP_OK) return error;
return error;
}
unsigned int belle_sip_header_call_id_equals(const belle_sip_header_call_id_t* a,const belle_sip_header_call_id_t* b) {
return strcasecmp(a->call_id,b->call_id) == 0;
}
BELLE_SIP_NEW_HEADER(header_call_id,header,BELLE_SIP_CALL_ID)
BELLE_SIP_PARSE(header_call_id)
GET_SET_STRING(belle_sip_header_call_id,call_id);
/**************************
* retry-after header object inherits from object
***************************/
struct _belle_sip_header_retry_after {
belle_sip_header_t header;
int retry_after;
};
static void belle_sip_header_retry_after_destroy(belle_sip_header_retry_after_t* retry_after) {
}
static void belle_sip_header_retry_after_clone(belle_sip_header_retry_after_t* retry_after,const belle_sip_header_retry_after_t *orig) {
retry_after->retry_after = orig->retry_after;
}
belle_sip_error_code belle_sip_header_retry_after_marshal(belle_sip_header_retry_after_t* retry_after, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(retry_after), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
if (retry_after->retry_after > 0) {
error=belle_sip_snprintf(buff,buff_size,offset,"%i",retry_after->retry_after);
if (error!=BELLE_SIP_OK) return error;
}
return error;
}
BELLE_SIP_NEW_HEADER(header_retry_after,header,BELLE_SIP_RETRY_AFTER)
BELLE_SIP_PARSE(header_retry_after)
GET_SET_INT(belle_sip_header_retry_after,retry_after,int);
belle_sip_header_retry_after_t* belle_sip_header_retry_after_create (int retry_after) {
belle_sip_header_retry_after_t* obj;
obj = belle_sip_header_retry_after_new();
belle_sip_header_retry_after_set_retry_after(obj,retry_after);
return obj;
}
/**************************
* cseq header object inherit from object
***************************/
struct _belle_sip_header_cseq {
belle_sip_header_t header;
char* method;
unsigned int seq_number;
};
static void belle_sip_header_cseq_destroy(belle_sip_header_cseq_t* cseq) {
if (cseq->method) belle_sip_free(cseq->method);
}
static void belle_sip_header_cseq_clone(belle_sip_header_cseq_t* cseq, const belle_sip_header_cseq_t *orig) {
CLONE_STRING(belle_sip_header_cseq,method,cseq,orig)
cseq->seq_number=orig->seq_number;
}
belle_sip_error_code belle_sip_header_cseq_marshal(belle_sip_header_cseq_t* cseq, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(cseq), buff,buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%i %s",cseq->seq_number,cseq->method);
if (error!=BELLE_SIP_OK) return error;
return error;
}
belle_sip_header_cseq_t * belle_sip_header_cseq_create(unsigned int number, const char *method) {
belle_sip_header_cseq_t *cseq=belle_sip_header_cseq_new();
belle_sip_header_cseq_set_method(cseq,method);
cseq->seq_number=number;
return cseq;
}
BELLE_SIP_NEW_HEADER(header_cseq,header,BELLE_SIP_CSEQ)
BELLE_SIP_PARSE(header_cseq)
GET_SET_STRING(belle_sip_header_cseq,method);
GET_SET_INT(belle_sip_header_cseq,seq_number,unsigned int)
/**************************
* content type header object inherit from parameters
***************************/
struct _belle_sip_header_content_type {
belle_sip_parameters_t params_list;
const char* type;
const char* subtype;
};
static void belle_sip_header_content_type_destroy(belle_sip_header_content_type_t* content_type) {
if (content_type->type) belle_sip_free((void*)content_type->type);
if (content_type->subtype) belle_sip_free((void*)content_type->subtype);
}
static void belle_sip_header_content_type_clone(belle_sip_header_content_type_t* content_type, const belle_sip_header_content_type_t* orig) {
CLONE_STRING(belle_sip_header_content_type,type,content_type,orig);
CLONE_STRING(belle_sip_header_content_type,subtype,content_type,orig);
}
belle_sip_error_code belle_sip_header_content_type_marshal(belle_sip_header_content_type_t* content_type, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(content_type), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s/%s",content_type->type, content_type->subtype);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_parameters_marshal(&content_type->params_list, buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW_HEADER(header_content_type,parameters,BELLE_SIP_CONTENT_TYPE)
BELLE_SIP_PARSE(header_content_type)
belle_sip_header_content_type_t* belle_sip_header_content_type_create (const char* type,const char* sub_type) {
belle_sip_header_content_type_t* header = belle_sip_header_content_type_new();
belle_sip_header_content_type_set_type(header,type);
belle_sip_header_content_type_set_subtype(header,sub_type);
return header;
}
GET_SET_STRING(belle_sip_header_content_type,type);
GET_SET_STRING(belle_sip_header_content_type,subtype);
/**************************
* Route header object inherit from header_address
***************************/
struct _belle_sip_header_route {
belle_sip_header_address_t address;
};
static void belle_sip_header_route_destroy(belle_sip_header_route_t* route) {
}
static void belle_sip_header_route_clone(belle_sip_header_route_t* route, const belle_sip_header_route_t* orig) {
}
belle_sip_error_code belle_sip_header_route_marshal(belle_sip_header_route_t* route, char* buff, size_t buff_size, size_t *offset) {
BELLE_SIP_FROM_LIKE_MARSHAL(route,TRUE)
}
BELLE_SIP_NEW_HEADER(header_route,header_address,BELLE_SIP_ROUTE)
BELLE_SIP_PARSE(header_route)
belle_sip_header_route_t* belle_sip_header_route_create(const belle_sip_header_address_t* route) {
belle_sip_header_route_t* header= belle_sip_header_route_new();
_belle_sip_object_copy((belle_sip_object_t*)header,(belle_sip_object_t*)route);
belle_sip_header_set_next(BELLE_SIP_HEADER(header),NULL); /*make sure only one header is kept*/
belle_sip_header_set_name(BELLE_SIP_HEADER(header),BELLE_SIP_ROUTE); /*restore header name*/
return header;
}
/**************************
* Record route header object inherit from header_address
***************************/
struct _belle_sip_header_record_route {
belle_sip_header_address_t address;
unsigned char auto_outgoing;
unsigned char pad[3];
};
static void belle_sip_header_record_route_destroy(belle_sip_header_record_route_t* record_route) {
}
static void belle_sip_header_record_route_clone(belle_sip_header_record_route_t* record_route,
const belle_sip_header_record_route_t* orig ) {
}
belle_sip_error_code belle_sip_header_record_route_marshal(belle_sip_header_record_route_t* record_route, char* buff, size_t buff_size, size_t *offset) {
BELLE_SIP_FROM_LIKE_MARSHAL(record_route,TRUE)
}
belle_sip_header_record_route_t *belle_sip_header_record_route_new_auto_outgoing() {
belle_sip_header_record_route_t *rr = belle_sip_header_record_route_new();
rr->auto_outgoing = TRUE;
return rr;
}
unsigned char belle_sip_header_record_route_get_auto_outgoing(const belle_sip_header_record_route_t *a) {
return a->auto_outgoing;
}
BELLE_SIP_NEW_HEADER(header_record_route,header_address,BELLE_SIP_RECORD_ROUTE)
BELLE_SIP_PARSE(header_record_route)
/**************************
* Service route header object inherit from header_address
***************************/
struct _belle_sip_header_service_route {
belle_sip_header_address_t address;
};
static void belle_sip_header_service_route_destroy(belle_sip_header_service_route_t* service_route) {
}
static void belle_sip_header_service_route_clone(belle_sip_header_service_route_t* service_route,
const belle_sip_header_service_route_t* orig ) {
}
belle_sip_error_code belle_sip_header_service_route_marshal(belle_sip_header_service_route_t* service_route, char* buff, size_t buff_size, size_t *offset) {
BELLE_SIP_FROM_LIKE_MARSHAL(service_route,TRUE)
}
BELLE_SIP_NEW_HEADER(header_service_route,header_address,BELLE_SIP_SERVICE_ROUTE)
BELLE_SIP_PARSE(header_service_route)
/**************************
* content length header object inherit from object
***************************/
struct _belle_sip_header_content_length {
belle_sip_header_t header;
size_t content_length;
};
static void belle_sip_header_content_length_destroy(belle_sip_header_content_length_t* content_length) {
}
static void belle_sip_header_content_length_clone(belle_sip_header_content_length_t* content_length,
const belle_sip_header_content_length_t *orig ) {
content_length->content_length=orig->content_length;
}
belle_sip_error_code belle_sip_header_content_length_marshal(belle_sip_header_content_length_t* content_length, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(content_length), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,FORMAT_SIZE_T,content_length->content_length);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW_HEADER(header_content_length,header,BELLE_SIP_CONTENT_LENGTH)
BELLE_SIP_PARSE(header_content_length)
GET_SET_INT(belle_sip_header_content_length,content_length,size_t)
belle_sip_header_content_length_t* belle_sip_header_content_length_create (size_t content_length) {
belle_sip_header_content_length_t* obj;
obj = belle_sip_header_content_length_new();
belle_sip_header_content_length_set_content_length(obj,content_length);
return obj;
}
/**************************
* Expires header object inherit from header
***************************/
struct _belle_sip_header_expires {
belle_sip_header_t header;
int expires;
};
static void belle_sip_header_expires_destroy(belle_sip_header_expires_t* expires) {
}
static void belle_sip_header_expires_clone(belle_sip_header_expires_t* expires,
const belle_sip_header_expires_t *orig ) {
expires->expires=orig->expires;
}
belle_sip_error_code belle_sip_header_expires_marshal(belle_sip_header_expires_t* expires, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(expires), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%i",expires->expires);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW_HEADER(header_expires,header,BELLE_SIP_EXPIRES)
BELLE_SIP_PARSE(header_expires)
GET_SET_INT(belle_sip_header_expires,expires,int)
belle_sip_header_expires_t* belle_sip_header_expires_create(int expires) {
belle_sip_header_expires_t* obj = belle_sip_header_expires_new();
belle_sip_header_expires_set_expires(obj,expires);
return obj;
}
/******************************
* Extension header hinerite from header
******************************/
struct _belle_sip_header_extension {
belle_sip_header_t header;
const char* value;
};
static void belle_sip_header_extension_destroy(belle_sip_header_extension_t* extension) {
if (extension->value) belle_sip_free((void*)extension->value);
}
static void belle_sip_header_extension_clone(belle_sip_header_extension_t* extension, const belle_sip_header_extension_t* orig) {
CLONE_STRING(belle_sip_header_extension,value,extension,orig)
}
belle_sip_error_code belle_sip_header_extension_marshal(belle_sip_header_extension_t* extension, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(extension), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
if (extension->value) error=belle_sip_snprintf(buff,buff_size,offset,"%s",extension->value);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW_HEADER(header_extension,header,NULL)
belle_sip_header_extension_t* belle_sip_header_extension_create (const char* name,const char* value) {
belle_sip_header_extension_t* ext = belle_sip_header_extension_new();
belle_sip_header_set_name(BELLE_SIP_HEADER(ext),name);
belle_sip_header_extension_set_value(ext,value);
return ext;
}
GET_SET_STRING(belle_sip_header_extension,value);
/**************************
*Authorization header object inherit from parameters
***************************/
#define AUTH_BASE \
belle_sip_parameters_t params_list; \
const char* scheme; \
const char* realm; \
const char* nonce; \
const char* algorithm; \
const char* opaque;
#define AUTH_BASE_DESTROY(obj) \
if (obj->scheme) belle_sip_free((void*)obj->scheme);\
if (obj->realm) belle_sip_free((void*)obj->realm);\
if (obj->nonce) belle_sip_free((void*)obj->nonce);\
if (obj->algorithm) belle_sip_free((void*)obj->algorithm);\
if (obj->opaque) belle_sip_free((void*)obj->opaque);\
/*if (obj->params_list) FIXME free list*/
#define AUTH_BASE_CLONE(object_type,dest,src) \
CLONE_STRING(object_type,scheme,dest,src)\
CLONE_STRING(object_type,realm,dest,src)\
CLONE_STRING(object_type,nonce,dest,src)\
CLONE_STRING(object_type,algorithm,dest,src)\
CLONE_STRING(object_type,opaque,dest,src) \
#define AUTH_BASE_MARSHAL(header) \
char* border=" ";\
const belle_sip_list_t* list;\
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(header), buff, buff_size, offset);\
if (error!=BELLE_SIP_OK) return error;\
list=belle_sip_parameters_get_parameters(&header->params_list);\
if (header->scheme) { \
error=belle_sip_snprintf(buff,buff_size,offset," %s",header->scheme);\
if (error!=BELLE_SIP_OK) return error;\
} else { \
belle_sip_error("missing mandatory scheme"); \
} \
for(;list!=NULL;list=list->next) {\
belle_sip_param_pair_t* container = list->data;\
error=belle_sip_snprintf(buff,buff_size,offset,"%s%s=%s",border, container->name,container->value);\
if (error!=BELLE_SIP_OK) return error;\
border=", ";\
}\
if (header->realm) {\
error=belle_sip_snprintf(buff,buff_size,offset,"%srealm=\"%s\"",border,header->realm);\
if (error!=BELLE_SIP_OK) return error;\
border=", ";\
}\
if (header->nonce) {\
error=belle_sip_snprintf(buff,buff_size,offset,"%snonce=\"%s\"",border,header->nonce);\
if (error!=BELLE_SIP_OK) return error;\
border=", ";\
}\
if (header->algorithm) {\
const char* format;\
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(header,belle_http_header_authorization_t)) {\
format="%salgorithm=\"%s\"";\
} else {\
format="%salgorithm=%s";\
}\
error=belle_sip_snprintf(buff,buff_size,offset,format,border,header->algorithm);\
if (error!=BELLE_SIP_OK) return error;\
border=", ";\
}\
if (header->opaque) {\
error=belle_sip_snprintf(buff,buff_size,offset,"%sopaque=\"%s\"",border,header->opaque);\
if (error!=BELLE_SIP_OK) return error;\
border=", ";\
}
struct _belle_sip_header_authorization {
AUTH_BASE
const char* username;
belle_sip_uri_t* uri;
const char* response;
const char* cnonce;
int nonce_count;
const char* qop;
};
static void belle_sip_header_authorization_destroy(belle_sip_header_authorization_t* authorization) {
if (authorization->username) belle_sip_free((void*)authorization->username);
if (authorization->uri) {
belle_sip_object_unref(authorization->uri);
}
if (authorization->cnonce) belle_sip_free((void*)authorization->cnonce);
AUTH_BASE_DESTROY(authorization)
DESTROY_STRING(authorization,response);
DESTROY_STRING(authorization,qop);
}
static void belle_sip_header_authorization_clone(belle_sip_header_authorization_t* authorization,
const belle_sip_header_authorization_t *orig ) {
AUTH_BASE_CLONE(belle_sip_header_authorization,authorization,orig)
CLONE_STRING(belle_sip_header_authorization,username,authorization,orig)
if (belle_sip_header_authorization_get_uri(orig)) {
belle_sip_header_authorization_set_uri(authorization,BELLE_SIP_URI(belle_sip_object_clone(BELLE_SIP_OBJECT(belle_sip_header_authorization_get_uri(orig)))));
}
CLONE_STRING(belle_sip_header_authorization,response,authorization,orig)
CLONE_STRING(belle_sip_header_authorization,cnonce,authorization,orig)
authorization->nonce_count=orig->nonce_count;
CLONE_STRING(belle_sip_header_authorization,qop,authorization,orig)
}
static void belle_sip_header_authorization_init(belle_sip_header_authorization_t* authorization) {
}
belle_sip_uri_t* belle_sip_header_authorization_get_uri(const belle_sip_header_authorization_t* authorization) {
return authorization->uri;
}
void belle_sip_header_authorization_set_uri(belle_sip_header_authorization_t* authorization, belle_sip_uri_t* uri) {
if (uri) belle_sip_object_ref(uri);
if (authorization->uri) {
belle_sip_object_unref(BELLE_SIP_OBJECT(authorization->uri));
}
authorization->uri=uri;
}
belle_sip_error_code belle_sip_header_authorization_marshal(belle_sip_header_authorization_t* authorization, char* buff, size_t buff_size, size_t *offset) {
char nonce_count[10];
AUTH_BASE_MARSHAL(authorization)
if (authorization->username) {
error=belle_sip_snprintf(buff,buff_size,offset,"%susername=\"%s\"",border,authorization->username);
if (error!=BELLE_SIP_OK) return error;
border=", ";
}
if (authorization->uri) {
error=belle_sip_snprintf(buff,buff_size,offset,"%s uri=\"",border);
if (error!=BELLE_SIP_OK) return error;
border=", ";
error=belle_sip_uri_marshal(authorization->uri,buff,buff_size,offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s","\"");
if (error!=BELLE_SIP_OK) return error;
}
if (authorization->response) {
error=belle_sip_snprintf(buff,buff_size,offset,"%sresponse=\"%s\"",border,authorization->response);
if (error!=BELLE_SIP_OK) return error;
border=", ";
}
if (authorization->cnonce) {
error=belle_sip_snprintf(buff,buff_size,offset,"%scnonce=\"%s\"",border,authorization->cnonce);
if (error!=BELLE_SIP_OK) return error;
border=", ";
}
if (authorization->nonce_count>0) {
belle_sip_header_authorization_get_nonce_count_as_string(authorization,nonce_count);
error=belle_sip_snprintf(buff,buff_size,offset,"%snc=%s",border,nonce_count);
if (error!=BELLE_SIP_OK) return error;
border=", ";
}
if (authorization->qop) {
const char* format;
format="%sqop=%s";
error=belle_sip_snprintf(buff,buff_size,offset,format,border,authorization->qop);
if (error!=BELLE_SIP_OK) return error;
}
return error;
}
BELLE_SIP_NEW_HEADER(header_authorization,parameters,BELLE_SIP_AUTHORIZATION)
BELLE_SIP_PARSE(header_authorization)
GET_SET_STRING(belle_sip_header_authorization,scheme);
GET_SET_STRING(belle_sip_header_authorization,username);
GET_SET_STRING(belle_sip_header_authorization,realm);
GET_SET_STRING(belle_sip_header_authorization,nonce);
GET_SET_STRING(belle_sip_header_authorization,response);
GET_SET_STRING(belle_sip_header_authorization,algorithm);
GET_SET_STRING(belle_sip_header_authorization,cnonce);
GET_SET_STRING(belle_sip_header_authorization,opaque);
GET_SET_STRING(belle_sip_header_authorization,qop);
GET_SET_INT(belle_sip_header_authorization,nonce_count,int)
int belle_sip_header_authorization_get_nonce_count_as_string(const belle_sip_header_authorization_t* authorization,char nounce_count[9]) {
nounce_count[0]='\0';
if (authorization->nonce_count>0) {
snprintf(nounce_count,9,"%08x",authorization->nonce_count);
return 0;
} else {
return -1;
}
}
/**************************
*Proxy-Authorization header object inherit from parameters
***************************/
struct _belle_sip_header_proxy_authorization {
belle_sip_header_authorization_t authorization;
};
static void belle_sip_header_proxy_authorization_destroy(belle_sip_header_proxy_authorization_t* proxy_authorization) {
}
static void belle_sip_header_proxy_authorization_clone(belle_sip_header_proxy_authorization_t* proxy_authorization,
const belle_sip_header_proxy_authorization_t *orig ) {
}
belle_sip_error_code belle_sip_header_proxy_authorization_marshal(belle_sip_header_proxy_authorization_t* proxy_authorization, char* buff, size_t buff_size, size_t *offset) {
return belle_sip_header_authorization_marshal(&proxy_authorization->authorization,buff,buff_size,offset);
}
BELLE_SIP_NEW_HEADER(header_proxy_authorization,header_authorization,BELLE_SIP_PROXY_AUTHORIZATION)
BELLE_SIP_PARSE(header_proxy_authorization)
/**************************
*HTTP Authorization header object inherit from Authorization
***************************/
struct _belle_http_header_authorization {
belle_sip_header_authorization_t authorization;
belle_generic_uri_t* uri;
};
static void belle_http_header_authorization_init(belle_http_header_authorization_t* authorization) {
belle_sip_header_set_name(BELLE_SIP_HEADER(authorization),BELLE_HTTP_AUTHORIZATION);
}
static void belle_http_header_authorization_destroy(belle_http_header_authorization_t* authorization) {
if (authorization->uri) {
belle_sip_object_unref(authorization->uri);
}
}
static void belle_http_header_authorization_clone(belle_http_header_authorization_t* authorization,
const belle_http_header_authorization_t *orig ) {
if (belle_http_header_authorization_get_uri(orig)) {
belle_http_header_authorization_set_uri(authorization,BELLE_GENERIC_URI(belle_sip_object_clone(BELLE_SIP_OBJECT(belle_http_header_authorization_get_uri(orig)))));
}
}
belle_sip_error_code belle_http_header_authorization_marshal(belle_http_header_authorization_t* authorization, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=BELLE_SIP_OK;
/*first make sure there is no sip uri*/
if (belle_sip_header_authorization_get_uri(BELLE_SIP_HEADER_AUTHORIZATION(authorization))) {
belle_sip_error ("Cannot marshal http_header_authorization because a sip uri is set. Use belle_http_authorization_set uri instead of belle_sip_header_authorization_set_uri");
return BELLE_SIP_NOT_IMPLEMENTED;
}
belle_sip_header_authorization_marshal(BELLE_SIP_HEADER_AUTHORIZATION(authorization),buff,buff_size,offset);
if (authorization->uri) {
error=belle_sip_snprintf(buff,buff_size,offset,", uri=\"");
if (error!=BELLE_SIP_OK) return error;
error=belle_generic_uri_marshal(authorization->uri,buff,buff_size,offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s","\"");
if (error!=BELLE_SIP_OK) return error;
}
return error;
}
BELLE_NEW(belle_http_header_authorization,belle_sip_header_authorization)
belle_generic_uri_t* belle_http_header_authorization_get_uri(const belle_http_header_authorization_t* authorization) {
return authorization->uri;
}
void belle_http_header_authorization_set_uri( belle_http_header_authorization_t* authorization,belle_generic_uri_t* uri) {
if (authorization->uri) belle_sip_object_unref(authorization->uri);
if (uri) belle_sip_object_ref(uri);
authorization->uri=uri;
}
/**************************
* WWW-Authenticate header object inherit from parameters
**************************/
struct _belle_sip_header_www_authenticate {
AUTH_BASE
const char* domain;
int stale;
belle_sip_list_t* qop;
};
static void belle_sip_header_www_authenticate_destroy(belle_sip_header_www_authenticate_t* www_authenticate) {
AUTH_BASE_DESTROY(www_authenticate)
if (www_authenticate->domain) belle_sip_free((void*)www_authenticate->domain);
if (www_authenticate->qop) belle_sip_list_free_with_data(www_authenticate->qop,belle_sip_free);
}
void belle_sip_header_www_authenticate_init(belle_sip_header_www_authenticate_t* www_authenticate) {
www_authenticate->stale=-1;
}
static void belle_sip_header_www_authenticate_clone(belle_sip_header_www_authenticate_t* www_authenticate,
const belle_sip_header_www_authenticate_t *orig ) {
AUTH_BASE_CLONE(belle_sip_header_www_authenticate,www_authenticate,orig)
CLONE_STRING(belle_sip_header_www_authenticate,domain,www_authenticate,orig)
www_authenticate->stale=orig->stale;
www_authenticate->qop=belle_sip_list_copy_with_data(orig->qop,(void* (*)(void*))belle_sip_strdup);
}
belle_sip_error_code belle_sip_header_www_authenticate_marshal(belle_sip_header_www_authenticate_t* www_authenticate, char* buff, size_t buff_size, size_t *offset) {
belle_sip_list_t* qops=www_authenticate->qop;
AUTH_BASE_MARSHAL(www_authenticate)
if (www_authenticate->domain) {
error=belle_sip_snprintf(buff,buff_size,offset,"%sdomain=\"%s\"",border,www_authenticate->domain);
if (error!=BELLE_SIP_OK) return error;
border=", ";
}
if (www_authenticate->stale>=0) {
error=belle_sip_snprintf(buff,buff_size,offset,"%sstale=%s",border,www_authenticate->stale?"true":"false");
if (error!=BELLE_SIP_OK) return error;
}
if (qops!=NULL && qops->data!=NULL) {
error=belle_sip_snprintf(buff,buff_size,offset,"%sqop=\"",border);
if (error!=BELLE_SIP_OK) return error;
border="";
for(;qops!=NULL;qops=qops->next) {
error=belle_sip_snprintf(buff,buff_size,offset,"%s%s",border, (const char*)qops->data);
if (error!=BELLE_SIP_OK) return error;
border=",";
}\
error=belle_sip_snprintf(buff,buff_size,offset,"\"");
if (error!=BELLE_SIP_OK) return error;
border=", ";
}
return error;
}
#define SET_ADD_STRING_LIST(header,name) \
void header##_set_##name(header##_t* obj, belle_sip_list_t* value) {\
if (obj->name) {\
belle_sip_list_free_with_data(obj->name,belle_sip_free);\
} \
obj->name=value;\
}\
void header##_add_##name(header##_t* obj, const char* value) {\
obj->name=belle_sip_list_append(obj->name,strdup(value));\
}
BELLE_SIP_NEW_HEADER_INIT(header_www_authenticate,parameters,BELLE_SIP_WWW_AUTHENTICATE,header_www_authenticate)
BELLE_SIP_PARSE(header_www_authenticate)
GET_SET_STRING(belle_sip_header_www_authenticate,scheme);
GET_SET_STRING(belle_sip_header_www_authenticate,realm);
GET_SET_STRING(belle_sip_header_www_authenticate,nonce);
GET_SET_STRING(belle_sip_header_www_authenticate,algorithm);
GET_SET_STRING(belle_sip_header_www_authenticate,opaque);
/*GET_SET_STRING(belle_sip_header_www_authenticate,qop);*/
SET_ADD_STRING_LIST(belle_sip_header_www_authenticate,qop)
GET_SET_STRING(belle_sip_header_www_authenticate,domain)
GET_SET_BOOL(belle_sip_header_www_authenticate,stale,is)
belle_sip_list_t* belle_sip_header_www_authenticate_get_qop(const belle_sip_header_www_authenticate_t* www_authetication) {
return www_authetication->qop;
}
const char* belle_sip_header_www_authenticate_get_qop_first(const belle_sip_header_www_authenticate_t* www_authetication) {
return www_authetication->qop?(const char*)www_authetication->qop->data:NULL;
}
/**************************
*Proxy-authenticate header object inherit from www_authenticate
***************************/
struct _belle_sip_header_proxy_authenticate {
belle_sip_header_www_authenticate_t www_authenticate;
};
static void belle_sip_header_proxy_authenticate_destroy(belle_sip_header_proxy_authenticate_t* proxy_authenticate) {
}
static void belle_sip_header_proxy_authenticate_clone(belle_sip_header_proxy_authenticate_t* proxy_authenticate,
const belle_sip_header_proxy_authenticate_t *orig ) {
}
belle_sip_error_code belle_sip_header_proxy_authenticate_marshal(belle_sip_header_proxy_authenticate_t* proxy_authenticate, char* buff, size_t buff_size, size_t *offset) {
return belle_sip_header_www_authenticate_marshal(&proxy_authenticate->www_authenticate,buff,buff_size,offset);
}
BELLE_SIP_NEW_HEADER(header_proxy_authenticate,header_www_authenticate,BELLE_SIP_PROXY_AUTHENTICATE)
BELLE_SIP_PARSE(header_proxy_authenticate)
/**************************
* max forwards header object inherit from header
***************************/
struct _belle_sip_header_max_forwards {
belle_sip_header_t header;
int max_forwards;
};
static void belle_sip_header_max_forwards_destroy(belle_sip_header_max_forwards_t* max_forwards) {
}
static void belle_sip_header_max_forwards_clone(belle_sip_header_max_forwards_t* max_forwards,
const belle_sip_header_max_forwards_t *orig ) {
max_forwards->max_forwards=orig->max_forwards;
}
belle_sip_error_code belle_sip_header_max_forwards_marshal(belle_sip_header_max_forwards_t* max_forwards, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(max_forwards), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%i",max_forwards->max_forwards);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW_HEADER(header_max_forwards,header,"Max-Forwards")
BELLE_SIP_PARSE(header_max_forwards)
GET_SET_INT(belle_sip_header_max_forwards,max_forwards,int)
int belle_sip_header_max_forwards_decrement_max_forwards(belle_sip_header_max_forwards_t* max_forwards) {
return max_forwards->max_forwards--;
}
belle_sip_header_max_forwards_t* belle_sip_header_max_forwards_create(int value) {
belle_sip_header_max_forwards_t* max_forwards=belle_sip_header_max_forwards_new();
max_forwards->max_forwards=value;
return max_forwards;
}
/**************************
* Subscription state header object inherit from parameters
***************************/
struct _belle_sip_header_subscription_state {
belle_sip_parameters_t parameters;
const char* state;
};
static void belle_sip_header_subscription_state_destroy(belle_sip_header_subscription_state_t* subscription_state) {
DESTROY_STRING(subscription_state,state);
}
static void belle_sip_header_subscription_state_clone(belle_sip_header_subscription_state_t* subscription_state,
const belle_sip_header_subscription_state_t *orig ) {
CLONE_STRING(belle_sip_header_subscription_state,state,subscription_state,orig)
}
belle_sip_error_code belle_sip_header_subscription_state_marshal(belle_sip_header_subscription_state_t* subscription_state, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(subscription_state), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s",subscription_state->state);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_parameters_marshal(BELLE_SIP_PARAMETERS(subscription_state), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW_HEADER(header_subscription_state,parameters,BELLE_SIP_SUBSCRIPTION_STATE)
BELLE_SIP_PARSE(header_subscription_state)
GET_SET_STRING(belle_sip_header_subscription_state,state);
GET_SET_STRING_PARAM(belle_sip_header_subscription_state,reason);
GET_SET_INT_PARAM2(belle_sip_header_subscription_state,retry-after,int,retry_after);
GET_SET_INT_PARAM(belle_sip_header_subscription_state,expires,int)
belle_sip_header_subscription_state_t* belle_sip_header_subscription_state_create (const char* subscription_state,int expires) {
belle_sip_header_subscription_state_t* sub_state=belle_sip_header_subscription_state_new();
belle_sip_header_subscription_state_set_state(sub_state,subscription_state);
belle_sip_header_subscription_state_set_expires(sub_state,expires);
return sub_state;
}
#define HEADER_TO_LIKE_IMPL(name,header_name) \
struct _belle_sip_header_##name { \
belle_sip_header_address_t address; \
}; \
\
static void belle_sip_header_##name##_destroy(belle_sip_header_##name##_t * obj) { \
} \
void belle_sip_header_##name##_clone(belle_sip_header_##name##_t *contact, const belle_sip_header_##name##_t *orig) { }\
belle_sip_error_code belle_sip_header_##name##_marshal(belle_sip_header_##name##_t* name, char* buff, size_t buff_size, size_t *offset) {\
BELLE_SIP_FROM_LIKE_MARSHAL(name,FALSE)\
}\
BELLE_SIP_NEW_HEADER(header_##name,header_address,header_name)\
BELLE_SIP_PARSE(header_##name)\
belle_sip_header_##name##_t* belle_sip_header_##name##_create(const belle_sip_header_address_t* address) { \
belle_sip_header_##name##_t* header= belle_sip_header_##name##_new();\
_belle_sip_object_copy((belle_sip_object_t*)header,(belle_sip_object_t*)address);\
belle_sip_header_set_next(BELLE_SIP_HEADER(header),NULL); /*make sure only one header is kept*/\
belle_sip_header_set_name(BELLE_SIP_HEADER(header),header_name); \
return header;\
}
/**************************
* Refer-To header object inherits from header_address
***************************/
HEADER_TO_LIKE_IMPL(refer_to,BELLE_SIP_REFER_TO)
/**************************
* Referred-By header object inherits from header_address
***************************/
HEADER_TO_LIKE_IMPL(referred_by,BELLE_SIP_REFERRED_BY)
/**************************
* Replaces state header object inherit from parameters
***************************/
struct _belle_sip_header_replaces {
belle_sip_parameters_t parameters;
char* call_id;
};
static void belle_sip_header_replaces_destroy(belle_sip_header_replaces_t* replaces) {
DESTROY_STRING(replaces,call_id);
}
static void belle_sip_header_replaces_clone(belle_sip_header_replaces_t* replaces,
const belle_sip_header_replaces_t *orig ) {
CLONE_STRING(belle_sip_header_replaces,call_id,replaces,orig)
}
belle_sip_error_code belle_sip_header_replaces_marshal(belle_sip_header_replaces_t* replaces, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(replaces), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s",replaces->call_id);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_parameters_marshal(BELLE_SIP_PARAMETERS(replaces), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW_HEADER(header_replaces,parameters,BELLE_SIP_REPLACES)
BELLE_SIP_PARSE(header_replaces)
GET_SET_STRING(belle_sip_header_replaces,call_id);
GET_SET_STRING_PARAM2(belle_sip_header_replaces,to-tag,to_tag);
GET_SET_STRING_PARAM2(belle_sip_header_replaces,from-tag,from_tag);
static void escaped_to_ascii(const char*a,char*b,size_t n) {
size_t index_a=0,index_b=0;
while (a[index_a]!='\0'&& index_acall_id);
if (error!=BELLE_SIP_OK) return NULL;
error=belle_sip_parameters_marshal(BELLE_SIP_PARAMETERS(replaces), buff, buff_size, &offset);
if (error!=BELLE_SIP_OK) return NULL;
buff[offset]='\0';
return strdup(buff);
}
belle_sip_header_replaces_t* belle_sip_header_replaces_create(const char* call_id,const char* from_tag,const char* to_tag) {
belle_sip_header_replaces_t* replaces=belle_sip_header_replaces_new();
belle_sip_header_replaces_set_call_id(replaces,call_id);
belle_sip_header_replaces_set_from_tag(replaces,from_tag);
belle_sip_header_replaces_set_to_tag(replaces,to_tag);
return replaces;
}
struct belle_sip_header_date{
belle_sip_header_t base;
char *date;
};
static void belle_sip_header_date_destroy(belle_sip_header_date_t* obj) {
DESTROY_STRING(obj,date);
}
static void belle_sip_header_date_clone(belle_sip_header_date_t* obj,
const belle_sip_header_date_t *orig ) {
CLONE_STRING(belle_sip_header_date,date,obj,orig);
}
belle_sip_error_code belle_sip_header_date_marshal(belle_sip_header_date_t* obj, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(obj), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s",obj->date);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW_HEADER(header_date,header,BELLE_SIP_DATE)
BELLE_SIP_PARSE(header_date)
BELLESIP_EXPORT belle_sip_header_date_t* belle_sip_header_date_create_from_time(const time_t *utc_time) {
belle_sip_header_date_t *obj=belle_sip_header_date_new();
belle_sip_header_date_set_time(obj,utc_time);
return obj;
}
static const char *days[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
static const char *months[]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
BELLESIP_EXPORT time_t belle_sip_header_date_get_time(belle_sip_header_date_t *obj) {
struct tm ret ={0};
char tmp1[4] ={0};
char tmp2[17] ={0};
int i,j;
time_t seconds;
#if defined(BELLE_SIP_WINDOWS_UNIVERSAL) || defined(BELLE_SIP_MSC_VER_GREATER_19)
long adjust_timezone;
#else
time_t adjust_timezone;
#endif
/* time headers are in GMT as spec says */
sscanf(obj->date,"%3c,%d %16s %d %d:%d:%d",tmp1,&ret.tm_mday,tmp2,
&ret.tm_year,&ret.tm_hour,&ret.tm_min,&ret.tm_sec);
ret.tm_year-=1900;
for(i=0;i<7;i++) {
if(strcmp(tmp1,days[i])==0) {
ret.tm_wday=i;
for(j=0;j<12;j++) {
if(strcmp(tmp2,months[j])==0) {
ret.tm_mon=j;
goto success;
}
}
}
}
belle_sip_warning("Failed to parse date %s",obj->date);
return (time_t)-1;
success:
ret.tm_isdst=0;
#if TARGET_IPHONE_SIMULATOR
/* 'timezone' is buggy on iOS simulator, use the timegm() function to convert to UTC timestamp
and discard the adjust timezone value */
seconds = timegm(&ret);
adjust_timezone = 0;
#else
seconds = mktime(&ret);
#if defined(BELLE_SIP_WINDOWS_UNIVERSAL) || defined(BELLE_SIP_MSC_VER_GREATER_19)
_get_timezone(&adjust_timezone);
#else
adjust_timezone = timezone;
#endif
#endif
if (seconds==(time_t)-1) {
belle_sip_error("mktime() failed: %s",strerror(errno));
return (time_t)-1;
}
return seconds-(time_t)adjust_timezone;
}
BELLESIP_EXPORT void belle_sip_header_date_set_time(belle_sip_header_date_t *obj, const time_t *utc_time) {
struct tm *ret;
#ifndef _WIN32
struct tm gmt;
ret=gmtime_r(utc_time,&gmt);
#else
ret=gmtime(utc_time);
#endif
/*cannot use strftime because it is locale dependant*/
if (obj->date) {
belle_sip_free(obj->date);
}
/*SIP-date = rfc1123-date
rfc1123-date = wkday "," SP date1 SP time SP "GMT"
date1 = 2DIGIT SP month SP 4DIGIT
; day month year (e.g., 02 Jun 1982)
time = 2DIGIT ":" 2DIGIT ":" 2DIGIT
; 00:00:00 - 23:59:59
wkday = "Mon" / "Tue" / "Wed"
/ "Thu" / "Fri" / "Sat" / "Sun"
month = "Jan" / "Feb" / "Mar" / "Apr"
/ "May" / "Jun" / "Jul" / "Aug"
/ "Sep" / "Oct" / "Nov" / "Dec"
*/
obj->date=belle_sip_strdup_printf("%s, %02i %s %04i %02i:%02i:%02i GMT",
days[ret->tm_wday],ret->tm_mday,months[ret->tm_mon],1900+ret->tm_year,ret->tm_hour,ret->tm_min,ret->tm_sec);
}
GET_SET_STRING(belle_sip_header_date,date);
/************************
* header_p_prefered_identity
***********************/
struct _belle_sip_header_p_preferred_identity {
belle_sip_header_address_t address;
};
void belle_sip_header_p_preferred_identity_destroy(belle_sip_header_p_preferred_identity_t* p_preferred_identity) {
}
void belle_sip_header_p_preferred_identity_clone(belle_sip_header_p_preferred_identity_t *p_preferred_identity, const belle_sip_header_p_preferred_identity_t *orig) {
}
belle_sip_error_code belle_sip_header_p_preferred_identity_marshal(belle_sip_header_p_preferred_identity_t* p_preferred_identity, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(p_preferred_identity), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_header_address_marshal(&p_preferred_identity->address, buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW_HEADER(header_p_preferred_identity,header_address,BELLE_SIP_P_PREFERRED_IDENTITY)
BELLE_SIP_PARSE(header_p_preferred_identity)
belle_sip_header_p_preferred_identity_t* belle_sip_header_p_preferred_identity_create (const belle_sip_header_address_t* p_preferred_identity) {
belle_sip_header_p_preferred_identity_t* header = belle_sip_header_p_preferred_identity_new();
_belle_sip_object_copy(BELLE_SIP_OBJECT(header),BELLE_SIP_OBJECT(p_preferred_identity));
belle_sip_header_set_next(BELLE_SIP_HEADER(header),NULL); /*make sure only one header is kept*/
belle_sip_header_set_name(BELLE_SIP_HEADER(header),BELLE_SIP_P_PREFERRED_IDENTITY); /*restaure header name*/
return header;
}
#define PRIVACY_LIKE_HEADER(header_name, string_name,separator) \
struct _belle_sip_header_##header_name { \
belle_sip_header_t header;\
belle_sip_list_t* header_name;\
}; \
\
static void belle_sip_header_##header_name##_destroy(belle_sip_header_##header_name##_t* p) {\
belle_sip_header_##header_name##_set_##header_name(p,NULL);\
}\
\
static void belle_sip_header_##header_name##_clone(belle_sip_header_##header_name##_t* p, const belle_sip_header_##header_name##_t* orig) {\
belle_sip_list_t* list=orig->header_name;\
for(;list!=NULL;list=list->next) {\
belle_sip_header_##header_name##_add_##header_name(p,(const char *)list->data);\
}\
}\
\
belle_sip_error_code belle_sip_header_##header_name##_marshal(belle_sip_header_##header_name##_t* p, char* buff, size_t buff_size, size_t *offset) {\
belle_sip_error_code error=BELLE_SIP_OK;\
belle_sip_list_t* list = p->header_name;\
error=belle_sip_header_marshal(BELLE_SIP_HEADER(p), buff, buff_size, offset);\
if (error!=BELLE_SIP_OK) return error;\
for(;list!=NULL;list=list->next) {\
error=belle_sip_snprintf(buff,buff_size,offset,list==p->header_name ? "%s" : separator" %s",(const char *)list->data);\
if (error!=BELLE_SIP_OK) return error;\
}\
return error;\
}\
\
BELLE_SIP_NEW_HEADER(header_##header_name,header,string_name)\
BELLE_SIP_PARSE(header_##header_name)\
belle_sip_list_t* belle_sip_header_##header_name##_get_##header_name(const belle_sip_header_##header_name##_t* p) {\
return p->header_name;\
}\
SET_ADD_STRING_LIST(belle_sip_header_##header_name,header_name)\
\
belle_sip_header_##header_name##_t* belle_sip_header_##header_name##_create(const char* header_name) {\
belle_sip_header_##header_name##_t* header=belle_sip_header_##header_name##_new();\
belle_sip_header_##header_name##_add_##header_name(header,header_name);\
return header;\
}
/******************************
* Privacy header inherits from header
******************************/
PRIVACY_LIKE_HEADER(privacy,BELLE_SIP_PRIVACY,";")
/**************************
* Event header object inherit from parameters
***************************/
struct _belle_sip_header_event {
belle_sip_parameters_t parameters;
const char* package_name;
};
static void belle_sip_header_event_destroy(belle_sip_header_event_t* event) {
DESTROY_STRING(event,package_name);
}
static void belle_sip_header_event_clone(belle_sip_header_event_t* event, const belle_sip_header_event_t *orig ) {
CLONE_STRING(belle_sip_header_event,package_name,event,orig)
}
belle_sip_error_code belle_sip_header_event_marshal(belle_sip_header_event_t* event, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(event), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s",event->package_name);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_parameters_marshal(BELLE_SIP_PARAMETERS(event), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW_HEADER(header_event,parameters,BELLE_SIP_EVENT)
BELLE_SIP_PARSE(header_event)
GET_SET_STRING(belle_sip_header_event,package_name);
GET_SET_STRING_PARAM(belle_sip_header_event,id);
belle_sip_header_event_t* belle_sip_header_event_create (const char* package_name) {
belle_sip_header_event_t* event=belle_sip_header_event_new();
belle_sip_header_event_set_package_name(event,package_name);
return event;
}
/******************************
* Supported header inherits from header
******************************/
PRIVACY_LIKE_HEADER(supported, BELLE_SIP_SUPPORTED, ",")
int belle_sip_header_supported_contains_tag(const belle_sip_header_supported_t* supported, const char* tag) {
belle_sip_list_t* list = belle_sip_header_supported_get_supported(supported);
while (list) {
if (strcmp(list->data, tag) == 0) return TRUE;
list = list->next;
}
return FALSE;
}
/******************************
* Require header inherits from header
******************************/
PRIVACY_LIKE_HEADER(require,BELLE_SIP_REQUIRE,",")
/******************************
* Content-Disposition header inherits from header
******************************/
struct _belle_sip_header_content_disposition {
belle_sip_parameters_t parameters;
const char* content_disposition;
};
static void belle_sip_header_content_disposition_destroy(belle_sip_header_content_disposition_t* content_disposition) {
DESTROY_STRING(content_disposition,content_disposition);
}
static void belle_sip_header_content_disposition_clone(belle_sip_header_content_disposition_t* content_disposition,
const belle_sip_header_content_disposition_t *orig ) {
CLONE_STRING(belle_sip_header_content_disposition,content_disposition,content_disposition,orig)
}
belle_sip_error_code belle_sip_header_content_disposition_marshal(belle_sip_header_content_disposition_t* content_disposition, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(content_disposition), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s",content_disposition->content_disposition);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_parameters_marshal(BELLE_SIP_PARAMETERS(content_disposition), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW_HEADER(header_content_disposition,parameters,BELLE_SIP_CONTENT_DISPOSITION)
BELLE_SIP_PARSE(header_content_disposition)
GET_SET_STRING(belle_sip_header_content_disposition,content_disposition);
belle_sip_header_content_disposition_t* belle_sip_header_content_disposition_create (const char* value) {
belle_sip_header_content_disposition_t* header=belle_sip_header_content_disposition_new();
belle_sip_header_content_disposition_set_content_disposition(header,value);
return header;
}
/******************************
* Accept header inherits from parameters
******************************/
struct _belle_sip_header_accept {
belle_sip_parameters_t params_list;
const char* type;
const char* subtype;
};
static void belle_sip_header_accept_destroy(belle_sip_header_accept_t* accept) {
if (accept->type) belle_sip_free((void*)accept->type);
if (accept->subtype) belle_sip_free((void*)accept->subtype);
}
static void belle_sip_header_accept_clone(belle_sip_header_accept_t* accept, const belle_sip_header_accept_t* orig) {
CLONE_STRING(belle_sip_header_accept,type,accept,orig);
CLONE_STRING(belle_sip_header_accept,subtype,accept,orig);
}
belle_sip_error_code belle_sip_header_accept_marshal(belle_sip_header_accept_t* accept, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(accept), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s/%s",accept->type, accept->subtype);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_parameters_marshal(&accept->params_list, buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW_HEADER(header_accept,parameters,BELLE_SIP_ACCEPT)
BELLE_SIP_PARSE(header_accept)
belle_sip_header_accept_t* belle_sip_header_accept_create (const char* type,const char* sub_type) {
belle_sip_header_accept_t* header = belle_sip_header_accept_new();
belle_sip_header_accept_set_type(header,type);
belle_sip_header_accept_set_subtype(header,sub_type);
return header;
}
GET_SET_STRING(belle_sip_header_accept,type);
GET_SET_STRING(belle_sip_header_accept,subtype);
/******************************
* Reason header object inherit from parameters
******************************/
struct _belle_sip_header_reason {
belle_sip_parameters_t params_list;
const char* protocol;
const char* unquoted_text;
};
static void belle_sip_header_reason_destroy(belle_sip_header_reason_t* reason) {
DESTROY_STRING(reason,protocol);
DESTROY_STRING(reason,unquoted_text);
}
static void belle_sip_header_reason_clone(belle_sip_header_reason_t* reason, const belle_sip_header_reason_t* orig) {
CLONE_STRING(belle_sip_header_reason,protocol,reason,orig)
}
belle_sip_error_code belle_sip_header_reason_marshal(belle_sip_header_reason_t* reason, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(reason), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s ",reason->protocol);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_parameters_marshal(BELLE_SIP_PARAMETERS(reason), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
if (reason->unquoted_text)
error=belle_sip_snprintf(buff,buff_size,offset,"; text=\"%s\"",reason->unquoted_text);
return error;
}
GET_SET_STRING(belle_sip_header_reason,unquoted_text);
void belle_sip_header_reason_set_text(belle_sip_header_reason_t* reason,const char* text) {
belle_sip_parameters_remove_parameter(BELLE_SIP_PARAMETERS(reason),"text"); /*just in case*/
belle_sip_header_reason_set_unquoted_text((belle_sip_header_reason_t*)reason, text);
}
BELLESIP_EXPORT const char* belle_sip_header_reason_get_text(const belle_sip_header_reason_t* reason) {
if (!reason->unquoted_text) {
/*try from params*/
const char * quoted = belle_sip_parameters_get_parameter(BELLE_SIP_PARAMETERS(reason), "text");
if (quoted) {
char* unquoted = _belle_sip_str_dup_and_unquote_string(quoted);
belle_sip_header_reason_set_unquoted_text((belle_sip_header_reason_t*)reason, unquoted); /*change internal param, ,even if reason is const*/
belle_sip_parameters_remove_parameter(BELLE_SIP_PARAMETERS(reason),"text");
belle_sip_free(unquoted);
}
}
return reason->unquoted_text;
}
GET_SET_STRING(belle_sip_header_reason,protocol);
GET_SET_INT_PARAM(belle_sip_header_reason,cause,int);
BELLE_SIP_PARSE(header_reason)
BELLE_SIP_NEW_HEADER(header_reason,parameters,BELLE_SIP_REASON)
/******************************
* AuthenticationInfo header hinerite from header
******************************/
struct _belle_sip_header_authentication_info {
belle_sip_header_t header;
const char* rsp_auth;
const char* cnonce;
int nonce_count;
const char* qop;
const char* next_nonce;
};
static void belle_sip_header_authentication_info_destroy(belle_sip_header_authentication_info_t* authentication_info) {
DESTROY_STRING(authentication_info,rsp_auth);
DESTROY_STRING(authentication_info,cnonce);
DESTROY_STRING(authentication_info,qop);
DESTROY_STRING(authentication_info,next_nonce);
}
static void belle_sip_header_authentication_info_clone( belle_sip_header_authentication_info_t* authentication_info
, const belle_sip_header_authentication_info_t* orig) {
CLONE_STRING(belle_sip_header_authentication_info,rsp_auth,authentication_info,orig)
CLONE_STRING(belle_sip_header_authentication_info,cnonce,authentication_info,orig)
CLONE_STRING(belle_sip_header_authentication_info,qop,authentication_info,orig)
CLONE_STRING(belle_sip_header_authentication_info,next_nonce,authentication_info,orig)
}
belle_sip_error_code belle_sip_header_authentication_info_marshal(belle_sip_header_authentication_info_t* authentication_info, char* buff, size_t buff_size, size_t *offset) {
char* border="";
belle_sip_error_code error=belle_sip_header_marshal(BELLE_SIP_HEADER(authentication_info), buff, buff_size, offset);
if (error!=BELLE_SIP_OK) return error;
if (authentication_info->rsp_auth) {
error=belle_sip_snprintf(buff,buff_size,offset,"%srspauth=\"%s\"", border,authentication_info->rsp_auth);
border=", ";
}
if (error!=BELLE_SIP_OK) return error;
if (authentication_info->cnonce) {
error=belle_sip_snprintf(buff,buff_size,offset,"%scnonce=\"%s\"", border, authentication_info->cnonce);
border=", ";
}
if (error!=BELLE_SIP_OK) return error;
if (authentication_info->nonce_count >= 0) {
error=belle_sip_snprintf(buff,buff_size,offset,"%snc=%08x", border, authentication_info->nonce_count);
border=", ";
}
if (error!=BELLE_SIP_OK) return error;
if (authentication_info->qop) {
error=belle_sip_snprintf(buff,buff_size,offset,"%sqop=%s", border, authentication_info->qop);
border=", ";
}
if (error!=BELLE_SIP_OK) return error;
if (authentication_info->next_nonce) {
error=belle_sip_snprintf(buff,buff_size,offset,"%snextnonce=\"%s\"", border, authentication_info->next_nonce);
}
return error;
}
void belle_sip_header_authentication_info_init(belle_sip_header_authentication_info_t* header_authentication) {
header_authentication->nonce_count=-1;
}
BELLE_SIP_NEW_HEADER_INIT(header_authentication_info,header,BELLE_SIP_AUTHENTICATION_INFO,header_authentication_info)
BELLE_SIP_PARSE(header_authentication_info)
GET_SET_STRING(belle_sip_header_authentication_info,rsp_auth);
GET_SET_STRING(belle_sip_header_authentication_info,qop);
GET_SET_STRING(belle_sip_header_authentication_info,next_nonce);
GET_SET_STRING(belle_sip_header_authentication_info,cnonce);
GET_SET_INT(belle_sip_header_authentication_info,nonce_count,int);
belle-sip-5.2.0+dfsg/src/belle_sip_internal.h 0000664 0000000 0000000 00000131237 14346131365 0021120 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef belle_utils_h
#define belle_utils_h
#include
#include
#include
#include
#include
/* include all public headers*/
#include "belle-sip/belle-sip.h"
#include "bctoolbox/map.h"
#include "port.h"
#include
#include
#ifdef HAVE_CONFIG_H
#ifdef PACKAGE
#undef PACKAGE
#endif
#ifdef PACKAGE_BUGREPORT
#undef PACKAGE_BUGREPORT
#endif
#ifdef PACKAGE_NAME
#undef PACKAGE_NAME
#endif
#ifdef PACKAGE_STRING
#undef PACKAGE_STRING
#endif
#ifdef PACKAGE_TARNAME
#undef PACKAGE_TARNAME
#endif
#ifdef VERSION
#undef VERSION
#endif
#ifdef PACKAGE_VERSION
#undef PACKAGE_VERSION
#endif
#include "config.h"
#else
#ifndef PACKAGE_VERSION
#error "PACKAGE_VERSION must be defined and equal to the VERSION file included in the belle-sip repository"
#endif
#endif
#ifdef HAVE_DNS_SERVICE // must be tested after config.h is included
#include "dispatch/dispatch.h"
#endif /* HAVE_DNS_SERVICE */
#define SOCKET_NOT_SET ((belle_sip_socket_t)-1)
/*etc*/
#define BELLE_SIP_INTERFACE_GET_METHODS(obj,interface) \
((BELLE_SIP_INTERFACE_METHODS_TYPE(interface)*)belle_sip_object_get_interface_methods((belle_sip_object_t*)obj,BELLE_SIP_INTERFACE_ID(interface)))
#define __BELLE_SIP_INVOKE_LISTENER_BEGIN(list,interface_name,method) \
if (list!=NULL) {\
belle_sip_list_t *__copy=belle_sip_list_copy_with_data((list), (void* (*)(void*))belle_sip_object_ref);\
const belle_sip_list_t *__elem=__copy;\
do{\
void *__method;\
interface_name *__obj=(interface_name*)__elem->data;\
__method=BELLE_SIP_INTERFACE_GET_METHODS(__obj,interface_name)->method;\
if (__method) BELLE_SIP_INTERFACE_GET_METHODS(__obj,interface_name)->
#define __BELLE_SIP_INVOKE_LISTENER_REVERSE_BEGIN(list,interface_name,method) \
if (list!=NULL) {\
belle_sip_list_t *__copy=belle_sip_list_copy_reverse_with_data((list), (void* (*)(void*))belle_sip_object_ref);\
const belle_sip_list_t *__elem=__copy;\
do{\
void *__method;\
interface_name *__obj=(interface_name*)__elem->data;\
__method=BELLE_SIP_INTERFACE_GET_METHODS(__obj,interface_name)->method;\
if (__method) BELLE_SIP_INTERFACE_GET_METHODS(__obj,interface_name)->
#define __BELLE_SIP_INVOKE_LISTENER_END \
__elem=__elem->next;\
}while(__elem!=NULL);\
belle_sip_list_free_with_data(__copy,belle_sip_object_unref);\
}
#define BELLE_SIP_INVOKE_LISTENERS_VOID(list,interface_name,method) \
__BELLE_SIP_INVOKE_LISTENER_BEGIN(list,interface_name,method)\
method(__obj);\
__BELLE_SIP_INVOKE_LISTENER_END
#define BELLE_SIP_INVOKE_LISTENERS_ARG(list,interface_name,method,arg) \
__BELLE_SIP_INVOKE_LISTENER_BEGIN(list,interface_name,method)\
method(__obj,arg);\
__BELLE_SIP_INVOKE_LISTENER_END
#define BELLE_SIP_INVOKE_LISTENERS_ARG1_ARG2(list,interface_name,method,arg1,arg2) \
__BELLE_SIP_INVOKE_LISTENER_BEGIN(list,interface_name,method)\
method(__obj,arg1,arg2);\
__BELLE_SIP_INVOKE_LISTENER_END
#define BELLE_SIP_INVOKE_LISTENERS_REVERSE_ARG1_ARG2(list,interface_name,method,arg1,arg2) \
__BELLE_SIP_INVOKE_LISTENER_REVERSE_BEGIN(list,interface_name,method)\
method(__obj,arg1,arg2);\
__BELLE_SIP_INVOKE_LISTENER_END
#define BELLE_SIP_INVOKE_LISTENERS_ARG1_ARG2_ARG3(list,interface_name,method,arg1,arg2,arg3) \
__BELLE_SIP_INVOKE_LISTENER_BEGIN(list,interface_name)\
method(__obj,arg1,arg2,arg3);\
__BELLE_SIP_INVOKE_LISTENER_END
#define BELLE_SIP_INVOKE_LISTENER_ARG(listener,interface_name,method,arg) \
((BELLE_SIP_INTERFACE_GET_METHODS((listener),interface_name)->method!=NULL) ? \
BELLE_SIP_INTERFACE_GET_METHODS((listener),interface_name)->method(listener,(arg)) : 0 )
typedef struct weak_ref{
struct weak_ref *next;
belle_sip_object_destroy_notify_t notify;
void *userpointer;
}weak_ref_t;
#ifdef __cplusplus
extern "C" {
#endif
void *belle_sip_object_get_interface_methods(belle_sip_object_t *obj, belle_sip_interface_id_t ifid);
/*used internally by unref()*/
void belle_sip_object_delete(void *obj);
void belle_sip_object_pool_add(belle_sip_object_pool_t *pool, belle_sip_object_t *obj);
void belle_sip_object_pool_remove(belle_sip_object_pool_t *pool, belle_sip_object_t *obj);
belle_sip_object_t * _belle_sip_object_init(belle_sip_object_t *obj, belle_sip_object_vptr_t *vptr);
void belle_sip_cpp_object_delete(belle_sip_object_t *obj);
const char * belle_sip_cpp_object_get_type_name(const belle_sip_object_t *obj);
void belle_sip_object_uninit(belle_sip_object_t *obj);
#define belle_sip_object_init(obj) /*nothing*/
/*list of all vptrs (classes) used in belle-sip*/
BELLE_SIP_DECLARE_VPTR(belle_sip_stack_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_datagram_listening_point_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_provider_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_main_loop_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_source_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_dialog_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_address_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_contact_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_from_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_to_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_via_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_diversion_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_uri_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_message_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_request_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_response_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_parameters_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_call_id_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_retry_after_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_cseq_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_content_type_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_route_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_record_route_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_user_agent_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_content_length_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_extension_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_authorization_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_www_authenticate_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_proxy_authenticate_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_proxy_authorization_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_max_forwards_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_expires_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_allow_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_attribute_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_bandwidth_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_connection_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_email_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_info_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_key_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_media_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_media_description_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_origin_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_phone_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_raw_attribute_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_repeate_time_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_rtcp_fb_attribute_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_rtcp_xr_attribute_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_content_attribute_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_label_attribute_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_creq_attribute_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_csup_attribute_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_tcap_attribute_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_acap_attribute_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_acfg_attribute_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_pcfg_attribute_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_session_description_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_session_name_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_time_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_time_description_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_uri_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_version_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_base_description_t);
BELLE_SIP_DECLARE_VPTR(belle_sdp_mime_parameter_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_refresher_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_subscription_state_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_service_route_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_refer_to_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_referred_by_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_replaces_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_session_expires_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_date_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_hop_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_object_pool_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_p_preferred_identity_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_privacy_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_certificates_chain_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_signing_key_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_dns_srv_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_dict_t)
BELLE_SIP_DECLARE_VPTR(belle_http_provider_t);
BELLE_SIP_DECLARE_VPTR(belle_http_channel_context_t);
BELLE_SIP_DECLARE_VPTR(belle_http_request_t);
BELLE_SIP_DECLARE_VPTR(belle_http_response_t);
BELLE_SIP_DECLARE_VPTR(belle_generic_uri_t);
BELLE_SIP_DECLARE_VPTR(belle_http_callbacks_t);
BELLE_SIP_DECLARE_VPTR(belle_tls_crypto_config_t);
BELLE_SIP_DECLARE_VPTR(belle_http_header_authorization_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_event_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_supported_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_require_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_content_disposition_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_accept_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_reason_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_header_authentication_info_t);
#ifdef HAVE_MDNS
BELLE_SIP_DECLARE_VPTR(belle_sip_mdns_source_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_mdns_register_t);
#endif
BELLE_SIP_DECLARE_VPTR(belle_sip_resolver_results_t);
BELLE_SIP_DECLARE_VPTR(belle_sip_digest_authentication_policy_t);
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_resolver_context_t,belle_sip_source_t)
void (*cancel)(belle_sip_resolver_context_t *);
void (*notify)(belle_sip_resolver_context_t *);
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_simple_resolver_context_t,belle_sip_resolver_context_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_combined_resolver_context_t,belle_sip_resolver_context_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_dual_resolver_context_t,belle_sip_resolver_context_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
void belle_sip_resolver_context_notify(belle_sip_resolver_context_t *ctx);
struct belle_sip_source{
belle_sip_object_t base;
belle_sip_list_t node;
unsigned long id;
belle_sip_fd_t fd;
unsigned short events,revents;
#ifdef _WIN32
long armed_events;
unsigned short pad;
#endif
int64_t timeout;
void *data;
uint64_t expire_ms;
int index; /* index in pollfd table */
belle_sip_source_func_t notify;
belle_sip_source_remove_callback_t on_remove;
belle_sip_socket_t sock;
unsigned char cancelled;
unsigned char expired;
unsigned char oneshot;
unsigned char notify_required; /*for testing purpose, use to ask for being scheduled*/
bctbx_iterator_t *it; /*for fast removal*/
belle_sip_main_loop_t *ml;
};
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);
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);
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);
void belle_sip_source_uninit(belle_sip_source_t *s);
void belle_sip_source_set_notify(belle_sip_source_t *s, belle_sip_source_func_t func);
/* include private headers */
#include "channel.h"
#define belle_sip_new(type) (type*)belle_sip_malloc(sizeof(type))
#define belle_sip_new0(type) (type*)belle_sip_malloc0(sizeof(type))
#define belle_sip_list_next(elem) ((elem)->next)
/* dictionary */
struct belle_sip_dict {
belle_sip_object_t base;
};
#undef MIN
#define MIN(a,b) ((a)>(b) ? (b) : (a))
#undef MAX
#define MAX(a,b) ((a)>(b) ? (a) : (b))
#define belle_sip_concat bctbx_concat
/*parameters accessors*/
#define GET_SET_STRING(object_type,attribute) \
const char* object_type##_get_##attribute (const object_type##_t* obj) {\
return obj->attribute;\
}\
void object_type##_set_##attribute (object_type##_t* obj,const char* value) {\
const char* previous_value = obj->attribute; /*preserve if same value re-asigned*/ \
if (value) {\
obj->attribute=belle_sip_strdup(value); \
} else obj->attribute=NULL;\
if (previous_value != NULL) belle_sip_free((void*)previous_value);\
}
/*#define GET_SET_STRING_PARAM_NULL_ALLOWED(object_type,attribute) \
GET_STRING_PARAM2(object_type,attribute,attribute) \
void object_type##_set_##func_name (object_type##_t* obj,const char* value) {\
belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS(obj),#attribute,value);\
}
*/
#define GET_SET_STRING_PARAM(object_type,attribute) GET_SET_STRING_PARAM2(object_type,attribute,attribute)
#define GET_SET_STRING_PARAM2(object_type,attribute,func_name) \
GET_STRING_PARAM2(object_type,attribute,func_name) \
void object_type##_set_##func_name (object_type##_t* obj,const char* value) {\
if (belle_sip_parameters_has_parameter(BELLE_SIP_PARAMETERS(obj),#attribute) && !value) {\
belle_sip_parameters_remove_parameter(BELLE_SIP_PARAMETERS(obj),#attribute); \
} else \
belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS(obj),#attribute,value);\
}
#define GET_STRING_PARAM2(object_type,attribute,func_name) \
const char* object_type##_get_##func_name (const object_type##_t* obj) {\
const char* l_value = belle_sip_parameters_get_parameter(BELLE_SIP_PARAMETERS(obj),#attribute);\
if (l_value == NULL) { \
/*belle_sip_warning("cannot find parameters [%s]",#attribute);*/\
return NULL;\
}\
return l_value;\
}
#define DESTROY_STRING(object,attribute) if (object->attribute) belle_sip_free((void*)object->attribute);
#define CLONE_STRING_GENERIC(object_type_src,object_type_dest,attribute,dest,src) \
if ( object_type_src##_get_##attribute (src)) {\
object_type_dest##_set_##attribute(dest,object_type_src##_get_##attribute(src));\
}
#define CLONE_STRING(object_type,attribute,dest,src) CLONE_STRING_GENERIC(object_type,object_type,attribute,dest,src)
#define GET_SET_INT(object_type,attribute,type) GET_SET_INT_PRIVATE(object_type,attribute,type,)
#define GET_SET_INT_PRIVATE(object_type,attribute,type,set_prefix) \
type object_type##_get_##attribute (const object_type##_t* obj) {\
return obj->attribute;\
}\
void set_prefix##object_type##_set_##attribute (object_type##_t* obj,type value) {\
obj->attribute=value;\
}
#define GET_SET_INT_PARAM(object_type,attribute,type) GET_SET_INT_PARAM_PRIVATE(object_type,attribute,type,)
#define GET_SET_INT_PARAM2(object_type,attribute,type,func_name) GET_SET_INT_PARAM_PRIVATE2(object_type,attribute,type,,func_name)
#define ATO_(type,value) ATO_##type(value)
#define ATO_int(value) atoi(value)
#define ATO_float(value) (float)strtod(value,NULL)
#define FORMAT_(type) FORMAT_##type
#define FORMAT_int "%i"
#define FORMAT_float "%f"
#define GET_SET_INT_PARAM_PRIVATE(object_type,attribute,type,set_prefix) GET_SET_INT_PARAM_PRIVATE2(object_type,attribute,type,set_prefix,attribute)
#define GET_SET_INT_PARAM_PRIVATE2(object_type,attribute,type,set_prefix,func_name) \
type object_type##_get_##func_name (const object_type##_t* obj) {\
const char* l_value = belle_sip_parameters_get_parameter(BELLE_SIP_PARAMETERS(obj),#attribute);\
if (l_value == NULL) { \
/*belle_sip_error("cannot find parameters [%s]",#attribute);*/\
return -1;\
}\
return ATO_(type,l_value);\
}\
void set_prefix##object_type##_set_##func_name (object_type##_t* obj,type value) {\
char l_str_value[16];\
if (value == -1) { \
belle_sip_parameters_remove_parameter(BELLE_SIP_PARAMETERS(obj),#attribute);\
return;\
}\
snprintf(l_str_value,16,FORMAT_(type),value);\
belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS(obj),#attribute,(const char*)l_str_value);\
}
#define GET_SET_BOOL(object_type,attribute,getter) \
unsigned int object_type##_##getter##_##attribute (const object_type##_t* obj) {\
return obj->attribute;\
}\
void object_type##_set_##attribute (object_type##_t* obj,unsigned int value) {\
obj->attribute=value;\
}
#define GET_SET_BOOL_PARAM2(object_type,attribute,getter,func_name) \
unsigned int object_type##_##getter##_##func_name (const object_type##_t* obj) {\
return belle_sip_parameters_has_parameter(BELLE_SIP_PARAMETERS(obj),#attribute);\
}\
void object_type##_set_##func_name (object_type##_t* obj,unsigned int value) {\
belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS(obj),#attribute,NULL);\
}
#define ANTLR_STREAM_NEW(object_type, value,length) \
antlr3StringStreamNew((pANTLR3_UINT8)value,ANTLR3_ENC_8BIT,(ANTLR3_UINT32)length,(pANTLR3_UINT8)#object_type)
#define BELLE_PARSE(parser_name, object_type_prefix, object_type) \
object_type_prefix##object_type##_t* object_type_prefix##object_type##_parse (const char* value) { \
pANTLR3_INPUT_STREAM input; \
pbelle_sip_messageLexer lex; \
pANTLR3_COMMON_TOKEN_STREAM tokens; \
p##parser_name parser; \
object_type_prefix##object_type##_t* l_parsed_object; \
input = ANTLR_STREAM_NEW(object_type,value,strlen(value));\
lex = belle_sip_messageLexerNew (input);\
tokens = antlr3CommonTokenStreamSourceNew (ANTLR3_SIZE_HINT, TOKENSOURCE(lex));\
parser = parser_name##New (tokens);\
l_parsed_object = parser->object_type(parser);\
parser ->free(parser);\
tokens ->free(tokens);\
lex ->free(lex);\
input ->close(input);\
if (l_parsed_object == NULL) belle_sip_error(#object_type" parser error for [%s]",value);\
return l_parsed_object;\
}
#define BELLE_SIP_PARSE(object_type) BELLE_PARSE(belle_sip_messageParser,belle_sip_,object_type)
#define BELLE_NEW(object_type,super_type) \
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(object_type##_t); \
BELLE_SIP_INSTANCIATE_VPTR( object_type##_t\
, super_type##_t\
, object_type##_destroy\
, object_type##_clone\
, object_type##_marshal, TRUE); \
object_type##_t* object_type##_new () { \
object_type##_t* l_object = belle_sip_object_new(object_type##_t);\
super_type##_init((super_type##_t*)l_object); \
object_type##_init((object_type##_t*) l_object); \
return l_object;\
}
#define BELLE_SIP_NEW(object_type,super_type) BELLE_NEW (belle_sip_##object_type, belle_sip_##super_type)
#define BELLE_SIP_NEW_HEADER(object_type,super_type,name) BELLE_SIP_NEW_HEADER_INIT(object_type,super_type,name,header)
#define BELLE_SIP_NEW_HEADER_INIT(object_type,super_type,name,init_type) \
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_##object_type##_t); \
BELLE_SIP_INSTANCIATE_VPTR( belle_sip_##object_type##_t\
, belle_sip_##super_type##_t\
, belle_sip_##object_type##_destroy\
, belle_sip_##object_type##_clone\
, belle_sip_##object_type##_marshal, TRUE); \
belle_sip_##object_type##_t* belle_sip_##object_type##_new () { \
belle_sip_##object_type##_t* l_object = belle_sip_object_new(belle_sip_##object_type##_t);\
belle_sip_##super_type##_init((belle_sip_##super_type##_t*)l_object); \
belle_sip_##init_type##_init((belle_sip_##init_type##_t*) l_object); \
if (name) belle_sip_header_set_name(BELLE_SIP_HEADER(l_object),name);\
return l_object;\
}
struct belle_sip_param_pair {
int ref;
char* name;
char* value;
} ;
void belle_sip_param_pair_destroy(belle_sip_param_pair_t* pair) ;
int belle_sip_param_pair_comp_func(const belle_sip_param_pair_t *a, const char*b) ;
int belle_sip_param_pair_case_comp_func(const belle_sip_param_pair_t *a, const char*b) ;
belle_sip_param_pair_t* belle_sip_param_pair_ref(belle_sip_param_pair_t* obj);
void belle_sip_param_pair_unref(belle_sip_param_pair_t* obj);
/*class header*/
struct _belle_sip_header {
belle_sip_object_t base;
belle_sip_header_t* next;
char *name;
char *unparsed_value;
};
void belle_sip_response_fill_for_dialog(belle_sip_response_t *obj, belle_sip_request_t *req);
void belle_sip_util_copy_headers(belle_sip_message_t *orig, belle_sip_message_t *dest, const char*header, int multiple);
void belle_sip_header_init(belle_sip_header_t* obj);
/*class parameters*/
struct _belle_sip_parameters {
belle_sip_header_t base;
belle_sip_list_t* param_list;
belle_sip_list_t* paramnames_list;
};
void belle_sip_parameters_init(belle_sip_parameters_t *obj);
/*
* Listening points
*/
#include "listeningpoint_internal.h"
struct belle_sip_hop{
belle_sip_object_t base;
char *cname;
char *host;
char *transport;
int port;
int port_is_explicit;
};
/*
belle_sip_stack_t
*/
struct belle_sip_stack{
belle_sip_object_t base;
belle_sip_main_loop_t *ml;
belle_sip_timer_config_t timer_config;
int transport_timeout;
int unreliable_transport_timeout;
int inactive_transport_timeout;
int dns_timeout;
int tx_delay; /*used to simulate network transmission delay, for tests*/
int send_error; /* used to simulate network error. if <0, channel_send will return this value*/
int resolver_tx_delay; /*used to simulate network transmission delay, for tests*/
int resolver_send_error; /* used to simulate network error*/
int test_bind_port;
int dscp;
char *dns_user_hosts_file; /* used to load additional hosts file for tests */
char *dns_resolv_conf; /*used to load custom resolv.conf, for tests*/
belle_sip_list_t *dns_servers; /*used when dns servers are supplied by app layer*/
/*http proxy stuff to be used by both http and sip provider*/
char *http_proxy_host;
int http_proxy_port;
char *http_proxy_username; /*for future use*/
char *http_proxy_passwd; /*for future use*/
belle_sip_digest_authentication_policy_t *digest_auth_policy;
unsigned char dns_srv_enabled;
unsigned char dns_search_enabled;
unsigned char reconnect_to_primary_asap;
unsigned char simulate_non_working_srv;
#ifdef HAVE_DNS_SERVICE
dispatch_queue_t dns_service_queue;
unsigned char use_dns_service;
#endif /* HAVE_DNS_SERVICE */
};
BELLESIP_EXPORT belle_sip_hop_t* belle_sip_hop_new(const char* transport, const char *cname, const char* host,int port);
BELLESIP_EXPORT belle_sip_hop_t* belle_sip_hop_new_from_uri(const belle_sip_uri_t *uri);
BELLESIP_EXPORT belle_sip_hop_t* belle_sip_hop_new_from_generic_uri(const belle_generic_uri_t *uri);
BELLESIP_EXPORT belle_sip_hop_t * belle_sip_stack_get_next_hop(belle_sip_stack_t *stack, belle_sip_request_t *req);
/* Return -1 if requested authentication is not compatible with local digest authentication security policy, 0 if compatible. */
BELLESIP_EXPORT int belle_sip_stack_check_digest_compatibility(const belle_sip_stack_t *stack, const belle_sip_header_www_authenticate_t *authenticate);
/*
belle_sip_provider_t
*/
struct belle_sip_provider{
belle_sip_object_t base;
belle_sip_stack_t *stack;
belle_sip_list_t *lps; /*listening points*/
belle_sip_list_t *listeners;
belle_sip_list_t *internal_listeners; /*for transaction internaly managed by belle-sip. I.E by refreshers*/
belle_sip_list_t *client_transactions;
belle_sip_list_t *server_transactions;
belle_sip_list_t *dialogs;
belle_sip_list_t *auth_contexts;
unsigned short unconditional_answer;
unsigned char rport_enabled; /*0 if rport should not be set in via header*/
unsigned char nat_helper;
unsigned char unconditional_answer_enabled;
unsigned char response_integrity_checking_enabled;
};
BELLESIP_EXPORT belle_sip_provider_t *belle_sip_provider_new(belle_sip_stack_t *s, belle_sip_listening_point_t *lp);
void belle_sip_provider_add_client_transaction(belle_sip_provider_t *prov, belle_sip_client_transaction_t *t);
belle_sip_client_transaction_t *belle_sip_provider_find_matching_client_transaction(belle_sip_provider_t *prov, belle_sip_response_t *resp);
void belle_sip_provider_remove_client_transaction(belle_sip_provider_t *prov, belle_sip_client_transaction_t *t);
void belle_sip_provider_add_server_transaction(belle_sip_provider_t *prov, belle_sip_server_transaction_t *t);
BELLESIP_EXPORT belle_sip_server_transaction_t * belle_sip_provider_find_matching_server_transaction(belle_sip_provider_t *prov,belle_sip_request_t *req);
void belle_sip_provider_remove_server_transaction(belle_sip_provider_t *prov, belle_sip_server_transaction_t *t);
void belle_sip_provider_set_transaction_terminated(belle_sip_provider_t *p, belle_sip_transaction_t *t);
void *belle_sip_transaction_get_application_data_internal(const belle_sip_transaction_t *t);
BELLESIP_EXPORT belle_sip_channel_t * belle_sip_provider_get_channel(belle_sip_provider_t *p, const belle_sip_hop_t *hop);
void belle_sip_provider_add_dialog(belle_sip_provider_t *prov, belle_sip_dialog_t *dialog);
void belle_sip_provider_remove_dialog(belle_sip_provider_t *prov, belle_sip_dialog_t *dialog);
void belle_sip_provider_release_channel(belle_sip_provider_t *p, belle_sip_channel_t *chan);
void belle_sip_provider_add_internal_sip_listener(belle_sip_provider_t *p, belle_sip_listener_t *l, int prepend);
void belle_sip_provider_remove_internal_sip_listener(belle_sip_provider_t *p, belle_sip_listener_t *l);
belle_sip_client_transaction_t * belle_sip_provider_find_matching_client_transaction_from_req(belle_sip_provider_t *prov, belle_sip_request_t *req);
belle_sip_dialog_t *belle_sip_provider_find_dialog_from_message(belle_sip_provider_t *prov, belle_sip_message_t *msg, int as_uas);
/*for testing purpose only:*/
BELLESIP_EXPORT void belle_sip_provider_dispatch_message(belle_sip_provider_t *prov, belle_sip_message_t *msg);
typedef struct listener_ctx{
belle_sip_listener_t *listener;
void *data;
}listener_ctx_t;
#define BELLE_SIP_PROVIDER_INVOKE_LISTENERS_FOR_TRANSACTION(t,callback,event) \
BELLE_SIP_PROVIDER_INVOKE_LISTENERS((t)->is_internal?(t)->provider->internal_listeners:(t)->provider->listeners,callback,event)
#define BELLE_SIP_PROVIDER_INVOKE_LISTENERS_FOR_DIALOG(d,callback,event) \
BELLE_SIP_PROVIDER_INVOKE_LISTENERS((d)->is_internal?(d)->provider->internal_listeners:(d)->provider->listeners,callback,event)
#define BELLE_SIP_PROVIDER_INVOKE_LISTENERS(listeners,callback,event) \
BELLE_SIP_INVOKE_LISTENERS_ARG((listeners),belle_sip_listener_t,callback,(event))
/*
* http provider
*/
belle_http_provider_t *belle_http_provider_new(belle_sip_stack_t *s, const char *bind_ip, const uint8_t transports);
/*
* SIP and http messages
**/
void belle_sip_message_init(belle_sip_message_t *message);
struct _belle_sip_message {
belle_sip_object_t base;
belle_sip_list_t* header_list;
belle_sip_body_handler_t *body_handler;
char *multipart_body_cache;
};
struct _belle_sip_request {
belle_sip_message_t base;
char* method;
belle_sip_uri_t* uri;
belle_generic_uri_t *absolute_uri;
belle_sip_dialog_t *dialog;/*set if request was created by a dialog to avoid to search in dialog list*/
char *rfc2543_branch; /*computed 'branch' id in case we receive this request from an old RFC2543 stack*/
unsigned char dialog_queued;
};
/** HTTP request**/
struct belle_http_request{
belle_sip_message_t base;
belle_generic_uri_t *req_uri;
char* method;
belle_http_request_listener_t *listener;
belle_generic_uri_t *orig_uri;/*original uri before removing host and user/passwd*/
belle_http_response_t *response;
belle_sip_channel_t *channel;
int auth_attempt_count;
int background_task_id;
int cancelled;
int resubmitted; /* Indicates whether this request has been resubmitted to a new channel after the first one was closed by the server.*/
};
void belle_http_request_set_listener(belle_http_request_t *req, belle_http_request_listener_t *l);
void belle_http_request_set_channel(belle_http_request_t *req, belle_sip_channel_t *chan);
void belle_http_request_set_response(belle_http_request_t *req, belle_http_response_t *resp);
/*
belle_sip_transaction_t
*/
struct belle_sip_transaction{
belle_sip_object_t base;
belle_sip_provider_t *provider; /*the provider that created this transaction */
belle_sip_request_t *request;
belle_sip_response_t *last_response;
belle_sip_channel_t *channel;
belle_sip_dialog_t *dialog;
belle_sip_source_t *call_repair_timer;
char *branch_id;
belle_sip_transaction_state_t state;
void *appdata;
unsigned char is_internal;
unsigned char timed_out;
unsigned char sent_by_dialog_queue;
unsigned long bg_task_id;
};
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_transaction_t,belle_sip_object_t)
void (*on_terminate)(belle_sip_transaction_t *obj);
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
static BELLESIP_INLINE const belle_sip_timer_config_t * belle_sip_transaction_get_timer_config(belle_sip_transaction_t *obj){
return belle_sip_stack_get_timer_config(obj->provider->stack);
}
static BELLESIP_INLINE void belle_sip_transaction_start_timer(belle_sip_transaction_t *obj, belle_sip_source_t *timer){
belle_sip_main_loop_add_source(obj->provider->stack->ml,timer);
}
/** */
static BELLESIP_INLINE void belle_sip_transaction_stop_timer(belle_sip_transaction_t *obj, belle_sip_source_t *timer){
belle_sip_main_loop_remove_source(obj->provider->stack->ml,timer);
}
int belle_sip_client_transaction_is_notify_matching_pending_subscribe(belle_sip_client_transaction_t *trans
, belle_sip_request_t *notify);
void belle_sip_transaction_notify_timeout(belle_sip_transaction_t *t);
void belle_sip_transaction_set_dialog(belle_sip_transaction_t *t, belle_sip_dialog_t *dialog);
void belle_sip_transaction_set_state(belle_sip_transaction_t *t, belle_sip_transaction_state_t state);
/*
*
*
* Client transaction
*
*
*/
struct belle_sip_client_transaction{
belle_sip_transaction_t base;
belle_sip_uri_t* preset_route; /*use to store outbound proxy, will be helpful for refresher*/
belle_sip_hop_t* next_hop; /*use to send cancel request*/
};
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_client_transaction_t,belle_sip_transaction_t)
void (*send_request)(belle_sip_client_transaction_t *);
void (*on_response)(belle_sip_client_transaction_t *obj, belle_sip_response_t *resp);
void (*stop_retransmissions)(belle_sip_client_transaction_t *obj);
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
void belle_sip_client_transaction_init(belle_sip_client_transaction_t *obj, belle_sip_provider_t *prov, belle_sip_request_t *req);
void belle_sip_client_transaction_add_response(belle_sip_client_transaction_t *t, belle_sip_response_t *resp);
void belle_sip_client_transaction_notify_response(belle_sip_client_transaction_t *t, belle_sip_response_t *resp);
struct belle_sip_ict{
belle_sip_client_transaction_t base;
belle_sip_source_t *timer_A;
belle_sip_source_t *timer_B;
belle_sip_source_t *timer_D;
belle_sip_source_t *timer_M;
belle_sip_request_t *ack;
/*last acknoleged provisional response sequence number. Note that "The RSeq numbering space is within a single transaction."*/
unsigned int r_cseq;
};
typedef struct belle_sip_ict belle_sip_ict_t;
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_ict_t,belle_sip_client_transaction_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
belle_sip_ict_t * belle_sip_ict_new(belle_sip_provider_t *prov, belle_sip_request_t *req);
struct belle_sip_nict{
belle_sip_client_transaction_t base;
belle_sip_source_t *timer_F;
belle_sip_source_t *timer_E;
belle_sip_source_t *timer_K;
};
typedef struct belle_sip_nict belle_sip_nict_t;
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_nict_t,belle_sip_client_transaction_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
belle_sip_nict_t * belle_sip_nict_new(belle_sip_provider_t *prov, belle_sip_request_t *req);
/*
*
*
* Server transaction
*
*
*/
struct belle_sip_server_transaction{
belle_sip_transaction_t base;
char to_tag[8];
};
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_server_transaction_t,belle_sip_transaction_t)
int (*send_new_response)(belle_sip_server_transaction_t *, belle_sip_response_t *resp);
void (*on_request_retransmission)(belle_sip_server_transaction_t *obj);
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
void belle_sip_server_transaction_init(belle_sip_server_transaction_t *t, belle_sip_provider_t *prov,belle_sip_request_t *req);
void belle_sip_server_transaction_on_request(belle_sip_server_transaction_t *t, belle_sip_request_t *req);
struct belle_sip_ist{
belle_sip_server_transaction_t base;
belle_sip_source_t *timer_G;
belle_sip_source_t *timer_H;
belle_sip_source_t *timer_I;
belle_sip_source_t *timer_L;
};
typedef struct belle_sip_ist belle_sip_ist_t;
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_ist_t,belle_sip_server_transaction_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
belle_sip_ist_t * belle_sip_ist_new(belle_sip_provider_t *prov, belle_sip_request_t *req);
/* returns 0 if the ack should be notified to TU, or -1 otherwise*/
int belle_sip_ist_process_ack(belle_sip_ist_t *obj, belle_sip_message_t *ack);
struct belle_sip_nist{
belle_sip_server_transaction_t base;
belle_sip_source_t *timer_J;
};
typedef struct belle_sip_nist belle_sip_nist_t;
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_nist_t,belle_sip_server_transaction_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
belle_sip_nist_t * belle_sip_nist_new(belle_sip_provider_t *prov, belle_sip_request_t *req);
typedef enum belle_sip_dialog_type{
BELLE_SIP_DIALOG_INVITE,
BELLE_SIP_DIALOG_SUBSCRIBE_NOTIFY
}belle_sip_dialog_type_t;
/*
* Dialogs
*/
struct belle_sip_dialog{
belle_sip_object_t base;
void *appdata;
belle_sip_dialog_type_t type;
belle_sip_provider_t *provider;
belle_sip_request_t *last_out_invite;
belle_sip_request_t *last_out_ack; /*so that it can be retransmitted when needed*/
belle_sip_response_t *last_200Ok;
belle_sip_source_t *timer_200Ok;
belle_sip_source_t *timer_200Ok_end;
belle_sip_dialog_state_t state;
belle_sip_dialog_state_t previous_state;
belle_sip_header_call_id_t *call_id;
belle_sip_header_address_t *local_party;
belle_sip_header_address_t *remote_party;
belle_sip_list_t *route_set;
belle_sip_header_address_t *remote_target;
belle_sip_source_t *expiration_timer;
belle_sip_dialog_termination_cause_t termination_cause;
char *local_tag;
char *remote_tag;
unsigned int local_cseq;
unsigned int remote_cseq;
belle_sip_transaction_t* last_transaction;
belle_sip_header_privacy_t* privacy;
belle_sip_list_t *queued_ct;/* queued client transactions*/
unsigned int remote_invite_cseq; /*needed because multiple trans can be handled whithin invite transaction (I.E UPDATE, PRACK,etc*/
unsigned char is_server;
unsigned char is_secure;
unsigned char terminate_on_bye;
unsigned char needs_ack;
unsigned char is_expired;
unsigned char pending_trans_checking_enabled; /*use to disabled pending transaction check at request creation (testing)*/
unsigned char is_internal; /*Internal dialogs are those created by refreshers. */
unsigned char simulate_lost_ack; /*used by testers*/
};
belle_sip_dialog_t *belle_sip_dialog_new(belle_sip_transaction_t *t);
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);
int belle_sip_dialog_can_accept_request(const belle_sip_dialog_t *dialog, belle_sip_request_t *request) ;
/*returns 1 if message belongs to the dialog, 0 otherwise */
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);
int _belle_sip_dialog_match(belle_sip_dialog_t *obj, const char *call_id, const char *local_tag, const char *remote_tag);
int belle_sip_dialog_match(belle_sip_dialog_t *obj, belle_sip_message_t *msg, int as_uas);
int belle_sip_dialog_update(belle_sip_dialog_t *obj,belle_sip_transaction_t* transaction, int as_uas);
void belle_sip_dialog_check_ack_sent(belle_sip_dialog_t*obj);
int belle_sip_dialog_handle_ack(belle_sip_dialog_t *obj, belle_sip_request_t *ack);
void belle_sip_dialog_queue_client_transaction(belle_sip_dialog_t *dialog, belle_sip_client_transaction_t *tr);
void belle_sip_dialog_stop_200Ok_retrans(belle_sip_dialog_t *obj);
/*
belle_sip_response_t
*/
belle_sip_hop_t* belle_sip_response_get_return_hop(belle_sip_response_t *msg);
/*********************************************************
* SDP
*/
#define BELLE_SDP_PARSE(object_type) \
belle_sdp_##object_type##_t* belle_sdp_##object_type##_parse (const char* value) { \
if (!belle_sdp_use_belr) {\
pANTLR3_INPUT_STREAM input; \
pbelle_sdpLexer lex; \
pANTLR3_COMMON_TOKEN_STREAM tokens; \
pbelle_sdpParser parser; \
belle_sdp_##object_type##_t* l_parsed_object; \
input = ANTLR_STREAM_NEW(object_type, value,strlen(value));\
lex = belle_sdpLexerNew (input);\
tokens = antlr3CommonTokenStreamSourceNew (ANTLR3_SIZE_HINT, TOKENSOURCE(lex));\
parser = belle_sdpParserNew (tokens);\
l_parsed_object = parser->object_type(parser).ret;\
parser ->free(parser);\
tokens ->free(tokens);\
lex ->free(lex);\
input ->close(input);\
if (l_parsed_object == NULL) belle_sip_error(#object_type" parser error for [%s]",value);\
return l_parsed_object;\
} else {\
auto parser = bellesip::SDP::Parser::getInstance();\
auto object = parser->parse(value, #object_type);\
if (object == NULL) belle_sip_error(#object_type" parser error for [%s]",value);\
return (belle_sdp_##object_type##_t *)object;\
}\
}
#define BELLE_SDP_BELR_PARSE(object_type) \
belle_sdp_##object_type##_t* belle_sdp_##object_type##_parse (const char* value) { \
auto parser = bellesip::SDP::Parser::getInstance();\
auto object = parser->parse(value, #object_type);\
if (object == NULL) belle_sip_error(#object_type" parser error for [%s]",value);\
return (belle_sdp_##object_type##_t *)object;\
}
#define BELLE_SDP_NEW(object_type,super_type) \
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sdp_##object_type##_t); \
BELLE_SIP_INSTANCIATE_VPTR( belle_sdp_##object_type##_t\
, super_type##_t\
, belle_sdp_##object_type##_destroy\
, belle_sdp_##object_type##_clone\
, belle_sdp_##object_type##_marshal, TRUE); \
belle_sdp_##object_type##_t* belle_sdp_##object_type##_new () { \
belle_sdp_##object_type##_t* l_object = belle_sip_object_new(belle_sdp_##object_type##_t);\
super_type##_init((super_type##_t*)l_object); \
return l_object;\
}
#define BELLE_SDP_NEW_WITH_CTR(object_type,super_type) \
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sdp_##object_type##_t); \
BELLE_SIP_INSTANCIATE_VPTR( belle_sdp_##object_type##_t\
, super_type##_t\
, belle_sdp_##object_type##_destroy\
, belle_sdp_##object_type##_clone\
, belle_sdp_##object_type##_marshal,TRUE); \
belle_sdp_##object_type##_t* belle_sdp_##object_type##_new () { \
belle_sdp_##object_type##_t* l_object = belle_sip_object_new(belle_sdp_##object_type##_t);\
super_type##_init((super_type##_t*)l_object); \
belle_sdp_##object_type##_init(l_object); \
return l_object;\
}
struct belle_sip_dialog_terminated_event{
belle_sip_provider_t *source;
belle_sip_dialog_t *dialog;
int is_expired;
};
struct belle_sip_io_error_event{
belle_sip_object_t *source; /*the object impacted by this error*/
const char *transport;
const char *host;
unsigned int port;
};
struct belle_sip_request_event{
belle_sip_object_t *source;
belle_sip_server_transaction_t *server_transaction;
belle_sip_dialog_t *dialog;
belle_sip_request_t *request;
};
struct belle_sip_response_event{
belle_sip_object_t *source;
belle_sip_client_transaction_t *client_transaction;
belle_sip_dialog_t *dialog;
belle_sip_response_t *response;
};
struct belle_sip_timeout_event{
belle_sip_object_t *source;
belle_sip_transaction_t *transaction;
int is_server_transaction;
};
struct belle_sip_transaction_terminated_event{
belle_sip_provider_t *source;
belle_sip_transaction_t *transaction;
int is_server_transaction;
};
struct belle_sip_auth_event {
belle_sip_object_t *source;
belle_sip_auth_mode_t mode;
char* username;
char* userid;
char* realm;
char* passwd;
char* ha1;
char* domain;
char* distinguished_name;
belle_sip_certificates_chain_t * cert;
belle_sip_signing_key_t* key;
char* algorithm; /* either MD5 ot SHA256*/
};
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);
void belle_sip_auth_event_set_distinguished_name(belle_sip_auth_event_t* event,const char* value);
/*
* refresher
* */
belle_sip_refresher_t* belle_sip_refresher_new(belle_sip_client_transaction_t* transaction);
/*
* returns a char, even if entry is escaped*/
size_t belle_sip_get_char (const char*a,char*out);
/*return an escaped string*/
BELLESIP_EXPORT char* belle_sip_uri_to_escaped_userpasswd(const char* buff) ;
BELLESIP_EXPORT char* belle_sip_uri_to_escaped_parameter(const char* buff) ;
BELLESIP_EXPORT char* belle_sip_uri_to_escaped_header(const char* buff) ;
/*(uri RFC 2396)*/
BELLESIP_EXPORT char* belle_generic_uri_to_escaped_query(const char* buff);
BELLESIP_EXPORT char* belle_generic_uri_to_escaped_path(const char* buff);
#define BELLE_SIP_SOCKET_TIMEOUT 30000
#define BELLE_SIP_BRANCH_ID_LENGTH 10
/*Shall not be less than 32bit */
#define BELLE_SIP_TAG_LENGTH 6
#define BELLE_SIP_MAX_TO_STRING_SIZE 2048
void belle_sip_header_contact_set_unknown(belle_sip_header_contact_t *a, int value);
void belle_sip_request_set_dialog(belle_sip_request_t *req, belle_sip_dialog_t *dialog);
void belle_sip_request_set_rfc2543_branch(belle_sip_request_t *req, const char *rfc2543branch);
void belle_sip_dialog_update_request(belle_sip_dialog_t *dialog, belle_sip_request_t *req);
belle_sip_error_code belle_sip_headers_marshal(belle_sip_message_t *message, char* buff, size_t buff_size, size_t *offset);
#define SET_OBJECT_PROPERTY(obj,property_name,new_value) \
if (new_value) belle_sip_object_ref(new_value); \
if (obj->property_name){ \
belle_sip_object_unref(obj->property_name); \
}\
obj->property_name=new_value;
#include "parserutils.h"
/******************************
*
* private Extension header inherit from header
*
******************************/
typedef struct _belle_sip_header_extension belle_sip_header_extension_t;
belle_sip_header_extension_t* belle_sip_header_extension_new(void);
belle_sip_header_extension_t* belle_sip_header_extension_parse (const char* extension) ;
BELLESIP_EXPORT belle_sip_header_extension_t* belle_sip_header_extension_create (const char* name,const char* value);
BELLESIP_EXPORT const char* belle_sip_header_extension_get_value(const belle_sip_header_extension_t* extension);
void belle_sip_header_extension_set_value(belle_sip_header_extension_t* extension,const char* value);
#define BELLE_SIP_HEADER_EXTENSION(t) BELLE_SIP_CAST(t,belle_sip_header_extension_t)
/****************
* belle_sip_body_handler_t object
***************/
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_body_handler_t,belle_sip_object_t)
void (*begin_recv_transfer)(belle_sip_body_handler_t *obj);
void (*begin_send_transfer)(belle_sip_body_handler_t *obj);
void (*end_transfer)(belle_sip_body_handler_t *obj);
void (*chunk_recv)(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, off_t offset, uint8_t *buf, size_t size);
int (*chunk_send)(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, off_t offset, uint8_t *buf, size_t * size);
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
void belle_sip_body_handler_begin_recv_transfer(belle_sip_body_handler_t *obj);
void belle_sip_body_handler_begin_send_transfer(belle_sip_body_handler_t *obj);
void belle_sip_body_handler_recv_chunk(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, uint8_t *buf, size_t size);
int belle_sip_body_handler_send_chunk(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, uint8_t *buf, size_t *size);
void belle_sip_body_handler_end_transfer(belle_sip_body_handler_t *obj);
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_memory_body_handler_t,belle_sip_body_handler_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_user_body_handler_t,belle_sip_body_handler_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_file_body_handler_t,belle_sip_body_handler_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_multipart_body_handler_t,belle_sip_body_handler_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
/**
* file manipulation
*/
typedef struct authorization_context authorization_context_t;
typedef authorization_context_t belle_sip_authorization_t;
BELLESIP_EXPORT void belle_sip_authorization_destroy(belle_sip_authorization_t* object);
BELLESIP_EXPORT const char *belle_sip_authorization_get_algorithm(const belle_sip_authorization_t* object);
/**
* Generate a random unsigned int
*/
uint32_t belle_sip_random(void);
#ifdef __cplusplus
}
#endif
#if TARGET_OS_IPHONE
int belle_sip_get_ios_device_major_version();
#endif
#endif
belle-sip-5.2.0+dfsg/src/belle_sip_loop.c 0000664 0000000 0000000 00000057763 14346131365 0020263 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "belle-sip/belle-sip.h"
#include "belle_sip_internal.h"
#include "bctoolbox/map.h"
#include
#ifndef _WIN32
#include
#include
typedef struct pollfd belle_sip_pollfd_t;
static int belle_sip_poll(belle_sip_pollfd_t *pfd, int count, int duration){
int err;
err=poll(pfd,count,duration);
if (err==-1 && errno!=EINTR)
belle_sip_error("poll() error: %s",strerror(errno));
return err;
}
/*
Poll() based implementation of event loop.
*/
static int belle_sip_event_to_poll(unsigned int events){
int ret=0;
if (events & BELLE_SIP_EVENT_READ)
ret|=POLLIN;
if (events & BELLE_SIP_EVENT_WRITE)
ret|=POLLOUT;
if (events & BELLE_SIP_EVENT_ERROR)
ret|=POLLERR;
return ret;
}
static unsigned int belle_sip_poll_to_event(belle_sip_pollfd_t * pfd){
unsigned int ret=0;
short events=pfd->revents;
if (events & POLLIN)
ret|=BELLE_SIP_EVENT_READ;
if (events & POLLOUT)
ret|=BELLE_SIP_EVENT_WRITE;
if (events & POLLERR)
ret|=BELLE_SIP_EVENT_ERROR;
return ret;
}
static void belle_sip_source_to_poll(belle_sip_source_t *s, belle_sip_pollfd_t *pfd, int i){
pfd[i].fd=s->fd;
pfd[i].events=belle_sip_event_to_poll(s->events);
pfd[i].revents=0;
s->index=i;
}
static unsigned int belle_sip_source_get_revents(belle_sip_source_t *s,belle_sip_pollfd_t *pfd){
return belle_sip_poll_to_event(&pfd[s->index]);
}
#else
#include
typedef HANDLE belle_sip_pollfd_t;
static void belle_sip_source_to_poll(belle_sip_source_t *s, belle_sip_pollfd_t *pfd,int i){
s->index=i;
pfd[i]=s->fd;
/*special treatments for windows sockets*/
if (s->sock!=(belle_sip_socket_t)-1){
int err;
long events=0;
if (s->events & BELLE_SIP_EVENT_READ)
events|=FD_READ|FD_ACCEPT;
if (s->events & BELLE_SIP_EVENT_WRITE)
events|=FD_WRITE|FD_CONNECT;
if (events!=s->armed_events){
s->armed_events=events;
err=WSAEventSelect(s->sock,s->fd,events);
if (err!=0) belle_sip_error("WSAEventSelect() failed: %s",belle_sip_get_socket_error_string());
}
}
}
static unsigned int belle_sip_source_get_revents(belle_sip_source_t *s,belle_sip_pollfd_t *pfd){
WSANETWORKEVENTS revents={0};
int err;
unsigned int ret=0;
if (WaitForSingleObjectEx(s->fd,0,FALSE)==WAIT_OBJECT_0){
if (s->sock!=(belle_sip_socket_t)-1){
/*special treatments for windows sockets*/
err=WSAEnumNetworkEvents(s->sock,s->fd,&revents);
if (err!=0){
belle_sip_error("WSAEnumNetworkEvents() failed: %s socket=%x",belle_sip_get_socket_error_string(),(unsigned int)s->sock);
return 0;
}
if (revents.lNetworkEvents & FD_READ || revents.lNetworkEvents & FD_ACCEPT){
ret|=BELLE_SIP_EVENT_READ;
}
if (revents.lNetworkEvents & FD_WRITE || revents.lNetworkEvents & FD_CONNECT){
ret|=BELLE_SIP_EVENT_WRITE;
}
s->armed_events=0;
}else{
ret=BELLE_SIP_EVENT_READ;
ResetEvent(s->fd);
}
}
return ret;
}
static int belle_sip_poll(belle_sip_pollfd_t *pfd, int count, int duration){
DWORD ret;
if (count == 0) {
belle_sip_sleep(duration);
return 0;
}
ret=WaitForMultipleObjectsEx(count,pfd,FALSE,duration,FALSE);
if (ret==WAIT_FAILED){
belle_sip_error("WaitForMultipleObjectsEx() failed.");
return -1;
}
if (ret==WAIT_TIMEOUT){
return 0;
}
return ret-WAIT_OBJECT_0;
}
#endif
static void belle_sip_source_destroy(belle_sip_source_t *obj){
if (obj->node.next || obj->node.prev){
belle_sip_fatal("Destroying source currently used in main loop !");
}
belle_sip_source_uninit(obj);
}
static void belle_sip_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){
static unsigned long global_id=1;
s->node.data=s;
if (s->id==0) s->id=global_id++;
s->fd=fd;
s->events=events;
s->timeout=timeout_value_ms;
s->data=data;
s->notify=func;
s->sock=(belle_sip_socket_t)-1;
}
void belle_sip_source_uninit(belle_sip_source_t *obj){
#ifdef _WIN32
if (obj->sock!=(belle_sip_socket_t)-1){
WSACloseEvent(obj->fd);
obj->fd=(WSAEVENT)-1;
}
#endif
obj->fd=(belle_sip_fd_t)-1;
obj->sock=(belle_sip_socket_t)-1;
/* if (obj->it) {
bctbx_iterator_delete(obj->it);
obj->it=NULL;
}*/
}
void belle_sip_source_set_notify(belle_sip_source_t *s, belle_sip_source_func_t func) {
s->notify = func;
}
void belle_sip_socket_source_init(belle_sip_source_t *s, belle_sip_source_func_t func, void *data, belle_sip_socket_t sock, unsigned int events, unsigned int timeout_value_ms){
#ifdef _WIN32
/*on windows, the fd to poll is not the socket */
belle_sip_fd_t fd=(belle_sip_fd_t)-1;
if (sock!=(belle_sip_socket_t)-1)
fd=WSACreateEvent();
else
fd=(WSAEVENT)-1;
belle_sip_source_init(s,func,data,fd,events,timeout_value_ms);
#else
belle_sip_source_init(s,func,data,sock,events,timeout_value_ms);
#endif
s->sock=sock;
if (sock!=(belle_sip_socket_t)-1)
belle_sip_socket_set_nonblocking(sock);
}
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){
belle_sip_source_init(s,func,data,fd,events,timeout_value_ms);
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_source_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_sip_source_t,belle_sip_object_t,belle_sip_source_destroy,NULL,NULL,FALSE);
belle_sip_source_t * belle_sip_socket_source_new(belle_sip_source_func_t func, void *data, belle_sip_socket_t sock, unsigned int events, unsigned int timeout_value_ms){
belle_sip_source_t *s=belle_sip_object_new(belle_sip_source_t);
belle_sip_socket_source_init(s,func,data,sock,events,timeout_value_ms);
return s;
}
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){
belle_sip_source_t *s=belle_sip_object_new(belle_sip_source_t);
belle_sip_fd_source_init(s,func,data,fd,events,timeout_value_ms);
return s;
}
belle_sip_source_t * belle_sip_timeout_source_new(belle_sip_source_func_t func, void *data, unsigned int timeout_value_ms){
return belle_sip_socket_source_new(func,data,(belle_sip_socket_t)-1,0,timeout_value_ms);
}
unsigned long belle_sip_source_get_id(const belle_sip_source_t *s){
return s->id;
}
void * belle_sip_source_get_user_data(const belle_sip_source_t *s) {
return s->data;
}
void belle_sip_source_set_user_data(belle_sip_source_t *s, void *user_data) {
s->data = user_data;
}
int belle_sip_source_set_events(belle_sip_source_t* source, int event_mask) {
source->events = event_mask;
return 0;
}
belle_sip_socket_t belle_sip_source_get_socket(const belle_sip_source_t* source) {
return source->sock;
}
struct belle_sip_main_loop{
belle_sip_object_t base;
belle_sip_list_t *fd_sources;
bctbx_map_t *timer_sources;
bctbx_mutex_t sources_mutex; // mutex to avoid concurency between source addition/removing/cancelling and main loop iteration.
belle_sip_object_pool_t *pool;
int nsources;
int run;
int in_loop;
#ifndef _WIN32
int control_fds[2];
unsigned long thread_id;
#endif
};
static void belle_sip_main_loop_remove_source_internal(
belle_sip_main_loop_t *ml,
belle_sip_source_t *source,
bool_t destroy_timer_sources
) {
int unrefs = 0;
bctbx_mutex_lock(&ml->sources_mutex);
if (source->node.next || source->node.prev || &source->node==ml->fd_sources) {
ml->fd_sources=belle_sip_list_remove_link(ml->fd_sources,&source->node);
unrefs++;
}
if (source->it) {
if (destroy_timer_sources)
bctbx_map_erase(ml->timer_sources, source->it);
bctbx_iterator_delete(source->it);
source->it=NULL;
unrefs++;
}
if (unrefs) {
source->cancelled=TRUE;
ml->nsources--;
bctbx_mutex_unlock(&ml->sources_mutex);
if (source->on_remove) source->on_remove(source);
// the mutex must be taken for unrefing because belle_sip_object_unref() isn't thread-safe
bctbx_mutex_lock(&ml->sources_mutex);
for (; unrefs > 0; --unrefs) belle_sip_object_unref(source);
}
bctbx_mutex_unlock(&ml->sources_mutex);
}
void belle_sip_main_loop_remove_source(belle_sip_main_loop_t *ml, belle_sip_source_t *source) {
belle_sip_main_loop_remove_source_internal(ml, source, TRUE);
}
static void belle_sip_main_loop_destroy(belle_sip_main_loop_t *ml){
bctbx_iterator_t *it = bctbx_map_ullong_begin(ml->timer_sources);
bctbx_iterator_t *end = bctbx_map_ullong_end(ml->timer_sources);
while (!bctbx_iterator_ullong_equals(it, end)) {
belle_sip_main_loop_remove_source_internal(
ml,
(belle_sip_source_t *)bctbx_pair_ullong_get_second(bctbx_iterator_ullong_get_pair(it)),
FALSE
);
it = bctbx_iterator_ullong_get_next(it);
}
bctbx_iterator_ullong_delete(it);
bctbx_iterator_ullong_delete(end);
while (ml->fd_sources){
belle_sip_main_loop_remove_source(ml,(belle_sip_source_t*)ml->fd_sources->data);
}
if (belle_sip_object_pool_cleanable(ml->pool)){
belle_sip_object_unref(ml->pool);
}
bctbx_mmap_ullong_delete(ml->timer_sources);
bctbx_mutex_destroy(&ml->sources_mutex);
#ifndef _WIN32
close(ml->control_fds[0]);
close(ml->control_fds[1]);
#endif
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_main_loop_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_sip_main_loop_t,belle_sip_object_t,belle_sip_main_loop_destroy,NULL,NULL,FALSE);
belle_sip_main_loop_t *belle_sip_main_loop_new(void){
belle_sip_main_loop_t*m=belle_sip_object_new(belle_sip_main_loop_t);
m->pool=belle_sip_object_pool_push();
m->timer_sources = bctbx_mmap_ullong_new();
bctbx_mutex_init(&m->sources_mutex,NULL);
#ifndef _WIN32
if (pipe(m->control_fds) == -1){
belle_sip_fatal("Cannot create control pipe of main loop thread: %s", strerror(errno));
}
if (fcntl(m->control_fds[0], F_SETFL, O_NONBLOCK) < 0) {
belle_sip_fatal("Fail to set O_NONBLOCK flag on the reading fd of the control pipe: %s", strerror(errno));
}
m->thread_id = 0;
#endif
return m;
}
void belle_sip_main_loop_wake_up(belle_sip_main_loop_t *ml);
void belle_sip_main_loop_add_source(belle_sip_main_loop_t *ml, belle_sip_source_t *source){
bctbx_mutex_lock(&ml->sources_mutex);
if (source->node.next || source->node.prev){
belle_sip_fatal("Source is already linked somewhere else.");
}
if (source->node.data!=source){
belle_sip_fatal("Insane source passed to belle_sip_main_loop_add_source() !");
}
source->ml=ml;
if (source->timeout>=0){
belle_sip_object_ref(source);
source->expire_ms=belle_sip_time_ms()+source->timeout;
source->it = bctbx_map_insert_and_delete_with_returned_it(
ml->timer_sources,
(bctbx_pair_t*)bctbx_pair_ullong_new(source->expire_ms, source)
);
}
source->cancelled=FALSE;
if (source->fd != (belle_sip_fd_t)-1 ) {
belle_sip_object_ref(source);
ml->fd_sources=belle_sip_list_prepend_link(ml->fd_sources,&source->node);
}
ml->nsources++;
#ifndef _WIN32
if (ml->thread_id != bctbx_thread_self())
belle_sip_main_loop_wake_up(ml);
#endif
bctbx_mutex_unlock(&ml->sources_mutex);
}
belle_sip_source_t* belle_sip_main_loop_create_timeout_with_remove_cb( belle_sip_main_loop_t *ml
, belle_sip_source_func_t func
, void *data
, unsigned int timeout_value_ms
, const char* timer_name
, belle_sip_source_remove_callback_t remove_func) {
belle_sip_source_t * s=belle_sip_timeout_source_new(func,data,timeout_value_ms);
belle_sip_object_set_name((belle_sip_object_t*)s,timer_name);
if (remove_func) {
belle_sip_source_set_remove_cb(s, remove_func);
}
belle_sip_main_loop_add_source(ml,s);
return s;
}
belle_sip_source_t* belle_sip_main_loop_create_timeout(belle_sip_main_loop_t *ml
, belle_sip_source_func_t func
, void *data
, unsigned int timeout_value_ms
,const char* timer_name) {
return belle_sip_main_loop_create_timeout_with_remove_cb(ml, func, data, timeout_value_ms,timer_name,NULL);
}
unsigned long belle_sip_main_loop_add_timeout(belle_sip_main_loop_t *ml, belle_sip_source_func_t func, void *data, unsigned int timeout_value_ms){
belle_sip_source_t * s=belle_sip_main_loop_create_timeout(ml,func,data,timeout_value_ms,"Timer");
belle_sip_object_unref(s);
return s->id;
}
typedef struct {
belle_sip_callback_t func;
void *user_data;
belle_sip_source_t *source;
} DoLaterData;
static int _do_later_cb(void *user_data, unsigned int event) {
DoLaterData *data = (DoLaterData *)user_data;
data->func(data->user_data);
belle_sip_object_unref(data->source);
belle_sip_free(data);
return BELLE_SIP_STOP;
}
void belle_sip_main_loop_do_later_with_name(
belle_sip_main_loop_t *ml,
belle_sip_callback_t func,
void *data,
const char *timer_name
){
DoLaterData *dolater_data = belle_sip_new0(DoLaterData);
dolater_data->func = func;
dolater_data->user_data = data;
/* The belle_sip_source_t is stored in dolater_data in order to decrement the refcounter in the
same thread than the main loop's. Otherwise, the ref counter may be corrupted because of race conditions
if the belle_sip_source_t was after the call to belle_sip_main_loop_add_source() */
dolater_data->source = belle_sip_timeout_source_new(_do_later_cb, dolater_data, 0);
belle_sip_object_set_name((belle_sip_object_t *)dolater_data->source, timer_name ? timer_name : "deferred task");
dolater_data->source->oneshot=TRUE;
/* This function MUST be the last to guarantee thread-safety. */
belle_sip_main_loop_add_source(ml,dolater_data->source);
}
void belle_sip_main_loop_do_later(belle_sip_main_loop_t *ml, belle_sip_callback_t func, void *data){
belle_sip_main_loop_do_later_with_name(ml, func, data, NULL);
}
void belle_sip_source_set_timeout(belle_sip_source_t *s, unsigned int value_ms) {
/*
WARNING: that's important to cast 'value_ms' into 'int' before giving it to belle_sip_source_set_timeout_int64()
in order to mimic the behavior of belle_sip_source_set_timeout() when the timeout was declared as 'int'
in the belle_sip_source_t structure.
That allows to write belle_sip_source_set_timeout(s, -1) to disable the timeout.
*/
belle_sip_source_set_timeout_int64(s, (int)value_ms);
}
void belle_sip_source_set_timeout_int64(belle_sip_source_t *s, int64_t value_ms) {
belle_sip_main_loop_t *ml = s->ml;
int removed_from_map = FALSE;
// take the mutex only when the source has been added to the mail loop
if (ml) bctbx_mutex_lock(&ml->sources_mutex);
if (!s->expired){
s->expire_ms=belle_sip_time_ms()+value_ms;
if (s->it){
/*this timeout is already sorted in the timer_sources map, we need to move it to its new place*/
bctbx_map_erase(ml->timer_sources, s->it);
bctbx_iterator_delete(s->it);
if (value_ms != -1){
s->it = bctbx_map_insert_and_delete_with_returned_it(ml->timer_sources,
(bctbx_pair_t*)bctbx_pair_ullong_new(s->expire_ms, s));
}else {
s->it = NULL;
removed_from_map = TRUE;
}
}
}
s->timeout = value_ms;
if (removed_from_map) belle_sip_object_unref(s);
if (ml) bctbx_mutex_unlock(&ml->sources_mutex);
}
void belle_sip_source_set_remove_cb(belle_sip_source_t *s, belle_sip_source_remove_callback_t func) {
s->on_remove=func;
}
unsigned int belle_sip_source_get_timeout(const belle_sip_source_t *s) {
return (unsigned int)s->timeout;
}
int64_t belle_sip_source_get_timeout_int64(const belle_sip_source_t *s) {
return s->timeout;
}
void belle_sip_source_cancel(belle_sip_source_t *s){
if (s->ml) {
bctbx_mutex_lock(&s->ml->sources_mutex);
s->cancelled = TRUE;
if (s->it) {
bctbx_map_erase(s->ml->timer_sources, s->it);
bctbx_iterator_delete(s->it);
/*put on front*/
s->it = bctbx_map_insert_and_delete_with_returned_it(s->ml->timer_sources, (bctbx_pair_t*)bctbx_pair_ullong_new(0, s));
}
bctbx_mutex_unlock(&s->ml->sources_mutex);
} else {
s->cancelled = TRUE;
}
}
static int match_source_id(const void *s, const void *pid){
if ( ((belle_sip_source_t*)s)->id==(unsigned long)(intptr_t)pid){
return 0;
}
return -1;
}
belle_sip_source_t *belle_sip_main_loop_find_source(belle_sip_main_loop_t *ml, unsigned long id){
bctbx_iterator_t *it;
belle_sip_source_t *ret=NULL;
belle_sip_list_t *elem=belle_sip_list_find_custom(ml->fd_sources,match_source_id,(const void*)(intptr_t)id);
if (elem!=NULL) {
ret = (belle_sip_source_t*)elem->data;
} else if ((it = bctbx_map_find_custom(ml->timer_sources, match_source_id, (const void*)(intptr_t)id))) {
ret = (belle_sip_source_t*)bctbx_pair_get_second(bctbx_iterator_get_pair(it));
bctbx_iterator_delete(it);
} /*else
ret = NULL;*/
return ret;
}
void belle_sip_main_loop_cancel_source(belle_sip_main_loop_t *ml, unsigned long id){
belle_sip_source_t *s=belle_sip_main_loop_find_source(ml,id);
if (s) belle_sip_source_cancel(s);
}
/**
* Clear all data of a pipe.
* @param[in] read_fd Opened file descriptor used to read the pipe. This fd MUST have O_NONBLOCK flag set.
* @return On success, return the number of bytes that have been cleard or zero if the pipe was already empty.
* On failure, return -1 and set errno.
*/
static ssize_t clear_pipe(int read_fd) {
char buffer[1024];
ssize_t nread, cum_nread = 0;
do {
nread = read(read_fd, buffer, sizeof(buffer));
if (nread > 0) cum_nread += nread;
} while (nread > 0);
if (nread < 0 && errno != EAGAIN) return -1;
else return cum_nread;
}
static void belle_sip_main_loop_iterate(belle_sip_main_loop_t *ml){
size_t pfd_size = (ml->nsources + 1) * sizeof(belle_sip_pollfd_t);
belle_sip_pollfd_t *pfd=(belle_sip_pollfd_t*)belle_sip_malloc0(pfd_size);
int i=0;
belle_sip_list_t *elem,*next;
int duration=-1;
int ret;
uint64_t cur;
belle_sip_list_t *to_be_notified=NULL;
int can_clean=belle_sip_object_pool_cleanable(ml->pool); /*iterate might not be called by the thread that created the main loop*/
belle_sip_object_pool_t *tmp_pool=NULL;
bctbx_iterator_t *it,*end;
if (!can_clean){
/*Push a temporary pool for the time of the iterate loop*/
tmp_pool=belle_sip_object_pool_push();
}
/*Step 1: prepare the pollfd table and get the next timeout value */
bctbx_mutex_lock(&ml->sources_mutex); // Lock for the whole step 1
for(elem=ml->fd_sources;elem!=NULL;elem=next) {
next=elem->next;
belle_sip_source_t *s=(belle_sip_source_t*)elem->data;
if (!s->cancelled){
if (s->fd!=(belle_sip_fd_t)-1){
belle_sip_source_to_poll(s,pfd,i);
++i;
}
}
}
#ifndef _WIN32
pfd[i].fd = ml->control_fds[0];
pfd[i].events = POLLIN;
++i;
#endif
/*all source with timeout are in ml->timer_sources*/
if (bctbx_map_size(ml->timer_sources) >0) {
int64_t diff;
uint64_t next_wakeup_time;
it = bctbx_map_begin(ml->timer_sources);
/*use first because in case of canceled timer, key ==0 , key != s->expire_ms */
next_wakeup_time = bctbx_pair_ullong_get_first((const bctbx_pair_ullong_t *)bctbx_iterator_get_pair(it));
/* compute the amount of time to wait for shortest timeout*/
cur=belle_sip_time_ms();
diff=next_wakeup_time-cur;
if (diff>0)
duration=MIN((unsigned int)diff,INT_MAX);
else
duration=0;
bctbx_iterator_delete(it);
it = NULL;
}
bctbx_mutex_unlock(&ml->sources_mutex);
/* do the poll */
ret=belle_sip_poll(pfd,i,duration);
if (ret==-1){
goto end;
}
#ifndef _WIN32
if (pfd[i - 1].revents == POLLIN){
if (clear_pipe(ml->control_fds[0]) == -1)
belle_sip_fatal("Cannot read control pipe of main loop thread: %s", strerror(errno));
}
#endif
/* Step 2: examine poll results and determine the list of source to be notified */
bctbx_mutex_lock(&ml->sources_mutex); // Lock for step 2 and step 3.
cur=belle_sip_time_ms();
for(elem=ml->fd_sources;elem!=NULL;elem=elem->next){
unsigned revents=0;
belle_sip_source_t *s=(belle_sip_source_t*)elem->data;
if (!s->cancelled){
if (s->fd!=(belle_sip_fd_t)-1){
if (s->notify_required) { /*for testing purpose to force channel to read*/
revents=BELLE_SIP_EVENT_READ;
s->notify_required=0; /*reset*/
} else {
revents=belle_sip_source_get_revents(s,pfd);
}
s->revents=revents;
} else {
belle_sip_error("Source [%p] does not contains any fd !",s);
}
if (revents!=0){
to_be_notified=belle_sip_list_append(to_be_notified,belle_sip_object_ref(s));
}
}else to_be_notified=belle_sip_list_append(to_be_notified,belle_sip_object_ref(s));
}
/* Step 3: find timeouted sources */
it = bctbx_map_begin(ml->timer_sources);
end = bctbx_map_end(ml->timer_sources);
while (!bctbx_iterator_equals(it,end)) {
/*use first because in case of canceled timer, key != s->expire_ms*/
uint64_t expire = bctbx_pair_ullong_get_first((const bctbx_pair_ullong_t *)bctbx_iterator_get_pair(it));
belle_sip_source_t *s = (belle_sip_source_t*)bctbx_pair_get_second(bctbx_iterator_get_pair(it));
if (expire > cur) {
/* no need to continue looping because map is ordered*/
break;
} else {
if (s->revents==0) {
s->expired=TRUE;
to_be_notified=belle_sip_list_append(to_be_notified,belle_sip_object_ref(s));
} /*else already in to_be_notified by Step 2*/
s->revents|=BELLE_SIP_EVENT_TIMEOUT;
it=bctbx_iterator_get_next(it);
}
}
bctbx_iterator_delete(it);
bctbx_iterator_delete(end);
bctbx_mutex_unlock(&ml->sources_mutex);
/* Step 4: notify those to be notified */
for(elem=to_be_notified;elem!=NULL;){
belle_sip_source_t *s=(belle_sip_source_t*)elem->data;
next=elem->next;
if (!s->cancelled){
if (belle_sip_log_level_enabled(BELLE_SIP_LOG_DEBUG)) {
/*to avoid too many traces*/
char *objdesc=belle_sip_object_to_string((belle_sip_object_t*)s);
belle_sip_debug("source %s notified revents=%u, timeout=%i",objdesc,s->revents,(int)s->timeout);
belle_sip_free(objdesc);
}
ret=s->notify(s->data,s->revents);
if (ret==BELLE_SIP_STOP || s->oneshot){
/*this source needs to be removed*/
belle_sip_main_loop_remove_source(ml,s);
} else {
bctbx_mutex_lock(&ml->sources_mutex);
if (s->expired && s->it) {
bctbx_map_erase(ml->timer_sources, s->it);
bctbx_iterator_delete(s->it);
s->it=NULL;
belle_sip_object_unref(s);
}
if (!s->it && s->timeout >= 0){
/*timeout needs to be started again */
if (ret==BELLE_SIP_CONTINUE_WITHOUT_CATCHUP){
s->expire_ms=cur+s->timeout;
}else{
s->expire_ms+=s->timeout;
}
s->expired=FALSE;
s->it = bctbx_map_insert_and_delete_with_returned_it(ml->timer_sources,
(bctbx_pair_t*)bctbx_pair_ullong_new(s->expire_ms, s));
belle_sip_object_ref(s);
}
bctbx_mutex_unlock(&ml->sources_mutex);
}
} else {
belle_sip_main_loop_remove_source(ml,s);
}
s->revents=0;
belle_sip_object_unref(s);
belle_sip_free(elem); /*free just the element*/
elem=next;
}
if (can_clean) belle_sip_object_pool_clean(ml->pool);
else if (tmp_pool) {
belle_sip_object_unref(tmp_pool);
tmp_pool=NULL;
}
end:
belle_sip_free(pfd);
}
void belle_sip_main_loop_run(belle_sip_main_loop_t *ml){
#ifndef _WIN32
ml->thread_id = bctbx_thread_self();
#endif
if (ml->in_loop){
belle_sip_warning("belle_sip_main_loop_run(): reentrancy detected, doing nothing");
return;
}
ml->run = TRUE;
ml->in_loop = TRUE;
while(ml->run){
belle_sip_main_loop_iterate(ml);
}
ml->in_loop = FALSE;
}
int belle_sip_main_loop_quit(belle_sip_main_loop_t *ml){
ml->run=0;
return BELLE_SIP_STOP;
}
void belle_sip_main_loop_sleep(belle_sip_main_loop_t *ml, int milliseconds){
belle_sip_source_t * s=belle_sip_main_loop_create_timeout(ml,(belle_sip_source_func_t)belle_sip_main_loop_quit,ml,milliseconds,"Main loop sleep timer");
belle_sip_main_loop_run(ml);
belle_sip_main_loop_remove_source(ml,s);
belle_sip_object_unref(s);
}
#ifndef _WIN32
void belle_sip_main_loop_wake_up(belle_sip_main_loop_t *ml) {
if (write(ml->control_fds[1], "wake up!", 1) == -1) {
belle_sip_fatal("Cannot write to control pipe of main loop thread: %s", strerror(errno));
}
}
#endif
belle-sip-5.2.0+dfsg/src/belle_sip_mdns_register.c 0000664 0000000 0000000 00000013000 14346131365 0022127 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "belle_sip_internal.h"
#include
#ifdef HAVE_MDNS
#include
#ifndef _WIN32
#include
#include
typedef struct pollfd belle_sip_pollfd_t;
static int belle_sip_poll(belle_sip_pollfd_t *pfd, int count, int duration) {
int err = poll(pfd, count, duration);
if (err == -1 && errno != EINTR)
belle_sip_error("poll() error: %s",strerror(errno));
return err;
}
#else
#include
typedef WSAPOLLFD belle_sip_pollfd_t;
static int belle_sip_poll(belle_sip_pollfd_t *pfd, int count, int duration) {
int err = WSAPoll(pfd, count, duration);
if (err == SOCKET_ERROR)
belle_sip_error("WSAPoll() error: %d", WSAGetLastError());
return err;
}
#endif
struct belle_sip_mdns_register {
belle_sip_object_t base;
DNSServiceRef service_ref;
belle_sip_mdns_register_callback_t cb;
void *data;
bctbx_thread_t thread;
volatile bool_t running;
};
belle_sip_mdns_register_t *belle_sip_mdns_register_create(belle_sip_mdns_register_callback_t cb, void *data) {
belle_sip_mdns_register_t *obj = belle_sip_object_new(belle_sip_mdns_register_t);
obj->cb = cb;
obj->data = data;
obj->running = FALSE;
return obj;
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_mdns_register_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_sip_mdns_register_t, belle_sip_object_t, NULL, NULL, NULL, FALSE);
static char * srv_prefix_from_service_and_transport(const char *service, const char *transport) {
if (service == NULL) service = "sip";
if (strcasecmp(transport, "udp") == 0) {
return belle_sip_strdup_printf("_%s._udp.", service);
} else if (strcasecmp(transport, "tcp") == 0) {
return belle_sip_strdup_printf("_%s._tcp.", service);
} else if (strcasecmp(transport, "tls") == 0) {
return belle_sip_strdup_printf("_%ss._tcp.", service);
}
return belle_sip_strdup_printf("_%s._udp.", service);
}
static void belle_sip_mdns_register_reply(DNSServiceRef service_ref
, DNSServiceFlags flags
, DNSServiceErrorType error_code
, const char *name
, const char *type
, const char *domain
, void *data) {
belle_sip_mdns_register_t *reg = (belle_sip_mdns_register_t *)data;
int error = 0;
if (error_code != kDNSServiceErr_NoError) {
belle_sip_error("%s error while registering %s [%s%s]: code %d", __FUNCTION__, name, type, domain, error_code);
error = -1;
}
if (reg->cb) reg->cb(reg->data, error);
}
void *mdns_register_poll(void *data) {
belle_sip_mdns_register_t *reg = (belle_sip_mdns_register_t *)data;
belle_sip_pollfd_t pollfd = {0};
pollfd.fd = DNSServiceRefSockFD(reg->service_ref);
pollfd.events = POLLIN;
reg->running = TRUE;
while(reg->running) {
int err = belle_sip_poll(&pollfd, 1, 1000);
if (err > 0) {
DNSServiceProcessResult(reg->service_ref);
}
}
return NULL;
}
#endif
int belle_sip_mdns_register_available(void) {
#ifdef HAVE_MDNS
return TRUE;
#else
return FALSE;
#endif
}
belle_sip_mdns_register_t *belle_sip_mdns_register(const char *service, const char *transport, const char *domain, const char *name, int port, int prio, int weight, int ttl, belle_sip_mdns_register_callback_t cb, void *data) {
#ifdef HAVE_MDNS
belle_sip_mdns_register_t *reg = belle_sip_mdns_register_create(cb, data);
DNSServiceErrorType error;
TXTRecordRef txt_ref;
char number[10];
char *prefix;
int n;
TXTRecordCreate(&txt_ref, 0, NULL);
n = snprintf(number, sizeof(number), "%d", prio);
TXTRecordSetValue(&txt_ref, "prio\0", n, number);
n = snprintf(number, sizeof(number), "%d", weight);
TXTRecordSetValue(&txt_ref, "weight\0", n, number);
n = snprintf(number, sizeof(number), "%d", ttl);
TXTRecordSetValue(&txt_ref, "ttl\0", n, number);
prefix = srv_prefix_from_service_and_transport(service, transport);
error = DNSServiceRegister(®->service_ref
, 0
, 0
, name
, prefix
, domain
, NULL
, port
, TXTRecordGetLength(&txt_ref)
, TXTRecordGetBytesPtr(&txt_ref)
, belle_sip_mdns_register_reply
, reg);
belle_sip_free(prefix);
TXTRecordDeallocate(&txt_ref);
if (error != kDNSServiceErr_NoError) {
belle_sip_error("%s Register error [_%s._%s.%s]: code %d", __FUNCTION__, service, transport, domain, error);
belle_sip_object_unref(reg);
return NULL;
} else {
int errnum = bctbx_thread_create(®->thread, NULL, mdns_register_poll, reg);
if (errnum != 0) {
belle_sip_error("%s Error creating register thread: code %d", __FUNCTION__, errnum);
belle_sip_object_unref(reg);
return NULL;
}
}
return reg;
#else
return NULL;
#endif
}
void belle_sip_mdns_unregister(belle_sip_mdns_register_t *reg) {
#ifdef HAVE_MDNS
if (!reg) return;
if (reg->running) {
reg->running = FALSE;
bctbx_thread_join(reg->thread, NULL);
}
DNSServiceRefDeallocate(reg->service_ref);
belle_sip_object_unref(reg);
#endif
}
belle-sip-5.2.0+dfsg/src/belle_sip_object.c 0000664 0000000 0000000 00000065521 14346131365 0020547 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "belle_sip_internal.h"
static void _belle_sip_object_pool_remove_from_stack(belle_sip_object_pool_t *pool);
static int _belle_sip_object_marshal_check_enabled = FALSE;
static int has_type(belle_sip_object_t *obj, belle_sip_type_id_t id){
belle_sip_object_vptr_t *vptr=obj->vptr;
while(vptr!=NULL){
if (vptr->id==id) return TRUE;
vptr=vptr->get_parent();
}
return FALSE;
}
int _belle_sip_object_is_instance_of(belle_sip_object_t * obj,belle_sip_type_id_t id) {
return has_type(obj,id);
}
void belle_sip_object_enable_marshal_check(int enable) {
_belle_sip_object_marshal_check_enabled = (enable) ? TRUE : FALSE;
}
static const char * belle_sip_object_vptr_get_type_name(const belle_sip_object_t *obj){
if (!obj->vptr->is_cpp)
return obj->vptr->type_name;
return belle_sip_cpp_object_get_type_name(obj);
}
static belle_sip_list_t *all_objects=NULL;
static int belle_sip_leak_detector_enabled=FALSE;
static int belle_sip_leak_detector_inhibited=FALSE;
static void add_new_object(belle_sip_object_t *obj){
if (belle_sip_leak_detector_enabled && !belle_sip_leak_detector_inhibited){
all_objects=belle_sip_list_prepend(all_objects,obj);
}
}
void belle_sip_object_remove_from_leak_detector(belle_sip_object_t *obj){
if (belle_sip_leak_detector_enabled && !belle_sip_leak_detector_inhibited){
belle_sip_list_t* it;
it=belle_sip_list_find(all_objects,obj);
if (it)
all_objects = belle_sip_list_delete_link(all_objects,it); /*it may fail if the leak detector was inhibitted at the time the object was created*/
}
}
void belle_sip_object_inhibit_leak_detector(int yes){
belle_sip_leak_detector_inhibited=yes ? TRUE : FALSE;
}
void belle_sip_object_enable_leak_detector(int enable){
belle_sip_leak_detector_enabled=enable;
}
int belle_sip_object_get_object_count(void){
return (int)belle_sip_list_size(all_objects);
}
void belle_sip_object_flush_active_objects(void){
//do not free objects so that they are still detected as leaked by valgrind and such
all_objects = belle_sip_list_free(all_objects);
}
void belle_sip_object_dump_active_objects(void){
belle_sip_list_t *elem;
if (all_objects){
belle_sip_warning("List of leaked objects:");
for(elem=all_objects;elem!=NULL;elem=elem->next){
belle_sip_object_t *obj=(belle_sip_object_t*)elem->data;
char* content= belle_sip_object_to_string(obj);
belle_sip_warning("%s(%p) ref=%i, content [%10s...]",belle_sip_object_vptr_get_type_name(obj),obj,obj->ref,content);
belle_sip_free(content);
}
}else belle_sip_warning("No objects leaked.");
}
belle_sip_object_t * _belle_sip_object_init(belle_sip_object_t *obj, belle_sip_object_vptr_t *vptr){
obj->vptr = vptr;
obj->ref = vptr->initially_unowned ? 0 : 1;
if (obj->ref == 0) {
belle_sip_object_pool_t *pool=belle_sip_object_pool_get_current();
if (pool) belle_sip_object_pool_add(pool,obj);
}
add_new_object(obj);
return obj;
}
belle_sip_object_t * _belle_sip_object_new(size_t objsize, belle_sip_object_vptr_t *vptr){
belle_sip_object_t *obj=(belle_sip_object_t *)belle_sip_malloc0(vptr->size);
return _belle_sip_object_init(obj, vptr);
}
int belle_sip_object_is_initially_unowned(const belle_sip_object_t *obj){
return obj->vptr->initially_unowned;
}
belle_sip_object_t * belle_sip_object_ref(void *obj){
belle_sip_object_t *o=BELLE_SIP_OBJECT(obj);
if (o->ref == 0 && o->pool) {
belle_sip_object_pool_remove(o->pool,obj);
}
if (o->vptr->on_first_ref && (o->ref == 0 || (!o->vptr->initially_unowned && o->ref == 1)))
o->vptr->on_first_ref(o);
o->ref++;
return obj;
}
void belle_sip_object_unref(void *ptr) {
belle_sip_object_unref_2(ptr);
}
int belle_sip_object_unref_2(void *ptr) {
belle_sip_object_t *obj=BELLE_SIP_OBJECT(ptr);
if (obj->ref <= -1) {
belle_sip_error("Object [%p] freed twice or corrupted !",obj);
if (obj->vptr && obj->vptr->type_name) belle_sip_error("Object type might be [%s]",obj->vptr->type_name);
if (obj->name) belle_sip_error("Object name might be [%s]",obj->name);
belle_sip_fatal("Fatal object error encountered, aborting.");
return 1;
}
if (obj->vptr->initially_unowned && obj->ref==0){
if (obj->pool)
belle_sip_object_pool_remove(obj->pool,obj);
obj->ref=-1;
belle_sip_object_delete(obj);
return 1;
}
if (obj->vptr->on_last_ref){
if ((obj->vptr->initially_unowned && obj->ref==1)
|| (!obj->vptr->initially_unowned && obj->ref == 2)){
obj->vptr->on_last_ref(obj);
}
}
obj->ref--; /* keep the ref until here to make sure obj is not deleted by obj->vptr->on_last_ref*/
if (obj->ref == 0){
obj->ref = -1;
belle_sip_object_delete(obj);
return 1;
}
return 0;
}
static weak_ref_t *weak_ref_new(belle_sip_object_destroy_notify_t destroy_notify, void *userpointer){
weak_ref_t *r=belle_sip_new(weak_ref_t);
r->next=NULL;
r->notify=destroy_notify;
r->userpointer=userpointer;
return r;
}
belle_sip_object_t *belle_sip_object_weak_ref(void *obj, belle_sip_object_destroy_notify_t destroy_notify, void *userpointer){
belle_sip_object_t *o=BELLE_SIP_OBJECT(obj);
weak_ref_t *old=o->weak_refs;
o->weak_refs=weak_ref_new(destroy_notify,userpointer);
o->weak_refs->next=old;
return o;
}
void belle_sip_object_weak_unref(void *obj, belle_sip_object_destroy_notify_t destroy_notify, void *userpointer){
belle_sip_object_t *o=BELLE_SIP_OBJECT(obj);
weak_ref_t *ref,*prevref=NULL,*next=NULL;
int found=FALSE;
if (o->ref==-1) return; /*too late and avoid recursions*/
for(ref=o->weak_refs;ref!=NULL;ref=next){
next=ref->next;
if (ref->notify==destroy_notify && ref->userpointer==userpointer){
if (prevref==NULL) o->weak_refs=next;
else prevref->next=next;
belle_sip_free(ref);
found=TRUE;
/*do not break or return, someone could have put twice the same weak ref on the same object*/
}else{
prevref=ref;
}
}
if (!found) belle_sip_fatal("Could not find weak_ref, you're a looser.");
}
static void belle_sip_object_loose_weak_refs(belle_sip_object_t *obj){
weak_ref_t *ref,*next;
for(ref=obj->weak_refs;ref!=NULL;ref=next){
next=ref->next;
ref->notify(ref->userpointer,obj);
belle_sip_free(ref);
}
obj->weak_refs=NULL;
}
static void _belle_sip_object_uninit(belle_sip_object_t *obj){
if (obj->name)
belle_sip_free(obj->name);
}
static void _belle_sip_object_clone(belle_sip_object_t *obj, const belle_sip_object_t *orig){
if (orig->name!=NULL) obj->name=belle_sip_strdup(orig->name);
}
static belle_sip_error_code _belle_object_marshal(belle_sip_object_t* obj, char* buff, size_t buff_size, size_t *offset) {
return belle_sip_snprintf(buff,buff_size,offset,"{%s::%s %p}",belle_sip_object_vptr_get_type_name(obj),obj->name ? obj->name : "(no name)",obj);
}
static belle_sip_object_vptr_t *no_parent(void){
return NULL;
}
belle_sip_object_vptr_t belle_sip_object_t_vptr={
BELLE_SIP_TYPE_ID(belle_sip_object_t),
sizeof(belle_sip_object_t),
"belle_sip_object_t",
FALSE,
no_parent, /*no parent, it's god*/
NULL,
_belle_sip_object_uninit,
_belle_sip_object_clone,
_belle_object_marshal,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
};
belle_sip_object_vptr_t *belle_sip_object_t_vptr_get(void){
return &belle_sip_object_t_vptr;
}
void belle_sip_object_uninit(belle_sip_object_t *obj){
belle_sip_object_vptr_t *vptr;
belle_sip_object_loose_weak_refs(obj);
belle_sip_object_remove_from_leak_detector(obj);
vptr = obj->vptr;
while(vptr!=NULL){
if (vptr->destroy) vptr->destroy(obj);
vptr=vptr->get_parent();
}
belle_sip_object_data_clear(obj);
}
void belle_sip_object_delete(void *ptr){
belle_sip_object_t *obj=BELLE_SIP_OBJECT(ptr);
if (obj->vptr->is_cpp){
/*This will call delete which calls the destructor chain*/
belle_sip_cpp_object_delete(obj);
return;
}
/*otherwise we're in C, call the destructor chain and free the memory*/
belle_sip_object_uninit(obj);
belle_sip_free(obj);
}
static belle_sip_object_vptr_t *find_common_floor(belle_sip_object_vptr_t *vptr1, belle_sip_object_vptr_t *vptr2){
belle_sip_object_vptr_t *it1,*it2;
for (it1=vptr1;it1!=NULL;it1=it1->get_parent()){
if (it1==vptr2)
return vptr2;
}
for(it2=vptr2;it2!=NULL;it2=it2->get_parent()){
if (vptr1==it2)
return vptr1;
}
return find_common_floor(vptr1->get_parent(),vptr2);
}
/*copy the content of ref object to new object, for the part they have in common in their inheritence diagram*/
void _belle_sip_object_copy(belle_sip_object_t *newobj, const belle_sip_object_t *ref){
belle_sip_object_vptr_t *vptr;
vptr=find_common_floor(newobj->vptr,ref->vptr);
if (vptr==NULL){
belle_sip_fatal("Should not happen");
}
while(vptr!=NULL){
if (vptr->clone==NULL){
belle_sip_fatal("Object of type %s cannot be cloned, it does not provide a clone() implementation.",vptr->type_name);
return;
}else vptr->clone(newobj,ref);
vptr=vptr->get_parent();
}
}
belle_sip_object_t *belle_sip_object_clone(const belle_sip_object_t *obj){
belle_sip_object_t *newobj;
newobj=belle_sip_malloc0(obj->vptr->size);
newobj->ref=obj->vptr->initially_unowned ? 0 : 1;
newobj->vptr=obj->vptr;
_belle_sip_object_copy(newobj,obj);
if (newobj->ref==0){
belle_sip_object_pool_t *pool=belle_sip_object_pool_get_current();
if (pool) belle_sip_object_pool_add(pool,newobj);
}
add_new_object(newobj);
return newobj;
}
belle_sip_object_t *belle_sip_object_clone_and_ref(const belle_sip_object_t *obj) {
return belle_sip_object_ref(belle_sip_object_clone(obj));
}
struct belle_sip_object_data{
char* name;
void* data;
belle_sip_data_destroy destroy_func;
};
static int belle_sip_object_data_find(const void* a, const void* b)
{
struct belle_sip_object_data* da = (struct belle_sip_object_data*)a;
return strcmp(da->name, (const char*)b);
}
static void belle_sip_object_data_destroy(void* data)
{
struct belle_sip_object_data* da = (struct belle_sip_object_data*)data;
if (da->destroy_func) da->destroy_func(da->data);
belle_sip_free(da->name);
belle_sip_free(da);
}
int belle_sip_object_data_set( belle_sip_object_t *obj, const char* name, void* data, belle_sip_data_destroy destroy_func )
{
int ret = 0;
belle_sip_list_t* list_entry = belle_sip_list_find_custom(obj->data_store, belle_sip_object_data_find, name);
struct belle_sip_object_data* entry = (list_entry)? list_entry->data : NULL;
if( entry == NULL){
entry = belle_sip_malloc0(sizeof( struct belle_sip_object_data));
obj->data_store = belle_sip_list_append(obj->data_store, entry);
}
else {
// clean previous data
if( entry->destroy_func ) entry->destroy_func(entry->data);
belle_sip_free(entry->name);
ret = 1;
}
if( entry ){
entry->data = data;
entry->name = belle_sip_strdup(name);
entry->destroy_func = destroy_func;
} else {
ret = -1;
}
return ret;
}
void* belle_sip_object_data_get( belle_sip_object_t *obj, const char* name )
{
belle_sip_list_t *list_entry = belle_sip_list_find_custom(obj->data_store, belle_sip_object_data_find, name);
struct belle_sip_object_data* entry = (list_entry)? list_entry->data : NULL;
return entry? entry->data : NULL;
}
int belle_sip_object_data_remove( belle_sip_object_t *obj, const char* name)
{
belle_sip_list_t *list_entry = belle_sip_list_find_custom(obj->data_store, belle_sip_object_data_find, name);
struct belle_sip_object_data* entry = (list_entry)? list_entry->data : NULL;
if( entry ){
belle_sip_free(entry->name);
if( entry->destroy_func ) entry->destroy_func(entry->data);
belle_sip_free(entry);
}
if( list_entry ) obj->data_store = belle_sip_list_remove_link(obj->data_store, list_entry);
return !(list_entry!= NULL);
}
int belle_sip_object_data_exists( const belle_sip_object_t *obj, const char* name )
{
return (belle_sip_list_find_custom(obj->data_store, belle_sip_object_data_find, name) != NULL);
}
void* belle_sip_object_data_grab( belle_sip_object_t* obj, const char* name)
{
belle_sip_list_t *list_entry = belle_sip_list_find_custom(obj->data_store, belle_sip_object_data_find, name);
struct belle_sip_object_data* entry = (list_entry)? list_entry->data : NULL;
void* data =NULL;
if( entry ){
belle_sip_free(entry->name);
data = entry->data;
}
obj->data_store = belle_sip_list_remove_link(obj->data_store, list_entry);
belle_sip_free(entry);
return data;
}
void belle_sip_object_data_clear( belle_sip_object_t* obj )
{
belle_sip_list_for_each(obj->data_store, belle_sip_object_data_destroy);
obj->data_store = belle_sip_list_free(obj->data_store);
}
void belle_sip_object_data_clone( const belle_sip_object_t* src, belle_sip_object_t* dst, belle_sip_data_clone clone_func)
{
belle_sip_object_data_clear(dst);
belle_sip_object_data_merge(src, dst, clone_func);
}
void belle_sip_object_data_merge( const belle_sip_object_t* src, belle_sip_object_t* dst, belle_sip_data_clone clone_func)
{
belle_sip_list_t *list = src->data_store;
struct belle_sip_object_data* it = NULL;
void* cloned_data = NULL;
while( list ){
it = list->data;
if( it ){
cloned_data = (clone_func)? clone_func( it->name, it->data ) : it->data;
belle_sip_object_data_set(dst, it->name, cloned_data, it->destroy_func);
}
list = list->next;
}
}
struct belle_sip_object_foreach_data {
void (*apply_func)(const char*, void*, void*);
void* userdata;
};
static void belle_sip_object_for_each_cb(void* data, void* pvdata)
{
struct belle_sip_object_data* it = (struct belle_sip_object_data*)data;
struct belle_sip_object_foreach_data* fd = (struct belle_sip_object_foreach_data*)pvdata;
if( it && fd->apply_func ){
fd->apply_func(it->name, it->data, fd->userdata);
}
}
void belle_sip_object_data_foreach( const belle_sip_object_t* obj, void (*apply_func)(const char* key, void* data, void* userdata), void* userdata)
{
struct belle_sip_object_foreach_data fd = { apply_func, userdata };
belle_sip_list_for_each2(obj->data_store, belle_sip_object_for_each_cb, &fd);
}
void *belle_sip_object_cast(belle_sip_object_t *obj, belle_sip_type_id_t id, const char *castname, const char *file, int fileno){
if (obj!=NULL){
if (has_type(obj,id)==0){
belle_sip_fatal("Bad cast to %s at %s:%i",castname,file,fileno);
return NULL;
}
}
return obj;
}
void *belle_sip_object_get_interface_methods(belle_sip_object_t *obj, belle_sip_interface_id_t ifid){
if (obj!=NULL){
belle_sip_object_vptr_t *vptr;
for (vptr=obj->vptr;vptr!=NULL;vptr=vptr->get_parent()){
belle_sip_interface_desc_t **ifaces=vptr->interfaces;
if (ifaces!=NULL){
for(;*ifaces!=0;++ifaces){
if ((*ifaces)->id==ifid){
return *ifaces;
}
}
}
}
}
return NULL;
}
int belle_sip_object_implements(belle_sip_object_t *obj, belle_sip_interface_id_t id){
return belle_sip_object_get_interface_methods(obj,id)!=NULL;
}
void *belle_sip_object_interface_cast(belle_sip_object_t *obj, belle_sip_interface_id_t ifid, const char *castname, const char *file, int fileno){
if (obj!=NULL){
if (belle_sip_object_get_interface_methods(obj,ifid)==0){
belle_sip_fatal("Bad cast to interface %s at %s:%i",castname,file,fileno);
return NULL;
}
}
return obj;
}
void belle_sip_object_set_name(belle_sip_object_t* object,const char* name) {
if (object->name) {
belle_sip_free(object->name);
object->name=NULL;
}
if (name)
object->name=belle_sip_strdup(name);
}
const char* belle_sip_object_get_name(belle_sip_object_t* object) {
return object->name;
}
static belle_sip_error_code checked_marshal(belle_sip_object_vptr_t *vptr, belle_sip_object_t* obj, char* buff, size_t buff_size, size_t *offset){
size_t tmp_buf_size=buff_size*2;
char *p=(char*)belle_sip_malloc0(tmp_buf_size);
size_t i;
size_t initial_offset=*offset;
belle_sip_error_code error=vptr->marshal(obj,p,buff_size,offset);
size_t written;
for (i=initial_offset;itype_name,(int)written,(int)(*offset-initial_offset));
}
memcpy(buff+initial_offset,p+initial_offset,*offset-initial_offset);
}else if (error==BELLE_SIP_BUFFER_OVERFLOW){
/* Case where the object aborted the marshalling because of not enough room.
* Should this happen, it is not allowed to write past buffer end anyway */
if (written > buff_size){
belle_sip_fatal("Object of type %s commited a buffer overflow by marshalling %i bytes",
vptr->type_name,(int)(*offset-initial_offset));
}
}else{
belle_sip_error("Object of type %s produced an error during marshalling: %i",
vptr->type_name,error);
}
belle_sip_free(p);
return error;
}
belle_sip_error_code belle_sip_object_marshal(belle_sip_object_t* obj, char* buff, size_t buff_size, size_t *offset) {
belle_sip_object_vptr_t *vptr=obj->vptr;
while (vptr != NULL) {
if (vptr->marshal != NULL) {
if (_belle_sip_object_marshal_check_enabled == TRUE)
return checked_marshal(vptr,obj,buff,buff_size,offset);
else
return vptr->marshal(obj,buff,buff_size,offset);
} else {
vptr=vptr->get_parent();
}
}
return BELLE_SIP_NOT_IMPLEMENTED; /*no implementation found*/
}
static char * belle_sip_object_to_alloc_string(const belle_sip_object_t *obj, int size_hint){
char *buf=belle_sip_malloc(size_hint);
size_t offset=0;
belle_sip_error_code error = belle_sip_object_marshal((belle_sip_object_t *)obj,buf,size_hint-1,&offset);
obj->vptr->tostring_bufsize_hint=size_hint;
if (error==BELLE_SIP_BUFFER_OVERFLOW){
belle_sip_message("belle_sip_object_to_alloc_string(): hint buffer was too short while doing to_string() for %s, retrying", belle_sip_object_vptr_get_type_name(obj));
belle_sip_free(buf);
return belle_sip_object_to_alloc_string(obj,2*size_hint);
}
buf=belle_sip_realloc(buf,offset+1);
buf[offset]='\0';
return buf;
}
static int get_hint_size(int size){
if (size<128)
return 128;
return size;
}
char* belle_sip_object_to_string(const void* _obj) {
const belle_sip_object_t *obj=BELLE_SIP_OBJECT(_obj);
if (obj->vptr->tostring_bufsize_hint!=0){
return belle_sip_object_to_alloc_string(obj,obj->vptr->tostring_bufsize_hint);
}else{
char buff[BELLE_SIP_MAX_TO_STRING_SIZE];
size_t offset=0;
belle_sip_error_code error = belle_sip_object_marshal((belle_sip_object_t *)obj,buff,sizeof(buff)-1,&offset);
if (error==BELLE_SIP_BUFFER_OVERFLOW){
belle_sip_message("belle_sip_object_to_string(): temporary buffer is too short while doing to_string() for %s, retrying", obj->vptr->type_name);
return belle_sip_object_to_alloc_string(obj,get_hint_size(2*(int)offset));
}
buff[offset]='\0';
obj->vptr->tostring_bufsize_hint=get_hint_size(2*(int)offset);
return belle_sip_strdup(buff);
}
}
char * _belle_sip_object_describe_type(belle_sip_object_t *obj, belle_sip_object_vptr_t *vptr){
const int maxbufsize=2048;
char *ret=belle_sip_malloc(maxbufsize);
belle_sip_object_vptr_t *it;
size_t pos=0;
belle_sip_list_t *l=NULL,*elem;
belle_sip_snprintf(ret,maxbufsize,&pos,"Ownership:\n");
belle_sip_snprintf(ret,maxbufsize,&pos,"\t%s is created initially %s\n", obj ? belle_sip_object_vptr_get_type_name(obj) : vptr->type_name,
vptr->initially_unowned ? "unowned" : "owned");
belle_sip_snprintf(ret,maxbufsize,&pos,"\nInheritance diagram:\n");
for(it=vptr;it!=NULL;it=it->get_parent()){
l=belle_sip_list_prepend(l,it);
}
for(elem=l;elem!=NULL;elem=elem->next){
it=(belle_sip_object_vptr_t*)elem->data;
belle_sip_snprintf(ret,maxbufsize,&pos,"\t%s\n",it->type_name);
if (elem->next)
belle_sip_snprintf(ret,maxbufsize,&pos,"\t |\n");
}
belle_sip_list_free(l);
belle_sip_snprintf(ret,maxbufsize,&pos,"\nImplemented interfaces:\n");
for(it=vptr;it!=NULL;it=it->get_parent()){
belle_sip_interface_desc_t **desc=it->interfaces;
if (desc!=NULL){
for(;*desc!=NULL;desc++){
belle_sip_snprintf(ret,maxbufsize,&pos,"\t* %s\n",(*desc)->ifname);
}
}
}
return ret;
}
char *belle_sip_object_describe(void *obj){
belle_sip_object_t *o=BELLE_SIP_OBJECT(obj);
return _belle_sip_object_describe_type(o, o->vptr);
}
#if !defined(_WIN32)
#include
char *belle_sip_object_describe_type_from_name(const char *name){
char *vptr_name;
void *handle;
void *symbol;
belle_sip_object_get_vptr_t vptr_getter;
handle=dlopen(NULL,RTLD_LAZY);
if (handle==NULL){
belle_sip_error("belle_sip_object_describe_type_from_name: dlopen() failed: %s",dlerror());
return NULL;
}
vptr_name=belle_sip_strdup_printf("%s_vptr_get",name);
symbol=dlsym(handle,vptr_name);
belle_sip_free(vptr_name);
dlclose(handle);
if (symbol==NULL){
belle_sip_error("belle_sip_object_describe_type_from_name: could not find vptr for type %s",name);
return NULL;
}
vptr_getter=(belle_sip_object_get_vptr_t)symbol;
return _belle_sip_object_describe_type(NULL, vptr_getter());
}
#else
char *belle_sip_object_describe_type_from_name(const char *name){
return belle_sip_strdup_printf("Sorry belle_sip_object_describe_type_from_name() is not implemented on this platform.");
}
#endif
struct belle_sip_object_pool{
belle_sip_object_t base;
belle_sip_list_t *objects;
unsigned long thread_id;
};
static void belle_sip_object_pool_destroy(belle_sip_object_pool_t *pool){
belle_sip_object_pool_clean(pool);
_belle_sip_object_pool_remove_from_stack(pool);
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_object_pool_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_sip_object_pool_t,belle_sip_object_t,belle_sip_object_pool_destroy,NULL,NULL,FALSE);
belle_sip_object_pool_t *belle_sip_object_pool_new(void){
belle_sip_object_pool_t *pool=belle_sip_object_new(belle_sip_object_pool_t);
pool->thread_id=belle_sip_thread_self_id();
return pool;
}
void belle_sip_object_pool_add(belle_sip_object_pool_t *pool, belle_sip_object_t *obj){
if (obj->pool!=NULL){
belle_sip_fatal("It is not possible to add an object to multiple pools.");
}
pool->objects=belle_sip_list_prepend(pool->objects,obj);
obj->pool_iterator=pool->objects;
obj->pool=pool;
}
void belle_sip_object_pool_remove(belle_sip_object_pool_t *pool, belle_sip_object_t *obj){
unsigned long tid=belle_sip_thread_self_id();
if (obj->pool!=pool){
belle_sip_fatal("Attempting to remove object from an incorrect pool: obj->pool=%p, pool=%p",obj->pool,pool);
return;
}
if (tid!=pool->thread_id){
belle_sip_fatal("It is forbidden (and unsafe()) to ref()/unref() an unowned object outside of the thread that created it.");
return;
}
pool->objects=belle_sip_list_delete_link(pool->objects,obj->pool_iterator);
obj->pool_iterator=NULL;
obj->pool=NULL;
}
int belle_sip_object_pool_cleanable(belle_sip_object_pool_t *pool){
return pool->thread_id!=0 && belle_sip_thread_self_id()==pool->thread_id;
}
void belle_sip_object_pool_clean(belle_sip_object_pool_t *pool){
belle_sip_list_t *elem,*next;
if (!belle_sip_object_pool_cleanable(pool)){
belle_sip_warning("Thread pool [%p] cannot be cleaned from thread [%lu] because it was created for thread [%lu]",
pool,belle_sip_thread_self_id(),(unsigned long)pool->thread_id);
return;
}
for(elem=pool->objects;elem!=NULL;elem=next){
belle_sip_object_t *obj=(belle_sip_object_t*)elem->data;
if (obj->ref==0){
belle_sip_message("Garbage collecting unowned object of type %s",obj->vptr->type_name);
obj->ref=-1;
belle_sip_object_delete(obj);
next=elem->next;
belle_sip_free(elem);
}else {
belle_sip_fatal("Object %p is in unowned list but with ref count %i, bug.",obj,obj->ref);
next=elem->next;
}
}
pool->objects=NULL;
}
static void belle_sip_object_pool_detach_from_thread(belle_sip_object_pool_t *pool){
belle_sip_object_pool_clean(pool);
pool->thread_id=(unsigned long)0;
}
static void cleanup_pool_stack(void *data){
belle_sip_list_t **pool_stack=(belle_sip_list_t**)data;
if (*pool_stack){
/*
* We would expect the pool_stack to be empty when the thread terminates.
* Otherwise that means the management of object pool is not properly done by the application.
* Since the object pools might be still referenced by the application, we can't destroy them.
* Instead, we mark them as detached, so that when the thread that will attempt to destroy them will do it,
* we'll accept (since anyway these object pool are no longer needed.
*/
belle_sip_warning("There were still [%u] object pools for thread [%lu] while the thread exited. ",
(unsigned int)belle_sip_list_size(*pool_stack),belle_sip_thread_self_id());
belle_sip_list_free_with_data(*pool_stack,(void (*)(void*)) belle_sip_object_pool_detach_from_thread);
}
*pool_stack=NULL;
belle_sip_free(pool_stack);
}
static belle_sip_list_t** get_current_pool_stack(int *first_time){
static belle_sip_thread_key_t pools_key;
static int pools_key_created=0;
belle_sip_list_t **pool_stack;
if (first_time) *first_time=0;
if (!pools_key_created){
pools_key_created=1;
if (belle_sip_thread_key_create(&pools_key, cleanup_pool_stack)!=0){
return NULL;
}
}
pool_stack=(belle_sip_list_t**)belle_sip_thread_getspecific(pools_key);
if (pool_stack==NULL){
pool_stack=belle_sip_new(belle_sip_list_t*);
*pool_stack=NULL;
belle_sip_thread_setspecific(pools_key,pool_stack);
if (first_time) *first_time=1;
}
return pool_stack;
}
static void _belle_sip_object_pool_remove_from_stack(belle_sip_object_pool_t *pool){
belle_sip_list_t **pools=get_current_pool_stack(NULL);
unsigned long tid=belle_sip_thread_self_id();
if (tid!=pool->thread_id){
belle_sip_fatal("It is forbidden to destroy a pool outside the thread that created it.");
return;
}
if (pools==NULL) {
belle_sip_fatal("Not possible to pop a pool.");
return;
}
if (*pools==NULL){
belle_sip_fatal("There is no current pool in stack.");
return;
}
*pools=belle_sip_list_remove(*pools,pool);
}
belle_sip_object_pool_t * belle_sip_object_pool_push(void){
belle_sip_list_t **pools=get_current_pool_stack(NULL);
belle_sip_object_pool_t *pool;
if (pools==NULL) {
belle_sip_error("Not possible to create a pool.");
return NULL;
}
pool=belle_sip_object_pool_new();
*pools=belle_sip_list_prepend(*pools,pool);
return pool;
}
belle_sip_object_pool_t *belle_sip_object_pool_get_current(void){
int first_time;
belle_sip_list_t **pools=get_current_pool_stack(&first_time);
if (pools==NULL) return NULL;
if (*pools==NULL ){
if (first_time) {
belle_sip_warning("There is no object pool created in thread [%lu]. "
"Use belle_sip_object_pool_push() to create one. Unowned objects not unref'd will be leaked.",
belle_sip_thread_self_id());
}
return NULL;
}
return (belle_sip_object_pool_t*)(*pools)->data;
}
belle-sip-5.2.0+dfsg/src/belle_sip_parameters.c 0000664 0000000 0000000 00000014222 14346131365 0021434 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "belle-sip/belle-sip.h"
#include "belle-sip/parameters.h"
#include "belle_sip_internal.h"
#include "belle-sip/headers.h"
void belle_sip_parameters_init(belle_sip_parameters_t *obj){
}
void belle_sip_parameters_clean(belle_sip_parameters_t* params) {
if (params->param_list) belle_sip_list_free_with_data (params->param_list, (void (*)(void*))belle_sip_param_pair_destroy);
if (params->paramnames_list) belle_sip_list_free(params->paramnames_list);
params->paramnames_list=NULL;
params->param_list=NULL;
}
static void belle_sip_parameters_destroy(belle_sip_parameters_t* params) {
belle_sip_parameters_clean(params);
}
void belle_sip_parameters_copy_parameters_from(belle_sip_parameters_t *params, const belle_sip_parameters_t *orig){
belle_sip_list_t* list=orig->param_list;
for(;list!=NULL;list=list->next){
belle_sip_param_pair_t* container = (belle_sip_param_pair_t* )(list->data);
belle_sip_parameters_set_parameter( params,container->name,container->value);
}
}
static void belle_sip_parameters_clone(belle_sip_parameters_t *params, const belle_sip_parameters_t *orig){
belle_sip_parameters_copy_parameters_from(params,orig);
}
belle_sip_error_code belle_sip_parameters_marshal(const belle_sip_parameters_t* params, char* buff, size_t buff_size, size_t *offset) {
belle_sip_list_t* list=params->param_list;
belle_sip_error_code error=BELLE_SIP_OK;
for(;list!=NULL;list=list->next){
belle_sip_param_pair_t* container = (belle_sip_param_pair_t* )(list->data);
if (container->value) {
error=belle_sip_snprintf(buff,buff_size,offset,";%s=%s", container->name, container->value);
} else {
error=belle_sip_snprintf(buff,buff_size,offset,";%s", container->name);
}
if (error!=BELLE_SIP_OK) return error;
}
return error;
}
BELLE_SIP_NEW_HEADER(parameters,header,"parameters")
const belle_sip_list_t *belle_sip_parameters_get_parameters(const belle_sip_parameters_t* obj) {
return obj->param_list;
}
const char* belle_sip_parameters_get_parameter_base(const belle_sip_parameters_t* params,const char* name,belle_sip_compare_func func) {
belle_sip_list_t * lResult = belle_sip_list_find_custom(params->param_list, func, name);
if (lResult) {
return ((belle_sip_param_pair_t*)(lResult->data))->value;
}
else {
return NULL;
}
}
const char* belle_sip_parameters_get_parameter(const belle_sip_parameters_t* params,const char* name) {
return belle_sip_parameters_get_parameter_base(params,name,(belle_sip_compare_func)belle_sip_param_pair_comp_func);
}
const char* belle_sip_parameters_get_case_parameter(const belle_sip_parameters_t* params,const char* name) {
return belle_sip_parameters_get_parameter_base(params,name,(belle_sip_compare_func)belle_sip_param_pair_case_comp_func);
}
unsigned int belle_sip_parameters_has_parameter(const belle_sip_parameters_t* params,const char* name) {
return belle_sip_list_find_custom(params->param_list, (belle_sip_compare_func)belle_sip_param_pair_comp_func, name) != NULL;
}
void belle_sip_parameters_set_parameter(belle_sip_parameters_t* params,const char* name,const char* value) {
/*1 check if present*/
belle_sip_param_pair_t* lNewpair;
belle_sip_list_t * lResult = belle_sip_list_find_custom(params->paramnames_list, (belle_sip_compare_func)strcmp, name);
/* first remove from header names list*/
if (lResult) {
params->paramnames_list=belle_sip_list_delete_link(params->paramnames_list,lResult);
}
/* next from header list*/
lResult = belle_sip_list_find_custom(params->param_list, (belle_sip_compare_func)belle_sip_param_pair_comp_func, name);
if (lResult) {
belle_sip_param_pair_destroy(lResult->data);
params->param_list=belle_sip_list_delete_link(params->param_list,lResult);
}
/* 2 insert*/
lNewpair = belle_sip_param_pair_new(name,value);
params->param_list=belle_sip_list_append(params->param_list,lNewpair);
params->paramnames_list=belle_sip_list_append(params->paramnames_list,lNewpair->name);
}
void belle_sip_parameters_set(belle_sip_parameters_t *parameters, const char* params){
belle_sip_parameters_clean(parameters);
if (params && *params!='\0'){
char *tmp=belle_sip_strdup(params);
char *end_of_param;
char *current=tmp;
char *equal;
char *next;
do{
end_of_param=strchr(current,';');
equal=strchr(current,'=');
if (!end_of_param) {
end_of_param=current+strlen(current);
next=end_of_param;
}else{
*end_of_param='\0';
next=end_of_param+1;
}
if (equal && equalparamnames_list:NULL;
}
void belle_sip_parameters_remove_parameter(belle_sip_parameters_t* params,const char* name) {
/*1 check if present*/
belle_sip_list_t * lResult = belle_sip_list_find_custom(params->paramnames_list, (belle_sip_compare_func)strcmp, name);
/* first remove from header names list*/
if (lResult) {
params->paramnames_list=belle_sip_list_delete_link(params->paramnames_list,lResult);
/*next remove node*/
lResult = belle_sip_list_find_custom(params->param_list, (belle_sip_compare_func)belle_sip_param_pair_comp_func, name);
if (lResult) {
belle_sip_param_pair_destroy(lResult->data);
params->param_list=belle_sip_list_delete_link(params->param_list,lResult);
}
}
}
belle-sip-5.2.0+dfsg/src/belle_sip_resolver.c 0000664 0000000 0000000 00000223774 14346131365 0021150 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "belle_sip_internal.h"
#include
#ifdef HAVE_MDNS
#include
#endif
#include
#include
#ifdef __APPLE__
#include "TargetConditionals.h"
#endif
#ifdef HAVE_DNS_SERVICE
/* When HAVE_DNS_SERVICE is on, the resolve is performed using Apple DNSService */
#include "TargetConditionals.h"
#include "dns.h"
#include
#include
#include "bctoolbox/port.h" // mutex
#endif /* HAVE_DNS_SERVICE */
#include "dns/dns.h"
#define DNS_EAGAIN EAGAIN
/* Default value for a timeout to wait AAAA results after A result for the same host have been received.
* This is to compensate buggy routers that don't really support IPv6 and never provide any answer to AAAA queries.
*/
static const int belle_sip_aaaa_timeout_after_a_received = 3000;
/* Default value for a timeout to wait for SRV results after a A/AAAA result for the same domain has been received.
* This is to compensate buggy routers that don't really support SRV and never provide any answer to SRV queries.
*/
static const int belle_sip_srv_timeout_after_a_received = 3000;
typedef struct belle_sip_simple_resolver_context belle_sip_simple_resolver_context_t;
#define BELLE_SIP_SIMPLE_RESOLVER_CONTEXT(obj) BELLE_SIP_CAST(obj,belle_sip_simple_resolver_context_t)
typedef struct belle_sip_combined_resolver_context belle_sip_combined_resolver_context_t;
#define BELLE_SIP_COMBINED_RESOLVER_CONTEXT(obj) BELLE_SIP_CAST(obj,belle_sip_combined_resolver_context_t)
typedef struct belle_sip_dual_resolver_context belle_sip_dual_resolver_context_t;
#define BELLE_SIP_DUAL_RESOLVER_CONTEXT(obj) BELLE_SIP_CAST(obj,belle_sip_dual_resolver_context_t)
struct belle_sip_dns_srv{
belle_sip_object_t base;
unsigned short priority;
unsigned short weight;
unsigned short port;
unsigned char a_done;
unsigned char dont_free_a_results;
int cumulative_weight; /*used only temporarily*/
char *target;
belle_sip_combined_resolver_context_t *root_resolver;/* used internally to combine SRV and A queries*/
belle_sip_resolver_context_t *a_resolver; /* used internally to combine SRV and A queries*/
struct addrinfo *a_results; /* used internally to combine SRV and A queries*/
#ifdef HAVE_MDNS
char *fullname; /* Used by mDNS */
#endif
};
static void belle_sip_dns_srv_destroy(belle_sip_dns_srv_t *obj){
if (obj->target) {
belle_sip_free(obj->target);
obj->target=NULL;
}
if (obj->a_resolver){
belle_sip_resolver_context_cancel(obj->a_resolver);
belle_sip_object_unref(obj->a_resolver);
obj->a_resolver=NULL;
}
if (obj->a_results && !obj->dont_free_a_results){
bctbx_freeaddrinfo(obj->a_results);
obj->a_results=NULL;
}
#ifdef HAVE_MDNS
if (obj->fullname){
belle_sip_free(obj->fullname);
obj->fullname = NULL;
}
#endif
}
#ifdef HAVE_MDNS
belle_sip_dns_srv_t *belle_sip_mdns_srv_create(short unsigned int priority, short unsigned int weight, short unsigned int port, const char *target, const char *fullname){
belle_sip_dns_srv_t *obj=belle_sip_object_new(belle_sip_dns_srv_t);
obj->priority=priority;
obj->weight=weight;
obj->port=port;
obj->target=belle_sip_strdup(target);
obj->fullname=belle_sip_strdup(fullname);
return obj;
}
#endif
#ifdef HAVE_DNS_SERVICE
belle_sip_dns_srv_t *belle_sip_dns_srv_create_dns_service(dns_resource_record_t *rr){
belle_sip_dns_srv_t *obj=belle_sip_object_new(belle_sip_dns_srv_t);
size_t end_pos;
obj->priority=rr->data.SRV->priority;
obj->weight=rr->data.SRV->weight;
obj->port=rr->data.SRV->port;
obj->target=belle_sip_strdup(rr->data.SRV->target);
/*remove trailing '.' at the end*/
end_pos = strlen(obj->target);
if (end_pos > 0){
end_pos--;
if (obj->target[end_pos] == '.') obj->target[end_pos] = '\0';
}
return obj;
}
#endif /* HAVE_DNS_SERVICE */
belle_sip_dns_srv_t *belle_sip_dns_srv_create(struct dns_srv *srv){
belle_sip_dns_srv_t *obj=belle_sip_object_new(belle_sip_dns_srv_t);
size_t end_pos;
obj->priority=srv->priority;
obj->weight=srv->weight;
obj->port=srv->port;
obj->target=belle_sip_strdup(srv->target);
/*remove trailing '.' at the end*/
end_pos = strlen(obj->target);
if (end_pos > 0){
end_pos--;
if (obj->target[end_pos] == '.') obj->target[end_pos] = '\0';
}
return obj;
}
const char *belle_sip_dns_srv_get_target(const belle_sip_dns_srv_t *obj){
return obj->target;
}
unsigned short belle_sip_dns_srv_get_priority(const belle_sip_dns_srv_t *obj){
return obj->priority;
}
unsigned short belle_sip_dns_srv_get_weight(const belle_sip_dns_srv_t *obj){
return obj->weight;
}
unsigned short belle_sip_dns_srv_get_port(const belle_sip_dns_srv_t *obj){
return obj->port;
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_dns_srv_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_sip_dns_srv_t, belle_sip_object_t,belle_sip_dns_srv_destroy, NULL, NULL,TRUE);
struct belle_sip_resolver_results{
belle_sip_object_t base;
struct addrinfo *ai_list;
bctbx_list_t *srv_list;
char *name;
uint32_t ttl;
};
static void belle_sip_resolver_results_destroy(belle_sip_resolver_results_t *obj){
if (obj->ai_list) bctbx_freeaddrinfo(obj->ai_list);
bctbx_list_free_with_data(obj->srv_list, belle_sip_object_unref);
if (obj->name) bctbx_free(obj->name);
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_resolver_results_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_sip_resolver_results_t, belle_sip_object_t,belle_sip_resolver_results_destroy, NULL, NULL,FALSE);
static int addrinfo_in_range(const struct addrinfo *ai, const struct addrinfo *begin, const struct addrinfo *end){
const struct addrinfo *it;
for (it = begin ; it != end; it = it->ai_next){
if (it == NULL){
belle_sip_error("addrinfo_in_range(): it == NULL, this should not happen, this is a bug !");
break;
}
if (it == ai){
return 1;
}
}
return 0;
}
static const belle_sip_dns_srv_t * _belle_sip_dns_srv_get_from_addrinfo(const belle_sip_list_t *srv_list, const struct addrinfo *ai){
/* We simply iterate on the addrinfo pointed by the srv objects in the srv list until we find "ai".
* This is not very efficient but there is not that much alternatives:
* - there is no user pointer in struct addrinfo
* - there might not be srv record for a domain, in which case the srv_list is empty...
*/
const bctbx_list_t *elem;
for (elem = srv_list; elem != NULL; elem = elem->next){
const belle_sip_dns_srv_t *srv = (const belle_sip_dns_srv_t *) elem->data;
const belle_sip_dns_srv_t *next_srv = elem->next ? (const belle_sip_dns_srv_t *) elem->next->data : NULL;
if (addrinfo_in_range(ai, srv->a_results, next_srv ? next_srv->a_results : NULL)){
return srv;
}
}
return NULL;
}
const belle_sip_dns_srv_t * belle_sip_resolver_results_get_srv_from_addrinfo(const belle_sip_resolver_results_t *obj, const struct addrinfo *ai){
return _belle_sip_dns_srv_get_from_addrinfo(obj->srv_list, ai);
}
const bctbx_list_t *belle_sip_resolver_results_get_srv_records(const belle_sip_resolver_results_t *obj){
return obj->srv_list;
}
const struct addrinfo *belle_sip_resolver_results_get_addrinfos(const belle_sip_resolver_results_t *obj){
return obj->ai_list;
}
int belle_sip_resolver_results_get_ttl(const belle_sip_resolver_results_t *obj){
return obj->ttl;
}
const char *belle_sip_resolver_results_get_name(const belle_sip_resolver_results_t *obj){
return obj->name;
}
belle_sip_resolver_results_t *belle_sip_resolver_results_create(const char *name, struct addrinfo *ai_list, belle_sip_list_t *srv_list, int ttl){
belle_sip_resolver_results_t *obj = belle_sip_object_new(belle_sip_resolver_results_t);
obj->ai_list = ai_list;
obj->srv_list = srv_list;
obj->ttl = ttl;
obj->name = bctbx_strdup(name);
return obj;
}
struct belle_sip_resolver_context{
belle_sip_source_t source;
belle_sip_stack_t *stack;
uint32_t min_ttl;
uint8_t notified;
uint8_t cancelled;
#ifdef HAVE_DNS_SERVICE
uint8_t use_dns_service;
uint8_t pad[1];
#else /* HAVE_DNS_SERVICE */
uint8_t pad[2];
#endif /* else HAVE_DNS_SERVICE */
};
struct belle_sip_simple_resolver_context{
belle_sip_resolver_context_t base;
belle_sip_resolver_callback_t cb;
belle_sip_resolver_srv_callback_t srv_cb;
void *cb_data;
void *srv_cb_data;
#ifdef HAVE_DNS_SERVICE
bctbx_mutex_t notify_mutex; // result is notified first on a specific thread, mutex to manage interactions with cancel
DNSServiceErrorType err; // used to pass the request dispatching status from the dns_service_queue to the main thread
DNSServiceRef dns_service;
dispatch_source_t dns_service_timer;
uint16_t dns_service_type;
dispatch_queue_t dns_service_queue; // this queue is created by the stack, but store a ref on it anyway
#endif /*HAVE_DNS_SERVICE */
struct dns_resolv_conf *resconf;
struct dns_hosts *hosts;
struct dns_resolver *R;
enum dns_type type;
char *name;
int port;
struct addrinfo *ai_list;
belle_sip_list_t *srv_list; /*list of belle_sip_dns_srv_t*/
int family;
int flags;
uint64_t start_time;
#ifdef HAVE_MDNS
char *srv_prefix;
char *srv_name;
int resolving;
bool_t browse_finished;
#endif
#if defined(USE_GETADDRINFO_FALLBACK) || defined(HAVE_MDNS)
struct addrinfo *getaddrinfo_ai_list;
belle_sip_source_t *getaddrinfo_source;
belle_sip_thread_t getaddrinfo_thread;
unsigned char getaddrinfo_done;
unsigned char getaddrinfo_cancelled;
#ifdef _WIN32
HANDLE ctlevent;
#else
int ctlpipe[2];
#endif
#endif
bool_t not_using_dns_socket;
};
struct belle_sip_combined_resolver_context{
belle_sip_resolver_context_t base;
belle_sip_resolver_callback_t cb;
void *cb_data;
char *name;
int port;
int family;
struct addrinfo *final_results;
struct addrinfo *a_fallback_results;
belle_sip_list_t *srv_results;
belle_sip_resolver_context_t *srv_ctx;
belle_sip_resolver_context_t *a_fallback_ctx;
int a_fallback_ttl;
unsigned char srv_completed;
unsigned char a_fallback_completed;
};
struct belle_sip_dual_resolver_context{
belle_sip_resolver_context_t base;
belle_sip_resolver_callback_t cb;
void *cb_data;
char *name;
belle_sip_resolver_context_t *a_ctx;
belle_sip_resolver_context_t *aaaa_ctx;
struct addrinfo *a_results;
struct addrinfo *aaaa_results;
uint8_t a_notified;
uint8_t aaaa_notified;
uint8_t pad[2];
};
void belle_sip_resolver_context_init(belle_sip_resolver_context_t *obj, belle_sip_stack_t *stack){
obj->stack=stack;
obj->min_ttl = UINT32_MAX;
#ifdef HAVE_DNS_SERVICE
obj->use_dns_service = obj->stack->use_dns_service; // the object might actually survive the stack, so save crucial information
#endif /* HAVE_DNS_SERVICE */
belle_sip_init_sockets(); /* Need to be called for DNS resolution to work on Windows platform. */
}
static int dns_resconf_nameservers_from_list(struct dns_resolv_conf *resconf, const belle_sip_list_t *l) {
int max_servers = sizeof(resconf->nameserver)/sizeof(struct sockaddr_storage);
int i;
const belle_sip_list_t *elem;
for (i = 0, elem = l; i < max_servers && elem != NULL; elem = elem->next) {
int error = dns_resconf_pton(&resconf->nameserver[i], (const char *) elem->data);
if (error == 0) ++i;
}
return i > 0 ? 0 : -1;
}
static struct dns_resolv_conf *resconf(belle_sip_simple_resolver_context_t *ctx) {
const char *path;
const belle_sip_list_t *servers;
int error;
if (ctx->resconf)
return ctx->resconf;
if (!(ctx->resconf = dns_resconf_open(&error))) {
belle_sip_error("%s dns_resconf_open error: %s", __FUNCTION__, dns_strerror(error));
return NULL;
}
path = belle_sip_stack_get_dns_resolv_conf_file(ctx->base.stack);
servers = ctx->base.stack->dns_servers;
if (servers){
belle_sip_message("%s using application supplied dns server list.", __FUNCTION__);
error = dns_resconf_nameservers_from_list(ctx->resconf, servers);
}else if (!path){
#if defined(USE_FIXED_NAMESERVERS)
error = dns_resconf_load_fixed_nameservers(ctx->resconf);
if (error) {
belle_sip_error("%s dns_resconf_load_fixed_nameservers error", __FUNCTION__);
}
#elif defined(USE_STRUCT_RES_STATE_NAMESERVERS)
error = dns_resconf_load_struct_res_state_nameservers(ctx->resconf);
if (error) {
belle_sip_error("%s dns_resconf_load_struct_res_state_nameservers error", __FUNCTION__);
}
#elif defined(_WIN32)
error = dns_resconf_loadwin(ctx->resconf);
if (error) {
belle_sip_error("%s dns_resconf_loadwin error", __FUNCTION__);
}
#elif defined(__ANDROID__)
error = dns_resconf_loadandroid(ctx->resconf);
if (error) {
belle_sip_error("%s dns_resconf_loadandroid error", __FUNCTION__);
}
#elif defined(HAVE_RESINIT)
/*#elif HAVE_RESINIT && TARGET_OS_IPHONE*/
error = dns_resconf_loadfromresolv(ctx->resconf);
if (error) {
belle_sip_error("%s dns_resconf_loadfromresolv error", __FUNCTION__);
}
#else
path = "/etc/resolv.conf";
error = dns_resconf_loadpath(ctx->resconf, path);
if (error) {
belle_sip_error("%s dns_resconf_loadpath error [%s]: %s", __FUNCTION__, path, dns_strerror(error));
return NULL;
}
path = "/etc/nsswitch.conf";
error = dns_nssconf_loadpath(ctx->resconf, path);
if (error) {
belle_sip_message("%s dns_nssconf_loadpath error [%s]: %s", __FUNCTION__, path, dns_strerror(error));
}
#endif
}else{
error = dns_resconf_loadpath(ctx->resconf, path);
if (error) {
belle_sip_error("%s dns_resconf_loadpath() of custom file error [%s]: %s", __FUNCTION__, path, dns_strerror(error));
return NULL;
}
}
if (error==0){
char ip[64];
char serv[10];
int using_ipv6=FALSE;
size_t i;
belle_sip_message("Resolver is using DNS server(s):");
for(i=0;iresconf->nameserver)/sizeof(ctx->resconf->nameserver[0]);++i){
struct sockaddr *ns_addr=(struct sockaddr*)&ctx->resconf->nameserver[i];
if (ns_addr->sa_family==AF_UNSPEC) break;
bctbx_getnameinfo(ns_addr,ns_addr->sa_family==AF_INET6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr)
,ip,sizeof(ip),serv,sizeof(serv),NI_NUMERICHOST|NI_NUMERICSERV);
belle_sip_message("\t%s",ip);
if (ns_addr->sa_family==AF_INET6) using_ipv6=TRUE;
}
ctx->resconf->iface.ss_family=using_ipv6 ? AF_INET6 : AF_INET;
if (i==0) {
belle_sip_error("- no DNS servers available - resolution aborted.");
return NULL;
}
}else{
belle_sip_error("Error loading dns server addresses.");
return NULL;
}
return ctx->resconf;
}
static struct dns_hosts *hosts(belle_sip_simple_resolver_context_t *ctx) {
int error;
if (ctx->hosts)
return ctx->hosts;
if (!(ctx->hosts = dns_hosts_local(&error))) {
belle_sip_warning("%s dns_hosts_local error: %s", __FUNCTION__, dns_strerror(error));
/*in case of failure, create an empty host object to make further processing happy, knowing that we can live without /etc/hosts.*/
ctx->hosts=dns_hosts_open(&error);
}
if (ctx->base.stack->dns_user_hosts_file) {
error = dns_hosts_loadpath(ctx->hosts, ctx->base.stack->dns_user_hosts_file);
if (error) {
belle_sip_error("%s dns_hosts_loadfile(\"%s\"): %s", __FUNCTION__,ctx->base.stack->dns_user_hosts_file,dns_strerror(error));
}
}
return ctx->hosts;
}
struct dns_cache *cache(belle_sip_simple_resolver_context_t *ctx) {
return NULL;
}
static struct addrinfo * ai_list_append(struct addrinfo *ai_list, struct addrinfo *ai_to_append) {
struct addrinfo *ai_current = ai_list;
if (ai_to_append == NULL) return ai_list;
if (ai_list == NULL) return ai_to_append;
while (ai_current->ai_next != NULL) {
ai_current = ai_current->ai_next;
}
ai_current->ai_next = ai_to_append;
return ai_list;
}
static int srv_compare_prio(const void *psrv1, const void *psrv2){
belle_sip_dns_srv_t *srv1=(belle_sip_dns_srv_t*)psrv1;
belle_sip_dns_srv_t *srv2=(belle_sip_dns_srv_t*)psrv2;
if (srv1->priority < srv2->priority) return -1;
if (srv1->priority == srv2->priority) return 0;
return 1;
}
#ifdef HAVE_MDNS
static int mdns_srv_compare_host_and_port(const void *psrv1, const void *psrv2){
belle_sip_dns_srv_t *srv1=(belle_sip_dns_srv_t*)psrv1;
belle_sip_dns_srv_t *srv2=(belle_sip_dns_srv_t*)psrv2;
int ret = strcmp(srv1->target, srv2->target);
if (ret != 0) return ret;
if (srv1->port < srv2->port) return -1;
if (srv1->port == srv2->port) return 0;
return 1;
}
static int mdns_srv_compare_fullname(const void *psrv1, const void *psrv2){
belle_sip_dns_srv_t *srv1=(belle_sip_dns_srv_t*)psrv1;
belle_sip_dns_srv_t *srv2=(belle_sip_dns_srv_t*)psrv2;
return strcmp(srv1->fullname, srv2->fullname);
}
#endif
/*
* see https://www.ietf.org/rfc/rfc2782.txt
* 0 weighted must just appear first.
**/
static int srv_sort_weight(const void *psrv1, const void *psrv2){
belle_sip_dns_srv_t *srv1=(belle_sip_dns_srv_t*)psrv1;
if (srv1->weight==0) return -1;
return 1;
}
static belle_sip_dns_srv_t *srv_elect_one(belle_sip_list_t *srv_list){
int sum=0;
belle_sip_list_t *elem;
belle_sip_dns_srv_t *srv;
int rand_number;
for(elem=srv_list;elem!=NULL;elem=elem->next){
srv=(belle_sip_dns_srv_t*)elem->data;
sum+=srv->weight;
srv->cumulative_weight=sum;
}
/*no weights given, return the first one*/
if (sum==0) return (belle_sip_dns_srv_t*)srv_list->data;
rand_number=belle_sip_random() % sum; /*random number choosen in the range of the sum of weights*/
for(elem=srv_list;elem!=NULL;elem=elem->next){
srv=(belle_sip_dns_srv_t*)elem->data;
if (rand_number<=srv->cumulative_weight)
return srv;
}
return (belle_sip_dns_srv_t*)srv_list->data;
}
/*
* Order an SRV list with entries having the same priority according to their weight
*/
static belle_sip_list_t *srv_elect(belle_sip_list_t **srv_list) {
belle_sip_list_t *result = NULL;
while (*srv_list != NULL) {
belle_sip_list_t *it;
belle_sip_dns_srv_t *entry = srv_elect_one(*srv_list);
result = belle_sip_list_append(result, belle_sip_object_ref(entry));
it = belle_sip_list_find(*srv_list, entry);
if (it) {
*srv_list = belle_sip_list_remove_link(*srv_list, it);
belle_sip_free(it);
}
}
return result;
}
/*
* this function will return a list of SRV, with only one SRV record per priority.
*/
static belle_sip_list_t *srv_select_by_weight(belle_sip_list_t *srv_list){
belle_sip_list_t *same_prio=NULL;
belle_sip_list_t *elem;
belle_sip_dns_srv_t *prev_srv=NULL;
belle_sip_list_t *result=NULL;
for (elem=srv_list;elem!=NULL;elem=elem->next){
belle_sip_dns_srv_t *srv=(belle_sip_dns_srv_t*)elem->data;
if (prev_srv){
if (prev_srv->priority==srv->priority){
if (!same_prio){
same_prio=belle_sip_list_append(same_prio,prev_srv);
}
same_prio=belle_sip_list_insert_sorted(same_prio,srv,srv_sort_weight);
}else{
if (same_prio){
result=belle_sip_list_concat(result,srv_elect(&same_prio));
}
}
}
prev_srv=srv;
}
if (same_prio){
result=belle_sip_list_concat(result,srv_elect(&same_prio));
}
if (result){
belle_sip_list_free_with_data(srv_list,belle_sip_object_unref);
return result;
}
return srv_list;/*no weight election was necessary, return original list*/
}
static void simple_resolver_context_notify(belle_sip_resolver_context_t *obj) {
belle_sip_simple_resolver_context_t *ctx = BELLE_SIP_SIMPLE_RESOLVER_CONTEXT(obj);
if ((ctx->type == DNS_T_A) || (ctx->type == DNS_T_AAAA)
#ifdef HAVE_DNS_SERVICE
|| (ctx->dns_service_type == kDNSServiceType_A) || (ctx->dns_service_type == kDNSServiceType_AAAA)
#endif /* HAVE_DNS_SERVICE */
) {
struct addrinfo **ai_list = &ctx->ai_list;
belle_sip_resolver_results_t *results;
#if defined(USE_GETADDRINFO_FALLBACK) || defined(HAVE_MDNS)
if (ctx->getaddrinfo_ai_list != NULL) ai_list = &ctx->getaddrinfo_ai_list;
#endif
results = belle_sip_resolver_results_create(ctx->name, *ai_list, NULL, BELLE_SIP_RESOLVER_CONTEXT(obj)->min_ttl);
ctx->cb(ctx->cb_data, results);
*ai_list = NULL;
belle_sip_object_unref(results);
} else if (ctx->type == DNS_T_SRV
#ifdef HAVE_DNS_SERVICE
|| (ctx->dns_service_type == kDNSServiceType_SRV)
#endif /* HAVE_DNS_SERVICE */
) {
ctx->srv_list = srv_select_by_weight(ctx->srv_list);
ctx->srv_cb(ctx->srv_cb_data, ctx->name, ctx->srv_list, BELLE_SIP_RESOLVER_CONTEXT(obj)->min_ttl);
}
}
static void dual_resolver_context_notify(belle_sip_resolver_context_t *obj) {
belle_sip_dual_resolver_context_t *ctx = BELLE_SIP_DUAL_RESOLVER_CONTEXT(obj);
struct addrinfo *results = ctx->aaaa_results;
belle_sip_resolver_results_t *result_obj;
results = ai_list_append(results, ctx->a_results);
ctx->a_results = NULL;
ctx->aaaa_results = NULL;
result_obj = belle_sip_resolver_results_create(ctx->name, results, NULL, BELLE_SIP_RESOLVER_CONTEXT(obj)->min_ttl);
ctx->cb(ctx->cb_data, result_obj);
belle_sip_object_unref(result_obj);
}
static void combined_resolver_context_cleanup(belle_sip_combined_resolver_context_t *ctx) {
if (ctx->srv_ctx) {
belle_sip_object_unref(ctx->srv_ctx);
ctx->srv_ctx = NULL;
}
if (ctx->a_fallback_ctx) {
belle_sip_object_unref(ctx->a_fallback_ctx);
ctx->a_fallback_ctx = NULL;
}
belle_sip_list_free_with_data(ctx->srv_results, belle_sip_object_unref);
ctx->srv_results = NULL;
}
static void combined_resolver_context_notify(belle_sip_resolver_context_t *obj) {
belle_sip_combined_resolver_context_t *ctx = BELLE_SIP_COMBINED_RESOLVER_CONTEXT(obj);
belle_sip_resolver_results_t *results = belle_sip_resolver_results_create(ctx->name, ctx->final_results, ctx->srv_results, BELLE_SIP_RESOLVER_CONTEXT(obj)->min_ttl);
ctx->cb(ctx->cb_data, results);
belle_sip_object_unref(results);
ctx->final_results = NULL;
ctx->srv_results = NULL;
combined_resolver_context_cleanup(ctx);
}
static void append_dns_result(belle_sip_simple_resolver_context_t *ctx, struct addrinfo **ai_list, struct sockaddr *addr, socklen_t addrlen){
char host[NI_MAXHOST + 1];
int gai_err;
int family=ctx->family;
if ((gai_err=bctbx_getnameinfo(addr, addrlen, host, sizeof(host), NULL, 0, NI_NUMERICHOST)) != 0){
belle_sip_error("append_dns_result(): getnameinfo() failed: %s",gai_strerror(gai_err));
return;
}
if (ctx->flags & AI_V4MAPPED) family=AF_INET6;
*ai_list = ai_list_append(*ai_list, bctbx_ip_address_to_addrinfo(family, SOCK_STREAM, host, ctx->port));
belle_sip_message("%s resolved to %s", ctx->name, host);
}
static int resolver_process_data(belle_sip_simple_resolver_context_t *ctx, unsigned int revents) {
struct dns_packet *ans;
struct dns_rr_i *I;
struct dns_rr_i dns_rr_it;
int error;
unsigned char simulated_timeout=0;
int timeout=belle_sip_stack_get_dns_timeout(ctx->base.stack);
unsigned char search_enabled = belle_sip_stack_dns_search_enabled(ctx->base.stack);
/*Setting timeout to 0 can be used to simulate DNS timeout*/
if ((revents!=0) && timeout==0){
belle_sip_warning("Simulating DNS timeout");
simulated_timeout=1;
}
if (simulated_timeout || ((revents & BELLE_SIP_EVENT_TIMEOUT) && ((int)(belle_sip_time_ms()-ctx->start_time)>=timeout))) {
belle_sip_error("%s timed-out", __FUNCTION__);
belle_sip_resolver_context_notify(BELLE_SIP_RESOLVER_CONTEXT(ctx));
return BELLE_SIP_STOP;
}
dns_res_enable_search(ctx->R, search_enabled);
/*belle_sip_message("resolver_process_data(): revents=%i",revents);*/
error = dns_res_check(ctx->R);
if (!error) {
struct dns_rr rr;
union dns_any any;
enum dns_section section = DNS_S_AN;
ans = dns_res_fetch(ctx->R, &error);
memset(&dns_rr_it, 0, sizeof dns_rr_it);
I = dns_rr_i_init(&dns_rr_it, ans);
while (dns_rr_grep(&rr, 1, I, ans, &error)) {
if (rr.section == section) {
if ((error = dns_any_parse(dns_any_init(&any, sizeof(any)), &rr, ans))) {
belle_sip_error("%s dns_any_parse error: %s", __FUNCTION__, dns_strerror(error));
break;
}
if ((ctx->type == DNS_T_AAAA) && (rr.class == DNS_C_IN) && (rr.type == DNS_T_AAAA)) {
struct dns_aaaa *aaaa = &any.aaaa;
struct sockaddr_in6 sin6;
memset(&sin6, 0, sizeof(sin6));
memcpy(&sin6.sin6_addr, &aaaa->addr, sizeof(sin6.sin6_addr));
sin6.sin6_family = AF_INET6;
sin6.sin6_port = ctx->port;
append_dns_result(ctx,&ctx->ai_list,(struct sockaddr*)&sin6,sizeof(sin6));
if (rr.ttl < BELLE_SIP_RESOLVER_CONTEXT(ctx)->min_ttl) BELLE_SIP_RESOLVER_CONTEXT(ctx)->min_ttl = rr.ttl;
} else if ((ctx->type == DNS_T_A) && (rr.class == DNS_C_IN) && (rr.type == DNS_T_A)) {
struct dns_a *a = &any.a;
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
memcpy(&sin.sin_addr, &a->addr, sizeof(sin.sin_addr));
sin.sin_family = AF_INET;
sin.sin_port = ctx->port;
append_dns_result(ctx,&ctx->ai_list,(struct sockaddr*)&sin,sizeof(sin));
if (rr.ttl < BELLE_SIP_RESOLVER_CONTEXT(ctx)->min_ttl) BELLE_SIP_RESOLVER_CONTEXT(ctx)->min_ttl = rr.ttl;
} else if ((ctx->type == DNS_T_SRV) && (rr.class == DNS_C_IN) && (rr.type == DNS_T_SRV)) {
char host[NI_MAXHOST + 1];
struct dns_srv *srv = &any.srv;
belle_sip_dns_srv_t * b_srv=belle_sip_dns_srv_create(srv);
snprintf(host, sizeof(host), "[target:%s port:%d prio:%d weight:%d]", srv->target, srv->port, srv->priority, srv->weight);
ctx->srv_list = belle_sip_list_insert_sorted(ctx->srv_list, belle_sip_object_ref(b_srv), srv_compare_prio);
belle_sip_message("SRV %s resolved to %s", ctx->name, host);
if (rr.ttl < BELLE_SIP_RESOLVER_CONTEXT(ctx)->min_ttl) BELLE_SIP_RESOLVER_CONTEXT(ctx)->min_ttl = rr.ttl;
}
}
}
free(ans);
#if defined(USE_GETADDRINFO_FALLBACK) || defined(HAVE_MDNS)
ctx->getaddrinfo_cancelled = TRUE;
#endif
if (dns_res_was_asymetric(ctx->R)){
belle_sip_warning("DNS answer was not received from the DNS server IP address the request was sent to. This seems to be a known issue with NAT64 networks created by Apple computers.");
}
belle_sip_resolver_context_notify(BELLE_SIP_RESOLVER_CONTEXT(ctx));
return BELLE_SIP_STOP;
}
if (error != DNS_EAGAIN) {
belle_sip_error("%s dns_res_check() error: %s (%d)", __FUNCTION__, dns_strerror(error), error);
#if defined(USE_GETADDRINFO_FALLBACK) || defined(HAVE_MDNS)
if (ctx->getaddrinfo_done) {
return BELLE_SIP_STOP;
} else {
// Wait for the getaddrinfo result
return BELLE_SIP_CONTINUE;
}
#else
belle_sip_resolver_context_notify(BELLE_SIP_RESOLVER_CONTEXT(ctx));
return BELLE_SIP_STOP;
#endif
} else {
#if defined(USE_GETADDRINFO_FALLBACK) || defined(HAVE_MDNS)
if (ctx->getaddrinfo_done) {
return BELLE_SIP_STOP;
} else
#endif
{
belle_sip_message("%s dns_res_check() in progress", __FUNCTION__);
}
}
return BELLE_SIP_CONTINUE;
}
#if defined(USE_GETADDRINFO_FALLBACK) || defined(HAVE_MDNS)
static void * _resolver_getaddrinfo_thread(void *ptr) {
belle_sip_simple_resolver_context_t *ctx = (belle_sip_simple_resolver_context_t *)ptr;
struct addrinfo *res = NULL;
struct addrinfo hints = { 0 };
char serv[10];
int err;
belle_sip_message("Resolver getaddrinfo thread started.");
snprintf(serv, sizeof(serv), "%i", ctx->port);
hints.ai_family = ctx->family;
hints.ai_flags = AI_NUMERICSERV;
hints.ai_protocol = strstr(ctx->name, "udp") ? IPPROTO_UDP : IPPROTO_TCP;
err = getaddrinfo(ctx->name, serv, &hints, &res);
if (err != 0) {
belle_sip_error("getaddrinfo DNS resolution of %s failed: %s", ctx->name, gai_strerror(err));
} else if (!ctx->getaddrinfo_cancelled) {
struct addrinfo *res_it = res;
do {
append_dns_result(ctx, &ctx->getaddrinfo_ai_list, res_it->ai_addr, (socklen_t)res_it->ai_addrlen);
res_it = res_it->ai_next;
} while (res_it != NULL);
}
if (res) freeaddrinfo(res);
ctx->getaddrinfo_done = TRUE;
#ifdef _WIN32
SetEvent(ctx->ctlevent);
#else
if (write(ctx->ctlpipe[1], "q", 1) == -1) {
belle_sip_error("_resolver_getaddrinfo_thread(): Fail to write on pipe.");
}
#endif
return NULL;
}
static int _resolver_getaddrinfo_callback(belle_sip_simple_resolver_context_t *ctx, unsigned int revents) {
if (!ctx->getaddrinfo_cancelled) {
belle_sip_resolver_context_notify(BELLE_SIP_RESOLVER_CONTEXT(ctx));
}
belle_sip_object_unref(ctx);
return BELLE_SIP_STOP;
}
static void _resolver_getaddrinfo_start(belle_sip_simple_resolver_context_t *ctx) {
belle_sip_fd_t fd = (belle_sip_fd_t)-1;
belle_sip_object_ref(ctx);
#ifdef _WIN32
ctx->ctlevent = CreateEventEx(NULL, NULL, CREATE_EVENT_MANUAL_RESET, EVENT_ALL_ACCESS);
fd = (HANDLE)ctx->ctlevent;
#else
if (pipe(ctx->ctlpipe) == -1) {
belle_sip_fatal("pipe() failed: %s", strerror(errno));
}
fd = ctx->ctlpipe[0];
#endif
bctbx_thread_create(&ctx->getaddrinfo_thread, NULL, _resolver_getaddrinfo_thread, ctx);
ctx->getaddrinfo_source = belle_sip_fd_source_new((belle_sip_source_func_t)_resolver_getaddrinfo_callback, ctx, fd, BELLE_SIP_EVENT_READ, -1);
belle_sip_main_loop_add_source(ctx->base.stack->ml, ctx->getaddrinfo_source);
}
#endif
#ifdef HAVE_MDNS
static int is_mdns_query(const char *name){
const char *suffix;
char *tmp = NULL;
int ret;
int len = strlen(name);
if (len > 0 && name[len-1] == '.'){
tmp = belle_sip_strdup(name);
tmp[len-1] = '\0';
name = tmp;
}
/* Check if name ends with .local to determine if we'll use multicast DNS or not */
suffix = strrchr(name, '.');
ret = suffix && strcmp(suffix, ".local") == 0;
if (tmp) belle_sip_free(tmp);
return ret;
}
#endif
#ifdef HAVE_DNS_SERVICE
static void dns_service_deallocate(belle_sip_simple_resolver_context_t *ctx) {
if (ctx->dns_service_timer) {
dispatch_source_cancel(ctx->dns_service_timer);
ctx->dns_service_timer = NULL;
}
if (ctx->dns_service) {
DNSServiceRefDeallocate(ctx->dns_service);
ctx->dns_service = NULL;
}
}
static void dns_service_query_record_cb(DNSServiceRef dns_service, DNSServiceFlags flags, uint32_t interfaceIndex, DNSServiceErrorType errorCode, const char *fullname, uint16_t rrtype, uint16_t rrclass, uint16_t rdlen, const void *rdata, uint32_t ttl, void *context) {
belle_sip_simple_resolver_context_t *ctx = (belle_sip_simple_resolver_context_t *)context;
bctbx_mutex_lock(&(ctx->notify_mutex));
if (ctx->base.cancelled == TRUE) {
dns_service_deallocate(ctx);
// resolver was cancelled, we may not have the stack anymore, just unref ourselve
bctbx_mutex_unlock(&(ctx->notify_mutex));
belle_sip_object_unref(ctx);
return;
}
if (errorCode != kDNSServiceErr_NoError) {
if (errorCode == kDNSServiceErr_NoSuchRecord) {
belle_sip_message("%s : resolving %s : no such record", __FUNCTION__, fullname);
} else {
belle_sip_error("%s : resolving %s got error %d", __FUNCTION__, fullname, errorCode);
}
dns_service_deallocate(ctx);
belle_sip_main_loop_do_later(ctx->base.stack->ml, (belle_sip_callback_t)belle_sip_resolver_context_notify, BELLE_SIP_RESOLVER_CONTEXT(ctx));
bctbx_mutex_unlock(&(ctx->notify_mutex));
return;
}
if (rrclass != kDNSServiceClass_IN) {
belle_sip_error("%s : resolving %s got class %d while IN(0x01) expected", __FUNCTION__, fullname, rrclass);
dns_service_deallocate(ctx);
belle_sip_main_loop_do_later(ctx->base.stack->ml, (belle_sip_callback_t)belle_sip_resolver_context_notify, BELLE_SIP_RESOLVER_CONTEXT(ctx));
bctbx_mutex_unlock(&(ctx->notify_mutex));
return;
}
bool_t got_valid_answer = FALSE;
switch (rrtype) {
case kDNSServiceType_A :
if (rdlen == 4) {
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
memcpy(&sin.sin_addr, rdata, sizeof(sin.sin_addr));
sin.sin_family = AF_INET;
sin.sin_port = ctx->port;
append_dns_result(ctx,&ctx->ai_list,(struct sockaddr*)&sin,sizeof(sin));
if (ttl < BELLE_SIP_RESOLVER_CONTEXT(ctx)->min_ttl) BELLE_SIP_RESOLVER_CONTEXT(ctx)->min_ttl = ttl;
got_valid_answer = TRUE;
}
break;
case kDNSServiceType_AAAA :
if (rdlen == 16) {
struct sockaddr_in6 sin;
memset(&sin, 0, sizeof(sin));
memcpy(&sin.sin6_addr, rdata, sizeof(sin.sin6_addr));
sin.sin6_family = AF_INET6;
sin.sin6_port = ctx->port;
append_dns_result(ctx,&ctx->ai_list,(struct sockaddr*)&sin,sizeof(sin));
if (ttl < BELLE_SIP_RESOLVER_CONTEXT(ctx)->min_ttl) BELLE_SIP_RESOLVER_CONTEXT(ctx)->min_ttl = ttl;
got_valid_answer = TRUE;
}
break;
case kDNSServiceType_SRV :
if (rdlen > 6) {
/* re-create a DNS packet to be able to use dns_util.h dns_parse_resource_record */
/* Must add: name, type, class, ttl, rdlength before pasting the rdata to be parsed */
char *dnsPacket = belle_sip_malloc(rdlen+11);
dnsPacket[0] = 0; // name is empty: 0 length
dnsPacket[1] = 0xFF & (kDNSServiceType_SRV >> 8); // type is SRV
dnsPacket[2] = 0xFF & kDNSServiceType_SRV;
dnsPacket[3] = 0xFF & (kDNSServiceClass_IN >> 8); // Class is IN
dnsPacket[4] = 0xFF & kDNSServiceClass_IN;
dnsPacket[5] = 0x01; // ttl is not relevant, just put fixed value
dnsPacket[6] = 0x01; // ttl is not relevant, just put fixed value
dnsPacket[7] = 0x01; // ttl is not relevant, just put fixed value
dnsPacket[8] = 0x01; // ttl is not relevant, just put fixed value
dnsPacket[9] = 0xFF & (rdlen >> 8); // use the given size
dnsPacket[10] = 0xFF & rdlen;
memcpy(dnsPacket+11, rdata, rdlen);
dns_resource_record_t *rr = dns_parse_resource_record(dnsPacket, rdlen+11);
belle_sip_free(dnsPacket);
char host[NI_MAXHOST + 1];
belle_sip_dns_srv_t * b_srv=belle_sip_dns_srv_create_dns_service(rr);
snprintf(host, sizeof(host), "[target:%s port:%d prio:%d weight:%d]", b_srv->target, b_srv->port, b_srv->priority, b_srv->weight);
ctx->srv_list = belle_sip_list_insert_sorted(ctx->srv_list, belle_sip_object_ref(b_srv), srv_compare_prio);
belle_sip_message("SRV %s resolved to %s", ctx->name, host);
if (ttl < BELLE_SIP_RESOLVER_CONTEXT(ctx)->min_ttl) BELLE_SIP_RESOLVER_CONTEXT(ctx)->min_ttl = ttl;
got_valid_answer = TRUE;
}
break;
case kDNSServiceType_CNAME :
belle_sip_message("%s : resolving %s got CNAME DNS answer. Ignore it, DNS Service will recurse it by itself", __FUNCTION__, fullname);
break;
default:
belle_sip_error("%s : resolving %s got DNS answer type %d - just ignore it", __FUNCTION__, fullname, rrtype);
bctbx_mutex_unlock(&(ctx->notify_mutex));
return;
}
if (!(flags & kDNSServiceFlagsMoreComing) && (got_valid_answer==TRUE)) { // notify only when nothing more is coming and we had a valid answer
dns_service_deallocate(ctx);
belle_sip_main_loop_do_later(ctx->base.stack->ml, (belle_sip_callback_t)belle_sip_resolver_context_notify, BELLE_SIP_RESOLVER_CONTEXT(ctx));
}
bctbx_mutex_unlock(&(ctx->notify_mutex));
}
#endif /* HAVE_DNS_SERVICE */
static int _resolver_send_query(belle_sip_simple_resolver_context_t *ctx) {
int error = 0;
#ifdef HAVE_MDNS
if (is_mdns_query(ctx->name)){
ctx->not_using_dns_socket = TRUE;
_resolver_getaddrinfo_start(ctx);
return 0;
}
#endif
if (!ctx->base.stack->resolver_send_error) {
error = dns_res_submit(ctx->R, ctx->name, ctx->type, DNS_C_IN);
if (error)
belle_sip_error("%s dns_res_submit error [%s]: %s", __FUNCTION__, ctx->name, dns_strerror(error));
} else {
/* Error simulation */
error = ctx->base.stack->resolver_send_error;
belle_sip_error("%s dns_res_submit error [%s]: simulated error %d", __FUNCTION__, ctx->name, error);
}
if (error < 0) {
return -1;
}
if (resolver_process_data(ctx, 0) == BELLE_SIP_CONTINUE) {
ctx->start_time=belle_sip_time_ms();
belle_sip_message("DNS resolution awaiting response, queued to main loop");
/*only init source if res inprogress*/
/*the timeout set to the source is 1 s, this is to allow dns.c to send request retransmissions*/
belle_sip_socket_source_init((belle_sip_source_t*)ctx, (belle_sip_source_func_t)resolver_process_data, ctx, dns_res_pollfd(ctx->R), BELLE_SIP_EVENT_READ | BELLE_SIP_EVENT_TIMEOUT, 1000);
#if defined(USE_GETADDRINFO_FALLBACK)
{
int timeout = belle_sip_stack_get_dns_timeout(ctx->base.stack);
if ((timeout != 0) && ((ctx->type == DNS_T_A) || (ctx->type == DNS_T_AAAA))) {
_resolver_getaddrinfo_start(ctx);
}
}
#endif
}
return 0;
}
static int resolver_process_data_delayed(belle_sip_simple_resolver_context_t *ctx, unsigned int revents) {
int err=_resolver_send_query(ctx);
if (err==0) return BELLE_SIP_CONTINUE;
return BELLE_SIP_STOP;
}
#ifdef HAVE_MDNS
typedef struct belle_sip_mdns_source belle_sip_mdns_source_t;
#define BELLE_SIP_MDNS_SOURCE(obj) BELLE_SIP_CAST(obj,belle_sip_mdns_source_t)
struct belle_sip_mdns_source {
belle_sip_source_t base;
DNSServiceRef service_ref;
belle_sip_simple_resolver_context_t *ctx;
bool_t resolve_finished;
};
belle_sip_mdns_source_t *belle_sip_mdns_source_new(DNSServiceRef service_ref, belle_sip_simple_resolver_context_t *ctx, belle_sip_source_func_t func, int timeout) {
belle_sip_mdns_source_t *obj = belle_sip_object_new(belle_sip_mdns_source_t);
obj->service_ref = service_ref;
obj->ctx = ctx;
obj->resolve_finished = BELLE_SIP_CONTINUE;
belle_sip_fd_source_init((belle_sip_source_t*)obj
, func
, obj
, DNSServiceRefSockFD(service_ref)
, BELLE_SIP_EVENT_READ | BELLE_SIP_EVENT_TIMEOUT
, timeout);
return obj;
}
void belle_sip_mdns_source_set_service_ref(belle_sip_mdns_source_t *source, DNSServiceRef service_ref) {
source->service_ref = service_ref;
source->base.fd = DNSServiceRefSockFD(service_ref);
}
static void belle_sip_mdns_source_destroy(belle_sip_mdns_source_t *obj){
if (obj->service_ref){
DNSServiceRefDeallocate(obj->service_ref);
}
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_mdns_source_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_sip_mdns_source_t, belle_sip_source_t, belle_sip_mdns_source_destroy, NULL, NULL, TRUE);
static void resolver_process_mdns_resolve(DNSServiceRef service_ref
, DNSServiceFlags flags
, uint32_t interface
, DNSServiceErrorType error_code
, const char *fullname
, const char *hosttarget
, uint16_t port
, uint16_t txt_len
, const unsigned char *txt_record
, belle_sip_mdns_source_t *source) {
if (error_code != kDNSServiceErr_NoError) {
belle_sip_error("%s error while resolving [%s]: code %d", __FUNCTION__, source->ctx->name, error_code);
} else {
uint8_t prio_size, weight_size, ttl_size;
const char *prio_buf = TXTRecordGetValuePtr(txt_len, txt_record, "prio", &prio_size);
const char *weight_buf = TXTRecordGetValuePtr(txt_len, txt_record, "weight", &weight_size);
const char *ttl_buf = TXTRecordGetValuePtr(txt_len, txt_record, "ttl", &ttl_size);
/* If the buffer is non-NULL then the key exist and if the result size is > 0 then the value is not empty */
if (prio_buf && prio_size > 0 && weight_buf && weight_size > 0 && ttl_buf && ttl_size > 0) {
short unsigned int prio, weight, ttl;
/* Don't use the VLAs since it doesn't work on Windows */
char *prio_value = belle_sip_malloc(prio_size + 1);
char *weight_value = belle_sip_malloc(weight_size + 1);
char *ttl_value = belle_sip_malloc(ttl_size + 1);
memcpy(prio_value, prio_buf, prio_size);
memcpy(weight_value, weight_buf, weight_size);
memcpy(ttl_value, ttl_buf, ttl_size);
prio_value[prio_size] = '\0';
weight_value[weight_size] = '\0';
ttl_value[ttl_size] = '\0';
prio = atoi(prio_value);
weight = atoi(weight_value);
ttl = atoi(ttl_value);
belle_sip_dns_srv_t *b_srv = belle_sip_mdns_srv_create(prio, weight, port, hosttarget, fullname);
if (!belle_sip_list_find_custom(source->ctx->srv_list, mdns_srv_compare_host_and_port, b_srv)) {
source->ctx->srv_list = belle_sip_list_insert_sorted(source->ctx->srv_list, belle_sip_object_ref(b_srv), srv_compare_prio);
if (ttl < BELLE_SIP_RESOLVER_CONTEXT(source->ctx)->min_ttl) BELLE_SIP_RESOLVER_CONTEXT(source->ctx)->min_ttl = ttl;
belle_sip_message("mDNS %s resolved to [target:%s port:%d prio:%d weight:%d ttl:%d]", source->ctx->name, hosttarget, port, prio, weight, ttl);
} else {
belle_sip_object_unref(b_srv);
}
belle_sip_free(prio_value);
belle_sip_free(weight_value);
belle_sip_free(ttl_value);
source->resolve_finished = BELLE_SIP_STOP;
} else {
belle_sip_warning("%s TXT record of %s does not contain a priority, weight or ttl key!", __FUNCTION__, hosttarget);
}
}
source->ctx->resolving--;
/* If this is the last resolve and the browse has already timed out then we notify */
if (source->ctx->resolving == 0 && source->ctx->browse_finished)
belle_sip_resolver_context_notify(BELLE_SIP_RESOLVER_CONTEXT(source->ctx));
}
static int resolver_process_mdns_resolve_result(belle_sip_mdns_source_t *source, unsigned int revents) {
if (revents & BELLE_SIP_EVENT_READ) {
DNSServiceProcessResult(source->service_ref);
}
if (revents & BELLE_SIP_EVENT_TIMEOUT) return BELLE_SIP_STOP;
return source->resolve_finished;
}
static void resolver_process_mdns_browse(DNSServiceRef service_ref
, DNSServiceFlags flags
, uint32_t interface
, DNSServiceErrorType error_code
, const char *name
, const char *type
, const char *domain
, belle_sip_simple_resolver_context_t *ctx) {
if (error_code != kDNSServiceErr_NoError) {
belle_sip_error("%s error while browing [%s]: code %d", __FUNCTION__, ctx->name, error_code);
} else {
if (flags & kDNSServiceFlagsAdd) {
DNSServiceRef resolve_ref;
DNSServiceErrorType error;
belle_sip_mdns_source_t *source = belle_sip_mdns_source_new(NULL, ctx, (belle_sip_source_func_t)resolver_process_mdns_resolve_result, 1000);
error = DNSServiceResolve(&resolve_ref, 0, interface, name, type, domain, (DNSServiceResolveReply)resolver_process_mdns_resolve, source);
if (error == kDNSServiceErr_NoError) {
ctx->resolving++;
belle_sip_mdns_source_set_service_ref(source, resolve_ref);
belle_sip_main_loop_add_source(ctx->base.stack->ml, (belle_sip_source_t*)source);
} else {
belle_sip_error("%s DNSServiceResolve error [%s]: code %d", __FUNCTION__, ctx->name, error);
belle_sip_object_unref(source);
}
} else {
belle_sip_list_t *elem;
char fullname[512];
/* If the browse service does not have the Add flags then it has to be removed */
snprintf(fullname, sizeof(fullname), "%s.%s%s", name, type, domain);
belle_sip_dns_srv_t *b_srv = belle_sip_mdns_srv_create(-1, -1, -1, NULL, fullname);
elem = belle_sip_list_find_custom(ctx->srv_list, mdns_srv_compare_fullname, b_srv);
if (elem) {
belle_sip_object_unref((belle_sip_dns_srv_t *)elem->data);
ctx->srv_list = belle_sip_list_delete_link(ctx->srv_list, elem);
}
belle_sip_object_unref(b_srv);
}
}
}
static int resolver_process_mdns_browse_result(belle_sip_mdns_source_t *source, unsigned int revents) {
if (revents & BELLE_SIP_EVENT_READ) {
DNSServiceProcessResult(source->service_ref);
}
if (revents & BELLE_SIP_EVENT_TIMEOUT) {
if (source->ctx->resolving == 0)
belle_sip_resolver_context_notify(BELLE_SIP_RESOLVER_CONTEXT(source->ctx));
source->ctx->browse_finished = TRUE;
return BELLE_SIP_STOP;
}
return BELLE_SIP_CONTINUE;
}
#endif
static int _resolver_start_query(belle_sip_simple_resolver_context_t *ctx) {
if (!ctx->name) return -1;
#ifdef HAVE_DNS_SERVICE
if (ctx->base.use_dns_service == TRUE ) {
// Take a ref on the context so we are sure it will still exists when the notify is called
// When returning an error, the notify is called anyway so do not unref, the matching unref
// is always performed in the belle_sip_resolver_context_notify function or directly in the callback
// when the resolve has been cancelled
belle_sip_object_ref(ctx);
/* Create the DNSServiceRef */
DNSServiceErrorType err = kDNSServiceErr_NoError;
err = DNSServiceQueryRecord(
&(ctx->dns_service),
kDNSServiceFlagsReturnIntermediates,
0, // interfaceIndex
ctx->name,
ctx->dns_service_type,
kDNSServiceClass_IN,
dns_service_query_record_cb,
(void *)ctx);
if (err != kDNSServiceErr_NoError) {
belle_sip_error("DNS query resolving %s, DNSServiceQueryRecord returned %d", ctx->name, err);
return -1;
}
/* Create a timer */
ctx->dns_service_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, ctx->dns_service_queue);
int timeout = belle_sip_stack_get_dns_timeout(ctx->base.stack); // timeout is in ms
dispatch_source_set_event_handler(ctx->dns_service_timer, ^{ // block captures ctx
bctbx_mutex_lock(&(ctx->notify_mutex));
dns_service_deallocate(ctx); /* disarm timer - we need it once and deallocate the query */
if (ctx->base.cancelled == TRUE) {
// resolver was cancelled, we may not have the stack anymore, just unref ourselve
bctbx_mutex_unlock(&(ctx->notify_mutex));
belle_sip_object_unref(ctx);
return;
}
belle_sip_message("DNS timer fired while resolving %s ", ctx->name);
belle_sip_main_loop_do_later(ctx->base.stack->ml, (belle_sip_callback_t)belle_sip_resolver_context_notify, BELLE_SIP_RESOLVER_CONTEXT(ctx));
bctbx_mutex_unlock(&(ctx->notify_mutex));
});
/* dispatch them */
if (!ctx->base.stack->resolver_send_error) {
dispatch_sync(ctx->dns_service_queue, ^{ // disptach them from the queue listening their events to avoid troubles, this block captures the ctx
bctbx_mutex_lock(&(ctx->notify_mutex));
dispatch_source_set_timer(ctx->dns_service_timer, dispatch_time(DISPATCH_TIME_NOW,timeout*NSEC_PER_MSEC), timeout*NSEC_PER_MSEC, 0); // timeout given is in Nano seconds
dispatch_resume(ctx->dns_service_timer);
ctx->err = DNSServiceSetDispatchQueue(ctx->dns_service, ctx->dns_service_queue); // could return an error to be passed back to the main thread
if (ctx->err != kDNSServiceErr_NoError) {
dns_service_deallocate(ctx); /* failed to dispatch, deallocate and disarm timer(which may already have fired) */
}
bctbx_mutex_unlock(&(ctx->notify_mutex));
});
if (ctx->err != kDNSServiceErr_NoError) {
belle_sip_message("DNS start_query resolving %s, DNSServiceSetDispatchQueue returned %d", ctx->name, err);
return -1;
}
} else {
/* Error simulation */
belle_sip_error("%s DNSServiceRefSockFD error [%s]: simulated error %d", __FUNCTION__, ctx->name, ctx->base.stack->resolver_send_error);
return -1;
}
return 0;
}
#endif /* HAVE_DNS_SERVICE */
#ifdef HAVE_MDNS
if (is_mdns_query(ctx->name) && ctx->type == DNS_T_SRV) {
DNSServiceErrorType error;
DNSServiceRef browse_ref;
error = DNSServiceBrowse(&browse_ref, 0, 0, ctx->srv_prefix, ctx->srv_name, (DNSServiceBrowseReply)resolver_process_mdns_browse, ctx);
if (error == kDNSServiceErr_NoError) {
belle_sip_mdns_source_t *source = belle_sip_mdns_source_new(browse_ref, ctx, (belle_sip_source_func_t)resolver_process_mdns_browse_result, 1000);
belle_sip_main_loop_add_source(ctx->base.stack->ml, (belle_sip_source_t*)source);
return 0;
} else {
belle_sip_error("%s DNSServiceBrowse error [%s]: code %d", __FUNCTION__, ctx->name, error);
return -1;
}
} else {
#endif
struct dns_options opts;
int error;
struct dns_resolv_conf *conf;
conf=resconf(ctx);
if (conf){
conf->options.recurse = 0;
conf->options.timeout=2;
conf->options.attempts=5;
}else
return -1;
if (!hosts(ctx))
return -1;
memset(&opts, 0, sizeof opts);
/* When there are IPv6 nameservers, allow responses to arrive from an IP address that is not the IP address to which the request was sent originally.
* Mac' NAT64 network tend to do this sometimes.*/
opts.udp_uses_connect = ctx->resconf->iface.ss_family != AF_INET6;
if (!opts.udp_uses_connect) belle_sip_message("Resolver is not using connect().");
if (!(ctx->R = dns_res_open(ctx->resconf, ctx->hosts, dns_hints_mortal(dns_hints_local(ctx->resconf, &error)), cache(ctx), &opts, &error))) {
belle_sip_error("%s dns_res_open error [%s]: %s", __FUNCTION__, ctx->name, dns_strerror(error));
return -1;
}
error=0;
if (ctx->base.stack->resolver_tx_delay > 0) {
belle_sip_socket_source_init((belle_sip_source_t*)ctx, (belle_sip_source_func_t)resolver_process_data_delayed, ctx, -1, BELLE_SIP_EVENT_TIMEOUT, ctx->base.stack->resolver_tx_delay + 1000);
belle_sip_message("%s DNS resolution delayed by %d ms", __FUNCTION__, ctx->base.stack->resolver_tx_delay);
} else {
error=_resolver_send_query(ctx);
}
if (error==0 && !ctx->base.notified && !ctx->not_using_dns_socket) belle_sip_main_loop_add_source(ctx->base.stack->ml,(belle_sip_source_t*)ctx);
return error;
#ifdef HAVE_MDNS
}
#endif
}
static belle_sip_simple_resolver_context_t * resolver_start_query(belle_sip_simple_resolver_context_t *ctx) {
int error;
/* Take a ref for this part of code because _resolver_start_query() can notify the results and free the ctx if this is not the case. */
belle_sip_object_ref(ctx);
error = _resolver_start_query(ctx);
if (error == 0) {
if (!ctx->base.notified) {
/* The resolution could not be done synchronously, return the context */
belle_sip_object_unref(ctx);
return ctx;
}
/* Otherwise, resolution could be done synchronously */
} else {
/* An error occured. We must notify the app. */
belle_sip_resolver_context_notify(BELLE_SIP_RESOLVER_CONTEXT(ctx));
}
belle_sip_object_unref(ctx);
return NULL;
}
static void belle_sip_combined_resolver_context_destroy(belle_sip_combined_resolver_context_t *obj){
if (obj->name != NULL) {
belle_sip_free(obj->name);
obj->name = NULL;
}
if (obj->srv_ctx){
belle_sip_object_unref(obj->srv_ctx);
obj->srv_ctx=NULL;
}
if (obj->a_fallback_ctx){
belle_sip_object_unref(obj->a_fallback_ctx);
obj->a_fallback_ctx=NULL;
}
if (obj->a_fallback_results){
/* we don't a/aaaa results since SRV provided results*/
bctbx_freeaddrinfo(obj->a_fallback_results);
obj->a_fallback_results = NULL;
}
}
static void belle_sip_simple_resolver_context_destroy(belle_sip_simple_resolver_context_t *ctx){
/* Do not free elements of ctx->ai_list with bctbx_freeaddrinfo(). Let the caller do it, otherwise
it will not be able to use them after the resolver has been destroyed. */
#if defined(USE_GETADDRINFO_FALLBACK) || defined(HAVE_MDNS)
if (ctx->getaddrinfo_thread != 0) {
bctbx_thread_join(ctx->getaddrinfo_thread, NULL);
#ifdef _WIN32
if (ctx->ctlevent != (belle_sip_fd_t)-1)
CloseHandle(ctx->ctlevent);
#else
close(ctx->ctlpipe[0]);
close(ctx->ctlpipe[1]);
#endif
}
if (ctx->getaddrinfo_source) belle_sip_object_unref(ctx->getaddrinfo_source);
#endif
if (ctx->ai_list != NULL) {
bctbx_freeaddrinfo(ctx->ai_list);
ctx->ai_list = NULL;
}
#if defined(USE_GETADDRINFO_FALLBACK) || defined(HAVE_MDNS)
if (ctx->getaddrinfo_ai_list != NULL) {
bctbx_freeaddrinfo(ctx->getaddrinfo_ai_list);
ctx->getaddrinfo_ai_list = NULL;
}
#endif
if (ctx->name != NULL) {
belle_sip_free(ctx->name);
ctx->name = NULL;
}
#ifdef HAVE_DNS_SERVICE
if (ctx->base.use_dns_service == TRUE) {
// deallocate the query and disarm timer on the dns service thread
if (ctx->dns_service != NULL || ctx->dns_service_timer != NULL) { // make sure we do not call this if we are in the dns thread
dispatch_sync(ctx->dns_service_queue, ^{
dns_service_deallocate(ctx);
});
}
// Cancel might not deallocate results when they arrive after the cancel, make sure they are
if (ctx->base.cancelled == TRUE) {
if (ctx->srv_list != NULL) {
bctbx_list_free_with_data(ctx->srv_list, belle_sip_object_unref);
ctx->srv_list = NULL;
}
}
bctbx_mutex_destroy(&ctx->notify_mutex);
dispatch_release(ctx->dns_service_queue);
}
#endif /* HAVE_DNS_SERVICE */
if (ctx->R != NULL) {
dns_res_close(ctx->R);
ctx->R = NULL;
}
if (ctx->hosts != NULL) {
dns_hosts_close(ctx->hosts);
ctx->hosts = NULL;
}
if (ctx->resconf != NULL) {
free(ctx->resconf);
ctx->resconf = NULL;
}
#ifdef HAVE_MDNS
if (ctx->srv_prefix) {
belle_sip_free(ctx->srv_prefix);
ctx->srv_prefix = NULL;
}
if (ctx->srv_name) {
belle_sip_free(ctx->srv_name);
ctx->srv_name = NULL;
}
#endif
}
static void belle_sip_dual_resolver_context_destroy(belle_sip_dual_resolver_context_t *obj){
if (obj->a_ctx){
belle_sip_object_unref(obj->a_ctx);
obj->a_ctx=NULL;
}
if (obj->aaaa_ctx){
belle_sip_object_unref(obj->aaaa_ctx);
obj->aaaa_ctx=NULL;
}
if (obj->a_results){
bctbx_freeaddrinfo(obj->a_results);
obj->a_results=NULL;
}
if (obj->aaaa_results){
bctbx_freeaddrinfo(obj->aaaa_results);
obj->aaaa_results=NULL;
}
if (obj->name){
belle_sip_free(obj->name);
obj->name=NULL;
}
}
static void simple_resolver_context_cancel(belle_sip_resolver_context_t *obj) {
belle_sip_main_loop_remove_source(obj->stack->ml, (belle_sip_source_t *)obj);
}
static void combined_resolver_context_cancel(belle_sip_resolver_context_t *obj) {
belle_sip_combined_resolver_context_t *ctx = BELLE_SIP_COMBINED_RESOLVER_CONTEXT(obj);
bctbx_list_t *elem;
for(elem=ctx->srv_results;elem!=NULL;elem=elem->next){
belle_sip_dns_srv_t *srv=(belle_sip_dns_srv_t*)elem->data;
if (srv->a_resolver){
belle_sip_resolver_context_cancel(srv->a_resolver);
belle_sip_object_unref(srv->a_resolver);
srv->a_resolver = NULL;
}
}
if (ctx->srv_ctx) {
belle_sip_resolver_context_cancel(ctx->srv_ctx);
belle_sip_object_unref(ctx->srv_ctx);
ctx->srv_ctx = NULL;
}
if (ctx->a_fallback_ctx) {
belle_sip_resolver_context_cancel(ctx->a_fallback_ctx);
belle_sip_object_unref(ctx->a_fallback_ctx);
ctx->a_fallback_ctx = NULL;
}
combined_resolver_context_cleanup(ctx);
}
static void dual_resolver_context_cancel(belle_sip_resolver_context_t *obj) {
belle_sip_dual_resolver_context_t *ctx= BELLE_SIP_DUAL_RESOLVER_CONTEXT(obj);
if (ctx->a_ctx) {
belle_sip_resolver_context_cancel(ctx->a_ctx);
belle_sip_object_unref(ctx->a_ctx);
ctx->a_ctx = NULL;
}
if (ctx->aaaa_ctx) {
belle_sip_resolver_context_cancel(ctx->aaaa_ctx);
belle_sip_object_unref(ctx->aaaa_ctx);
ctx->aaaa_ctx = NULL;
}
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_resolver_context_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_resolver_context_t)
{
BELLE_SIP_VPTR_INIT(belle_sip_resolver_context_t,belle_sip_source_t,TRUE),
(belle_sip_object_destroy_t) NULL,
NULL,
NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
NULL
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_simple_resolver_context_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_simple_resolver_context_t)
{
{
BELLE_SIP_VPTR_INIT(belle_sip_simple_resolver_context_t,belle_sip_resolver_context_t,TRUE),
(belle_sip_object_destroy_t) belle_sip_simple_resolver_context_destroy,
NULL,
NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
simple_resolver_context_cancel,
simple_resolver_context_notify
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_dual_resolver_context_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_dual_resolver_context_t)
{
{
BELLE_SIP_VPTR_INIT(belle_sip_dual_resolver_context_t,belle_sip_resolver_context_t,TRUE),
(belle_sip_object_destroy_t) belle_sip_dual_resolver_context_destroy,
NULL,
NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
dual_resolver_context_cancel,
dual_resolver_context_notify
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_combined_resolver_context_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_combined_resolver_context_t)
{
{
BELLE_SIP_VPTR_INIT(belle_sip_combined_resolver_context_t,belle_sip_resolver_context_t,TRUE),
(belle_sip_object_destroy_t) belle_sip_combined_resolver_context_destroy,
NULL,
NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
combined_resolver_context_cancel,
combined_resolver_context_notify
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
static char * srv_prefix_from_service_and_transport(const char *service, const char *transport) {
if (service == NULL) service = "sip";
if (strcasecmp(transport, "udp") == 0) {
return belle_sip_strdup_printf("_%s._udp.", service);
} else if (strcasecmp(transport, "tcp") == 0) {
return belle_sip_strdup_printf("_%s._tcp.", service);
} else if (strcasecmp(transport, "tls") == 0) {
return belle_sip_strdup_printf("_%ss._tcp.", service);
}
return belle_sip_strdup_printf("_%s._udp.", service);
}
static void combined_resolver_context_check_finished(belle_sip_combined_resolver_context_t *obj, uint32_t ttl){
belle_sip_list_t *elem;
struct addrinfo *final=NULL;
if (ttl < BELLE_SIP_RESOLVER_CONTEXT(obj)->min_ttl) BELLE_SIP_RESOLVER_CONTEXT(obj)->min_ttl = ttl;
if (!obj->srv_completed && obj->srv_results){
unsigned char finished = TRUE;
for(elem=obj->srv_results;elem!=NULL;elem=elem->next){
belle_sip_dns_srv_t *srv=(belle_sip_dns_srv_t*)elem->data;
if (!srv->a_done) {
finished=FALSE;
break;
}
}
if (finished){
belle_sip_message("All A/AAAA results for combined resolution have arrived.");
obj->srv_completed = TRUE;
for(elem=obj->srv_results;elem!=NULL;elem=elem->next){
belle_sip_dns_srv_t *srv=(belle_sip_dns_srv_t*)elem->data;
final=ai_list_append(final,srv->a_results);
srv->dont_free_a_results = TRUE;
}
obj->final_results=final;
}
}
if (obj->srv_completed && obj->a_fallback_completed){
if (obj->final_results == NULL){
/* No SRV results, use a/aaaa fallback */
obj->final_results = obj->a_fallback_results;
obj->base.min_ttl = obj->a_fallback_ttl;
obj->a_fallback_results = NULL;
}
belle_sip_resolver_context_notify(BELLE_SIP_RESOLVER_CONTEXT(obj));
}
}
static int combined_resolver_srv_timeout(belle_sip_combined_resolver_context_t *ctx){
belle_sip_message("No SRV results while A/AAAA fallback resulted arrived a while ago. Giving up SRV.");
if (ctx->srv_ctx) {
belle_sip_resolver_context_cancel(ctx->srv_ctx);
belle_sip_object_unref(ctx->srv_ctx);
ctx->srv_ctx = NULL;
}
ctx->srv_completed = TRUE;
combined_resolver_context_check_finished(ctx, BELLE_SIP_RESOLVER_CONTEXT(ctx)->min_ttl);
return BELLE_SIP_STOP;
}
static void process_a_fallback_result(void *data, belle_sip_resolver_results_t *results){
belle_sip_combined_resolver_context_t *ctx=(belle_sip_combined_resolver_context_t *)data;
ctx->a_fallback_results = results->ai_list;
results->ai_list = NULL;
ctx->a_fallback_ttl = results->ttl;
ctx->a_fallback_completed = TRUE;
/*
* Start a global timer in order to workaround buggy home routers that don't respond to SRV requests.
* If A fallback response arrived, SRV shall not take a lot longer.
*/
belle_sip_message("resolver[%p]: starting SRV timer since A/AAAA fallback response is received.", ctx);
belle_sip_socket_source_init((belle_sip_source_t*)ctx, (belle_sip_source_func_t)combined_resolver_srv_timeout, ctx, -1 , BELLE_SIP_EVENT_TIMEOUT,
belle_sip_srv_timeout_after_a_received);
belle_sip_main_loop_add_source(ctx->base.stack->ml, (belle_sip_source_t*)ctx);
combined_resolver_context_check_finished(ctx, ctx->base.min_ttl);
}
static void process_a_from_srv(void *data, belle_sip_resolver_results_t *results){
belle_sip_dns_srv_t *srv=(belle_sip_dns_srv_t*)data;
srv->a_results = results->ai_list;
results->ai_list = NULL;
srv->a_done=TRUE;
belle_sip_message("A query finished for srv result [%s]",srv->target);
if (results->ttl < BELLE_SIP_RESOLVER_CONTEXT(srv->root_resolver)->min_ttl) BELLE_SIP_RESOLVER_CONTEXT(srv->root_resolver)->min_ttl = results->ttl;
combined_resolver_context_check_finished(srv->root_resolver, results->ttl);
}
static void srv_resolve_a(belle_sip_combined_resolver_context_t *obj, belle_sip_dns_srv_t *srv){
belle_sip_message("Starting A/AAAA query for srv result [%s]",srv->target);
srv->root_resolver=obj;
/* take a ref of the srv object because the A resolution may terminate synchronously and destroy the srv
object before to store the returned value of belle_sip_stack_resolve_a(). That would lead to an invalid write */
belle_sip_object_ref(srv);
srv->a_resolver=belle_sip_stack_resolve_a(obj->base.stack,srv->target,srv->port,obj->family,process_a_from_srv,srv);
if (srv->a_resolver){
belle_sip_object_ref(srv->a_resolver);
}
belle_sip_object_unref(srv);
}
static void process_srv_results(void *data, const char *name, belle_sip_list_t *srv_results, uint32_t ttl){
belle_sip_combined_resolver_context_t *ctx=(belle_sip_combined_resolver_context_t *)data;
/*take a ref here, because the A resolution might succeed synchronously and terminate the context before exiting this function*/
if (ctx->base.stack->simulate_non_working_srv) {
belle_sip_list_free_with_data(srv_results, belle_sip_object_unref);
belle_sip_message("SRV results ignored for testing.");
return;
}
belle_sip_object_ref(ctx);
if (ttl < BELLE_SIP_RESOLVER_CONTEXT(data)->min_ttl) BELLE_SIP_RESOLVER_CONTEXT(data)->min_ttl = ttl;
if (srv_results){
belle_sip_list_t *elem;
/* take a ref of each srv_results because the last A resolution may terminate synchronously
and destroy the list before the loop terminate */
ctx->srv_results = belle_sip_list_copy(srv_results);
belle_sip_list_for_each(srv_results, (void(*)(void *))belle_sip_object_ref);
for(elem=srv_results;elem!=NULL;elem=elem->next){
belle_sip_dns_srv_t *srv=(belle_sip_dns_srv_t*)elem->data;
srv_resolve_a(ctx,srv);
}
srv_results = belle_sip_list_free_with_data(srv_results, belle_sip_object_unref);
/* Since we have SRV results, we can cancel the srv timeout, and cancel the fallback a/aaaa resolution */
belle_sip_source_cancel((belle_sip_source_t*)ctx);
if (ctx->a_fallback_ctx){
ctx->a_fallback_completed = TRUE; /* we don't need a/aaaa fallback anymore.*/
belle_sip_resolver_context_cancel(ctx->a_fallback_ctx);
belle_sip_object_unref(ctx->a_fallback_ctx);
ctx->a_fallback_ctx = NULL;
}
}else{
/* No SRV result. Possibly notify the a/aaaa fallback if already arrived*/
ctx->srv_completed = TRUE;
combined_resolver_context_check_finished(ctx, ctx->base.min_ttl);
}
belle_sip_object_unref(ctx);
}
/**
* Perform combined SRV + A / AAAA resolution.
**/
belle_sip_resolver_context_t * belle_sip_stack_resolve(belle_sip_stack_t *stack, const char *service, const char *transport, const char *name, int port, int family, belle_sip_resolver_callback_t cb, void *data) {
struct addrinfo *res = bctbx_ip_address_to_addrinfo(family, SOCK_STREAM, name, port);
if (res == NULL) {
/* First perform asynchronous DNS SRV query */
belle_sip_combined_resolver_context_t *ctx = belle_sip_object_new(belle_sip_combined_resolver_context_t);
belle_sip_resolver_context_init((belle_sip_resolver_context_t*)ctx,stack);
belle_sip_object_ref(ctx);/*we don't want the object to be destroyed until the end of this function*/
ctx->cb=cb;
ctx->cb_data = data;
ctx->name = belle_sip_strdup(name);
ctx->port=port;
belle_sip_object_set_name((belle_sip_object_t*)ctx, ctx->name);
if (family == 0) family = AF_UNSPEC;
ctx->family = family;
/* Take a ref for the entire duration of the DNS procedure, it will be released when it is finished */
belle_sip_object_ref(ctx);
ctx->srv_ctx=belle_sip_stack_resolve_srv(stack,service,transport,name,process_srv_results,ctx);
if (ctx->srv_ctx) {
belle_sip_object_ref(ctx->srv_ctx);
}
/*In parallel and in case of no SRV result, perform A query */
ctx->a_fallback_ctx=belle_sip_stack_resolve_a(ctx->base.stack,ctx->name,ctx->port,ctx->family,process_a_fallback_result,ctx);
if (ctx->a_fallback_ctx) belle_sip_object_ref(ctx->a_fallback_ctx);
if (ctx->base.notified) {
belle_sip_object_unref(ctx);
return NULL;
}
belle_sip_object_unref(ctx);
return BELLE_SIP_RESOLVER_CONTEXT(ctx);
} else {
/* There is no resolution to be done */
belle_sip_resolver_results_t *results = belle_sip_resolver_results_create(name, res, NULL, UINT32_MAX);
cb(data, results);
belle_sip_object_unref(results);
return NULL;
}
}
static belle_sip_resolver_context_t * belle_sip_stack_resolve_single(belle_sip_stack_t *stack, const char *name, int port, int family, int flags, belle_sip_resolver_callback_t cb , void *data){
/* Then perform asynchronous DNS A or AAAA query */
belle_sip_simple_resolver_context_t *ctx = belle_sip_object_new(belle_sip_simple_resolver_context_t);
belle_sip_resolver_context_init((belle_sip_resolver_context_t*)ctx,stack);
ctx->cb_data = data;
ctx->cb = cb;
ctx->name = belle_sip_strdup(name);
ctx->port = port;
ctx->flags = flags;
belle_sip_object_set_name((belle_sip_object_t*)ctx, ctx->name);
/* Take a ref for the entire duration of the DNS procedure, it will be released when it is finished */
belle_sip_object_ref(ctx);
if (family == 0) family = AF_UNSPEC;
ctx->family = family;
#ifdef HAVE_DNS_SERVICE
ctx->dns_service_queue = stack->dns_service_queue;
dispatch_retain(ctx->dns_service_queue); // take a ref on the dispatch queue
ctx->dns_service_type = (ctx->family == AF_INET6) ? kDNSServiceType_AAAA : kDNSServiceType_A;
if (stack->use_dns_service == TRUE) {
bctbx_mutex_init(&ctx->notify_mutex,NULL);
}
#endif /* HAVE_DNS_SERVICE */
ctx->type = (ctx->family == AF_INET6) ? DNS_T_AAAA : DNS_T_A;
#if (defined(USE_GETADDRINFO_FALLBACK) || defined(HAVE_MDNS)) && defined(_WIN32)
ctx->ctlevent = (belle_sip_fd_t)-1;
#endif
return (belle_sip_resolver_context_t*)resolver_start_query(ctx);
}
static uint8_t belle_sip_resolver_context_can_be_cancelled(belle_sip_resolver_context_t *obj) {
return ((obj->cancelled == TRUE) || (obj->notified == TRUE)) ? FALSE : TRUE;
}
#define belle_sip_resolver_context_can_be_notified(obj) belle_sip_resolver_context_can_be_cancelled(obj)
static void dual_resolver_context_check_finished(belle_sip_dual_resolver_context_t *ctx) {
if (belle_sip_resolver_context_can_be_notified(BELLE_SIP_RESOLVER_CONTEXT(ctx)) && (ctx->a_notified == TRUE) && (ctx->aaaa_notified == TRUE)) {
belle_sip_resolver_context_notify(BELLE_SIP_RESOLVER_CONTEXT(ctx));
}
}
static int dual_resolver_aaaa_timeout(void *data, unsigned int event){
belle_sip_dual_resolver_context_t *ctx = BELLE_SIP_DUAL_RESOLVER_CONTEXT(data);
/*
* It is too late to receive the AAAA query, so give up, and notify the A result we have already.
*/
if (ctx->aaaa_ctx){
belle_sip_resolver_context_cancel(ctx->aaaa_ctx);
belle_sip_object_unref(ctx->aaaa_ctx);
ctx->aaaa_ctx = NULL;
}
ctx->aaaa_notified = TRUE;
dual_resolver_context_check_finished(ctx);
return BELLE_SIP_STOP;
}
static void on_ipv4_results(void *data, belle_sip_resolver_results_t *results) {
belle_sip_dual_resolver_context_t *ctx = BELLE_SIP_DUAL_RESOLVER_CONTEXT(data);
ctx->a_results = results->ai_list;
results->ai_list = NULL;
ctx->a_notified = TRUE;
if (!ctx->aaaa_notified && ctx->a_results && belle_sip_aaaa_timeout_after_a_received > 0){
/*
* Start a global timer in order to workaround buggy home routers that don't respond to AAAA requests when there is no
* corresponding AAAA record for the queried domain. It is only started if we have a A result.
*/
belle_sip_message("resolver[%p]: starting aaaa timeout since A response is received.", ctx);
belle_sip_socket_source_init((belle_sip_source_t*)ctx, (belle_sip_source_func_t)dual_resolver_aaaa_timeout, ctx, -1 , BELLE_SIP_EVENT_TIMEOUT,
belle_sip_aaaa_timeout_after_a_received);
belle_sip_main_loop_add_source(ctx->base.stack->ml, (belle_sip_source_t*)ctx);
}
dual_resolver_context_check_finished(ctx);
}
static void on_ipv6_results(void *data, belle_sip_resolver_results_t *results) {
belle_sip_dual_resolver_context_t *ctx = BELLE_SIP_DUAL_RESOLVER_CONTEXT(data);
ctx->aaaa_results = results->ai_list;
results->ai_list = NULL;
ctx->aaaa_notified = TRUE;
if (ctx->a_notified){
/* Cancel the aaaa timeout.*/
belle_sip_source_cancel((belle_sip_source_t*)ctx);
}
dual_resolver_context_check_finished(ctx);
}
static belle_sip_resolver_context_t * belle_sip_stack_resolve_dual(belle_sip_stack_t *stack, const char *name, int port, belle_sip_resolver_callback_t cb , void *data){
/* Then perform asynchronous DNS A or AAAA query */
belle_sip_dual_resolver_context_t *ctx = belle_sip_object_new(belle_sip_dual_resolver_context_t);
belle_sip_resolver_context_init((belle_sip_resolver_context_t*)ctx,stack);
belle_sip_object_ref(ctx);/*we don't want the object to be destroyed until the end of this function*/
ctx->cb_data = data;
ctx->cb = cb;
ctx->name = belle_sip_strdup(name);
belle_sip_object_set_name((belle_sip_object_t*)ctx, ctx->name);
/* Take a ref for the entire duration of the DNS procedure, it will be released when it is finished */
belle_sip_object_ref(ctx);
ctx->a_ctx=belle_sip_stack_resolve_single(stack,name,port,AF_INET, AI_V4MAPPED, on_ipv4_results,ctx);
if (ctx->a_ctx) belle_sip_object_ref(ctx->a_ctx);
ctx->aaaa_ctx=belle_sip_stack_resolve_single(stack, name, port, AF_INET6, 0, on_ipv6_results, ctx);
if (ctx->aaaa_ctx) belle_sip_object_ref(ctx->aaaa_ctx);
if (ctx->base.notified){
/* All results were found synchronously */
belle_sip_object_unref(ctx);
ctx = NULL;
} else belle_sip_object_unref(ctx);
return BELLE_SIP_RESOLVER_CONTEXT(ctx);
}
belle_sip_resolver_context_t * belle_sip_stack_resolve_a(belle_sip_stack_t *stack, const char *name, int port, int family, belle_sip_resolver_callback_t cb , void *data) {
struct addrinfo *res = bctbx_ip_address_to_addrinfo(family, SOCK_STREAM, name, port);
if (res == NULL) {
switch(family){
case AF_UNSPEC:
family=AF_INET6;
BCTBX_NO_BREAK; /*intentionally no break*/
case AF_INET6:
return belle_sip_stack_resolve_dual(stack,name,port,cb,data);
break;
case AF_INET:
return belle_sip_stack_resolve_single(stack,name,port,AF_INET,0,cb,data);
break;
default:
belle_sip_error("belle_sip_stack_resolve_a(): unsupported address family [%i]",family);
}
} else {
/* There is no resolution to be done */
belle_sip_resolver_results_t *results = belle_sip_resolver_results_create(name, res, NULL, UINT32_MAX);
cb(data, results);
belle_sip_object_unref(results);
}
return NULL;
}
belle_sip_resolver_context_t * belle_sip_stack_resolve_srv(belle_sip_stack_t *stack, const char *service, const char *transport, const char *name, belle_sip_resolver_srv_callback_t cb, void *data) {
belle_sip_simple_resolver_context_t *ctx = belle_sip_object_new(belle_sip_simple_resolver_context_t);
char *srv_prefix = srv_prefix_from_service_and_transport(service, transport);
belle_sip_resolver_context_init((belle_sip_resolver_context_t*)ctx,stack);
ctx->srv_cb_data = data;
ctx->srv_cb = cb;
#ifdef HAVE_MDNS
ctx->srv_prefix = belle_sip_strdup(srv_prefix);
ctx->srv_name = belle_sip_strdup(name);
ctx->resolving = 0;
ctx->browse_finished = FALSE;
#endif
ctx->name = belle_sip_concat(srv_prefix, name, NULL);
#ifdef HAVE_DNS_SERVICE
ctx->dns_service_queue = stack->dns_service_queue;
dispatch_retain(ctx->dns_service_queue); // take a ref on the dispatch queue
ctx->dns_service_type = kDNSServiceType_SRV;
if (stack->use_dns_service == TRUE) {
bctbx_mutex_init(&ctx->notify_mutex,NULL);
}
#endif /* HAVE_DNS_SERVICE */
ctx->type = DNS_T_SRV;
belle_sip_object_set_name((belle_sip_object_t*)ctx, ctx->name);
/* Take a ref for the entire duration of the DNS procedure, it will be released when it is finished */
belle_sip_object_ref(ctx);
belle_sip_free(srv_prefix);
return (belle_sip_resolver_context_t*)resolver_start_query(ctx);
}
void belle_sip_resolver_context_cancel(belle_sip_resolver_context_t *obj) {
#ifdef HAVE_DNS_SERVICE
bctbx_mutex_t *notify_mutex = NULL;
if ((obj->use_dns_service == TRUE) && (BELLE_SIP_OBJECT_IS_INSTANCE_OF(obj, belle_sip_simple_resolver_context_t) == TRUE)) {
notify_mutex = &(BELLE_SIP_SIMPLE_RESOLVER_CONTEXT(obj)->notify_mutex);
bctbx_mutex_lock(notify_mutex);
}
#endif /* HAVE_DNS_SERVICE */
if (belle_sip_resolver_context_can_be_cancelled(obj)) {
obj->cancelled = TRUE;
BELLE_SIP_OBJECT_VPTR(obj, belle_sip_resolver_context_t)->cancel(obj);
#ifdef HAVE_DNS_SERVICE
if (notify_mutex != NULL) {
bctbx_mutex_unlock(notify_mutex);
}
#endif /* HAVE_DNS_SERVICE */
belle_sip_object_unref(obj);
}
#ifdef HAVE_DNS_SERVICE
else {
if (notify_mutex != NULL) {
bctbx_mutex_unlock(notify_mutex);
}
}
#endif /* HAVE_DNS_SERVICE */
}
void belle_sip_resolver_context_notify(belle_sip_resolver_context_t *obj) {
#ifdef HAVE_DNS_SERVICE
/* When using DNS Service, a ref is taken in simple resolver to ensure
* the context is always present if a notify rises after a cancel
* Check before performing the actual notify if we must unref it
* as the notify may destroy the object (when the resolver is not simple
* and unref after the notify if needed */
bool_t unref_me = ((obj->use_dns_service == TRUE) && (BELLE_SIP_OBJECT_IS_INSTANCE_OF(obj, belle_sip_simple_resolver_context_t) == TRUE));
#endif /* HAVE_DNS_SERVICE */
if (belle_sip_resolver_context_can_be_notified(obj)) {
obj->notified = TRUE;
BELLE_SIP_OBJECT_VPTR(obj, belle_sip_resolver_context_t)->notify(obj);
belle_sip_object_unref(obj);
}
#ifdef HAVE_DNS_SERVICE
if(unref_me == TRUE) {
belle_sip_object_unref(obj);
}
#endif /* HAVE_DNS_SERVICE */
}
/*
This function does the connect() method to get local ip address suitable to reach a given destination.
It works on all platform except for windows using ipv6 sockets. TODO: find a workaround for win32+ipv6 socket
*/
int belle_sip_get_src_addr_for(const struct sockaddr *dest, socklen_t destlen, struct sockaddr *src, socklen_t *srclen, int local_port){
int af_type=dest->sa_family;
int sock=(int)bctbx_socket(af_type,SOCK_DGRAM,IPPROTO_UDP);
int ret = 0;
if (sock==(belle_sip_socket_t)-1){
if (af_type == AF_INET){
belle_sip_fatal("Could not create socket: %s",belle_sip_get_socket_error_string());
}
goto fail;
}
if (af_type==AF_INET6 && (IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6*)dest)->sin6_addr))){
/*this is actually required only for windows, who is unable to provide an ipv4 mapped local address if the remote is ipv4 mapped,
and unable to provide a correct local address if the remote address is true ipv6 address when in dual stack mode*/
belle_sip_socket_enable_dual_stack(sock);
}
if (bctbx_connect(sock,dest,destlen)==-1){
//if (connect(sock,dest,destlen)==-1){
ret = -get_socket_error();
belle_sip_error("belle_sip_get_src_addr_for: bctbx_connect() failed: %s",belle_sip_get_socket_error_string_from_code(-ret));
goto fail;
}
if (bctbx_getsockname(sock,src,srclen)==-1){
ret = -get_socket_error();
belle_sip_error("belle_sip_get_src_addr_for: bctbx_getsockname() failed: %s",belle_sip_get_socket_error_string_from_code(-ret));
goto fail;
}
if (af_type==AF_INET6){
struct sockaddr_in6 *sin6=(struct sockaddr_in6*)src;
sin6->sin6_port=htons(local_port);
}else{
struct sockaddr_in *sin=(struct sockaddr_in*)src;
sin->sin_port=htons(local_port);
}
belle_sip_close_socket(sock);
return ret;
fail:
{
struct addrinfo *res = bctbx_ip_address_to_addrinfo(af_type, SOCK_STREAM, af_type == AF_INET ? "127.0.0.1" : "::1", local_port);
if (res != NULL) {
memcpy(src,res->ai_addr,MIN((size_t)*srclen,res->ai_addrlen));
*srclen=(socklen_t)res->ai_addrlen;
bctbx_freeaddrinfo(res);
} else {
if (af_type == AF_INET) belle_sip_fatal("belle_sip_get_src_addr_for(): belle_sip_ip_address_to_addrinfo() failed");
}
}
if (sock!=(belle_sip_socket_t)-1) belle_sip_close_socket(sock);
return ret;
}
belle-sip-5.2.0+dfsg/src/belle_sip_uri_impl.c 0000664 0000000 0000000 00000050305 14346131365 0021113 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "belle-sip/sip-uri.h"
#include "belle-sip/parameters.h"
#include
#include
#include
#include "grammars/belle_sip_messageParser.h"
#include "grammars/belle_sip_messageLexer.h"
#include "belle_sip_internal.h"
#include "listeningpoint_internal.h"
#define SIP_URI_GET_SET_STRING(attribute) GET_SET_STRING(belle_sip_uri,attribute)
#define SIP_URI_GET_SET_STRING_PARAM(attribute) GET_SET_STRING_PARAM2(belle_sip_uri,attribute,attribute##_param)
#define SIP_URI_GET_SET_UINT(attribute) GET_SET_INT(belle_sip_uri,attribute,unsigned int)
#define SIP_URI_GET_SET_INT(attribute) GET_SET_INT(belle_sip_uri,attribute,int)
#define SIP_URI_GET_SET_INT_PARAM(attribute) GET_SET_INT_PARAM2(belle_sip_uri,attribute,int,attribute##_param)
#define SIP_URI_GET_SET_BOOL(attribute) GET_SET_BOOL(belle_sip_uri,attribute,is)
#define SIP_URI_HAS_SET_BOOL(attribute) GET_SET_BOOL(belle_sip_uri,attribute,has)
#define SIP_URI_HAS_SET_BOOL_PARAM(attribute) GET_SET_BOOL_PARAM2(belle_sip_uri,attribute,has,attribute##_param)
struct _belle_sip_uri {
belle_sip_parameters_t params;
unsigned int secure;
char* user;
char* user_password;
char* host;
int port;
belle_sip_parameters_t * header_list;
};
static void belle_sip_uri_destroy(belle_sip_uri_t* uri) {
if (uri->user) belle_sip_free (uri->user);
if (uri->host) belle_sip_free (uri->host);
if (uri->user_password) belle_sip_free (uri->user_password);
belle_sip_object_unref(BELLE_SIP_OBJECT(uri->header_list));
}
static void belle_sip_uri_clone(belle_sip_uri_t* uri, const belle_sip_uri_t *orig){
uri->secure=orig->secure;
uri->user=orig->user?belle_sip_strdup(orig->user):NULL;
uri->user_password=orig->user_password?belle_sip_strdup(orig->user_password):NULL;
uri->host=orig->host?belle_sip_strdup(orig->host):NULL;
uri->port=orig->port;
if (orig->header_list){
uri->header_list=(belle_sip_parameters_t*)belle_sip_object_clone(BELLE_SIP_OBJECT(orig->header_list));
belle_sip_object_ref(uri->header_list);
}
}
static void encode_params(belle_sip_param_pair_t* container, belle_sip_list_t** newlist) {
char *escapedName = belle_sip_uri_to_escaped_parameter(container->name);
char *escapedValue = container->value? belle_sip_uri_to_escaped_parameter(container->value) : NULL;
*newlist = belle_sip_list_append(*newlist, belle_sip_param_pair_new(escapedName, escapedValue));
if (escapedName) free(escapedName);
if (escapedValue) free(escapedValue);
}
static void encode_headers(belle_sip_param_pair_t* container, belle_sip_list_t** newlist) {
char *escapedName = belle_sip_uri_to_escaped_header(container->name);
char *escapedValue = container->value? belle_sip_uri_to_escaped_header(container->value) : NULL;
*newlist = belle_sip_list_append(*newlist, belle_sip_param_pair_new(escapedName, escapedValue));
if (escapedName) free(escapedName);
if (escapedValue) free(escapedValue);
}
belle_sip_error_code belle_sip_uri_marshal(const belle_sip_uri_t* uri, char* buff, size_t buff_size, size_t *offset) {
const belle_sip_list_t* list;
belle_sip_error_code error=BELLE_SIP_OK;
error=belle_sip_snprintf(buff,buff_size,offset,"%s:",uri->secure?"sips":"sip");
if (error!=BELLE_SIP_OK) return error;
if (uri->user && uri->user[0]!='\0') {
char* escaped_username=belle_sip_uri_to_escaped_username(uri->user);
error=belle_sip_snprintf(buff,buff_size,offset,"%s",escaped_username);
belle_sip_free(escaped_username);
if (error!=BELLE_SIP_OK) return error;
if (uri->user_password) {
char* escaped_password=belle_sip_uri_to_escaped_userpasswd(uri->user_password);
error=belle_sip_snprintf(buff,buff_size,offset,":%s",escaped_password);
belle_sip_free(escaped_password);
if (error!=BELLE_SIP_OK) return error;
}
error=belle_sip_snprintf(buff,buff_size,offset,"@");
if (error!=BELLE_SIP_OK) return error;
}
if (uri->host) {
if (strchr(uri->host,':')) { /*ipv6*/
error=belle_sip_snprintf(buff,buff_size,offset,"[%s]",uri->host);
} else {
error=belle_sip_snprintf(buff,buff_size,offset,"%s",uri->host);
}
if (error!=BELLE_SIP_OK) return error;
} else {
belle_sip_warning("no host found in this uri");
}
if (uri->port!=0) {
error=belle_sip_snprintf(buff,buff_size,offset,":%i",uri->port);
if (error!=BELLE_SIP_OK) return error;
}
{
belle_sip_parameters_t *encparams = belle_sip_parameters_new();
belle_sip_list_for_each2(uri->params.param_list, (void (*)(void *, void *))encode_params, &encparams->param_list);
error=belle_sip_parameters_marshal(encparams,buff,buff_size,offset);
belle_sip_object_unref(encparams);
if (error!=BELLE_SIP_OK) return error;
}
{
belle_sip_list_t * encheaders = NULL;
belle_sip_list_for_each2(uri->header_list->param_list, (void (*)(void *, void *))encode_headers, &encheaders);
for(list=encheaders;list!=NULL;list=list->next){
belle_sip_param_pair_t* container = list->data;
if (list == encheaders) {
//first case
error=belle_sip_snprintf(buff,buff_size,offset,"?%s=%s",container->name,container->value?container->value:"");
} else {
//subsequent headers
error=belle_sip_snprintf(buff,buff_size,offset,"&%s=%s",container->name,container->value?container->value:"");
}
if (error!=BELLE_SIP_OK) break;
}
belle_sip_list_free_with_data(encheaders,(void (*)(void*))belle_sip_param_pair_destroy);
}
return error;
}
BELLE_SIP_PARSE(uri);
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_uri_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_sip_uri_t,belle_sip_parameters_t,belle_sip_uri_destroy,belle_sip_uri_clone,belle_sip_uri_marshal,TRUE);
belle_sip_uri_t* belle_sip_uri_new () {
belle_sip_uri_t* l_object = belle_sip_object_new(belle_sip_uri_t);
belle_sip_parameters_init((belle_sip_parameters_t*)l_object); /*super*/
l_object->header_list = belle_sip_parameters_new();
belle_sip_object_ref(l_object->header_list);
return l_object;
}
belle_sip_uri_t* belle_sip_uri_create (const char* username,const char* host) {
belle_sip_uri_t* uri = belle_sip_uri_new();
belle_sip_uri_set_user(uri,username);
belle_sip_uri_set_host(uri,host);
return uri;
}
char* belle_sip_uri_to_string(const belle_sip_uri_t* uri) {
return belle_sip_object_to_string(BELLE_SIP_OBJECT(uri));
}
const char* belle_sip_uri_get_header(const belle_sip_uri_t* uri,const char* name) {
return belle_sip_parameters_get_parameter(uri->header_list,name);
}
void belle_sip_uri_set_header(belle_sip_uri_t* uri,const char* name,const char* value) {
belle_sip_parameters_set_parameter(uri->header_list,name,value);
}
void belle_sip_uri_remove_header(belle_sip_uri_t *uri, const char *name){
belle_sip_parameters_remove_parameter(uri->header_list,name);
}
const belle_sip_list_t* belle_sip_uri_get_header_names(const belle_sip_uri_t* uri) {
return belle_sip_parameters_get_parameter_names(uri->header_list);
}
int belle_sip_uri_get_listening_port(const belle_sip_uri_t *uri){
int port=belle_sip_uri_get_port(uri);
const char *transport=belle_sip_uri_get_transport_param(uri);
if (!transport) {
transport=belle_sip_uri_is_secure(uri)?"tls":"udp";
}
if (port==0)
port=belle_sip_listening_point_get_well_known_port(transport);
return port;
}
void belle_sip_uri_fix(belle_sip_uri_t *uri){
/*nop, to be removed*/
}
SIP_URI_GET_SET_BOOL(secure)
SIP_URI_GET_SET_STRING(user)
SIP_URI_GET_SET_STRING(user_password)
SIP_URI_GET_SET_STRING(host)
SIP_URI_GET_SET_INT(port)
SIP_URI_GET_SET_STRING_PARAM(transport)
SIP_URI_GET_SET_STRING_PARAM(user)
SIP_URI_GET_SET_STRING_PARAM(method)
SIP_URI_GET_SET_STRING_PARAM(maddr)
SIP_URI_GET_SET_INT_PARAM(ttl)
SIP_URI_HAS_SET_BOOL_PARAM(lr)
const belle_sip_parameters_t* belle_sip_uri_get_headers(const belle_sip_uri_t* uri) {
return uri->header_list;
}
void belle_sip_uri_headers_clean(belle_sip_uri_t* uri) {
belle_sip_parameters_clean(uri->header_list);
}
static int uri_strcmp(const char*a,const char*b,int case_sensitive) {
int result = 0;
size_t index_a=0,index_b=0;
char char_a,char_b;
if (a == NULL && b == NULL) {
goto end;
}
if ((a != NULL && b == NULL) || (a == NULL && b != NULL)){
result = 1;
goto end;
}
do {
index_a+=belle_sip_get_char(a+index_a,&char_a);
index_b+=belle_sip_get_char(b+index_b,&char_b);
if (!case_sensitive && char_a<0x7B && char_a>0x60) char_a-=0x20;
if (!case_sensitive && char_b<0x7B && char_b>0x60) char_b-=0x20;
result=(char_a!=char_b);
if (result) break;
if (char_a == '\0' || char_b == '\0') break;
}while(1);
end:
return result;
}
#define IS_EQUAL(a,b) (uri_strcmp(a,b,TRUE)==0)
#define IS_EQUAL_CASE(a,b) (uri_strcmp(a,b,FALSE)==0)
#define PARAM_CASE_CMP(uri_a,uri_b,param) \
a_param_value=belle_sip_parameters_get_case_parameter((belle_sip_parameters_t*) uri_a,param); \
b_param_value=belle_sip_parameters_get_case_parameter((belle_sip_parameters_t*) uri_b,param);\
if (!IS_EQUAL_CASE(a_param_value,b_param_value)) return 0;
/*
* RFC 3261 SIP: Session Initiation Protocol June 2002
* 19.1.4 URI Comparison
Some operations in this specification require determining whether two
SIP or SIPS URIs are equivalent. In this specification, registrars
need to compare bindings in Contact URIs in REGISTER requests (see
Section 10.3.). SIP and SIPS URIs are compared for equality
according to the following rules:
*/
static int belle_sip_uri_equals_with_omission(const belle_sip_uri_t* uri_a,const belle_sip_uri_t* uri_b,bool_t uri_omitting) {
const belle_sip_list_t * params;
belle_sip_param_pair_t * a_param;
const char * a_param_value;
const char * b_param_value;
/*
o A SIP and SIPS URI are never equivalent.
*/
if (belle_sip_uri_is_secure(uri_a)!=belle_sip_uri_is_secure(uri_b)) {
return 0;
}
/*
o Comparison of the userinfo of SIP and SIPS URIs is case-
sensitive. This includes userinfo containing passwords or
formatted as telephone-subscribers. Comparison of all other
components of the URI is case-insensitive unless explicitly
defined otherwise.
*/
if (!IS_EQUAL(uri_a->user,uri_b->user)) return 0;
/*
o The ordering of parameters and header fields is not significant
in comparing SIP and SIPS URIs.
o Characters other than those in the "reserved" set (see RFC 2396
[5]) are equivalent to their ""%" HEX HEX" encoding.
o An IP address that is the result of a DNS lookup of a host name
does not match that host name.
o For two URIs to be equal, the user, password, host, and port
components must match.
*/
if (!IS_EQUAL_CASE(uri_a->host,uri_b->host)) {
return 0;
}
if (uri_omitting) {
int port_a = uri_a->port;
int port_b = uri_b->port;
if (port_a == 0) {
const char* transport_a = belle_sip_parameters_get_case_parameter((belle_sip_parameters_t*) uri_a, "transport");
if (transport_a == NULL) port_a = belle_sip_listening_point_get_well_known_port("UDP");
else port_a = belle_sip_listening_point_get_well_known_port(transport_a);
}
if (port_b == 0) {
const char* transport_b = belle_sip_parameters_get_case_parameter((belle_sip_parameters_t*) uri_b, "transport");
if (transport_b == NULL) port_b = belle_sip_listening_point_get_well_known_port("UDP");
else port_b = belle_sip_listening_point_get_well_known_port(transport_b);
}
if (port_a != port_b) return 0;
} else {
/* In this case (by default) we respect URI omitting */
if (uri_a->port != uri_b->port) return 0;
}
/*
A URI omitting the user component will not match a URI that
includes one. A URI omitting the password component will not
match a URI that includes one.
A URI omitting any component with a default value will not
match a URI explicitly containing that component with its
default value. For instance, a URI omitting the optional port
component will not match a URI explicitly declaring port 5060.
The same is true for the transport-parameter, ttl-parameter,
user-parameter, and method components.
Defining sip:user@host to not be equivalent to
sip:user@host:5060 is a change from RFC 2543. When deriving
addresses from URIs, equivalent addresses are expected from
equivalent URIs. The URI sip:user@host:5060 will always
resolve to port 5060. The URI sip:user@host may resolve to
other ports through the DNS SRV mechanisms detailed in [4].
o URI uri-parameter components are compared as follows:
- Any uri-parameter appearing in both URIs must match.
*/
/*
* - A user, ttl, or method uri-parameter appearing in only one
URI never matches, even if it contains the default value.
- A URI that includes an maddr parameter will not match a URI
that contains no maddr parameter.
* */
PARAM_CASE_CMP(uri_a,uri_b,"transport")
PARAM_CASE_CMP(uri_a,uri_b,"user")
PARAM_CASE_CMP(uri_a,uri_b,"ttl")
PARAM_CASE_CMP(uri_a,uri_b,"method")
PARAM_CASE_CMP(uri_a,uri_b,"maddr")
for(params=belle_sip_parameters_get_parameters((belle_sip_parameters_t*) uri_a);params!=NULL;params=params->next) {
a_param = (belle_sip_param_pair_t*)(params->data);
if ((b_param_value=belle_sip_parameters_get_parameter((belle_sip_parameters_t*) uri_b,a_param->name)) != NULL) {
if (!IS_EQUAL_CASE(b_param_value,a_param->value)) return 0;
}
}
/*
- All other uri-parameters appearing in only one URI are
ignored when comparing the URIs.
*/
/* *fixme ignored for now*/
/*
o URI header components are never ignored. Any present header
component MUST be present in both URIs and match for the URIs
to match. The matching rules are defined for each header field
in Section 20.
*/
return 1;
}
int belle_sip_uri_equals(const belle_sip_uri_t* uri_a,const belle_sip_uri_t* uri_b) {
return belle_sip_uri_equals_with_omission(uri_a, uri_b, FALSE);
}
int belle_sip_uri_equals_with_uri_omitting(const belle_sip_uri_t* uri_a, const belle_sip_uri_t* uri_b) {
return belle_sip_uri_equals_with_omission(uri_a, uri_b, TRUE);
}
/*uri checker*/
/*
* From 19.1.1 SIP and SIPS URI Components
* dialog
reg./redir. Contact/
default Req.-URI To From Contact R-R/Route external
user -- o o o o o o
password -- o o o o o o
host -- m m m m m m
port (1) o - - o o o
user-param ip o o o o o o
method INVITE - - - - - o
maddr-param -- o - - o o o
ttl-param 1 o - - o - o
transp.-param (2) o - - o o o
lr-param -- o - - - o o
other-param -- o o o o o o
headers -- - - - o - o
(1): The default port value is transport and scheme dependent. The
default is 5060 for sip: using UDP, TCP, or SCTP. The default is
5061 for sip: using TLS over TCP and sips: over TCP.
(2): The default transport is scheme dependent. For sip:, it is UDP.
For sips:, it is TCP.
Table 1: Use and default values of URI components for SIP header
field values, Request-URI and references*/
typedef enum {
m /*mandotory*/
, o /*optionnal*/
, na /*not allowd*/
} mark;
static const char* mark_to_string(mark value) {
switch (value) {
case o: return "optionnal";
case m: return "mandatory";
case na: return "not allowed";
}
return "unknown";
}
typedef struct uri_components {
const char * name;
mark user;
mark password;
mark host;
mark port;
mark user_param;
mark method;
mark maddr_param;
mark ttl_param;
mark transp_param;
mark lr_param;
mark other_param;
mark headers;
} uri_components_t;
/*belle sip allows contact header without host because stack will automatically put host if missing*/
static uri_components_t uri_component_use_for_request = {"Req.-URI" ,o ,o ,m ,o ,o ,na ,o ,o ,o ,o ,o ,na};
static uri_components_t uri_component_use_for_header_to = {"Header To" ,o ,o ,m ,na ,o ,na ,na ,na ,na ,na ,o ,na};
static uri_components_t uri_component_use_for_header_from = {"Header From" ,o ,o ,m ,na ,o ,na ,na ,na ,na ,na ,o ,na};
static uri_components_t uri_component_use_for_header_refer_to = {"Header Refer-To" ,o ,o ,o ,o ,o ,o ,o ,o ,o ,o ,o ,o};
static uri_components_t uri_component_use_for_contact_in_reg = {"Contact in REG" ,o ,o ,/*m*/o ,o ,o ,na ,o ,o ,o ,na ,o ,o};
static uri_components_t uri_component_use_for_dialog_ct_rr_ro = {"Dialog Contact/R-R/Route" ,o ,o ,/*m*/o ,o ,o ,na ,o ,na ,o ,o ,o ,na};
static uri_components_t uri_component_use_for_external = {"External" ,o ,o ,m ,o ,o ,o ,o ,o ,o ,o ,o ,o};
static int check_component(int is_present,mark requirement) {
switch (requirement) {
case o: return TRUE;
case m: return is_present;
case na: return !is_present;
}
return 0;
}
#define CHECK_URI_COMPONENT(uri_component,uri_component_name,component_use_rule,component_use_rule_name) \
if (!check_component(uri_component,component_use_rule)) {\
belle_sip_error("Uri component [%s] does not follow reqs [%s] for context [%s]", uri_component_name,mark_to_string(component_use_rule),component_use_rule_name);\
return FALSE;\
}
static int check_uri_components(const belle_sip_uri_t* uri, const uri_components_t* components_use) {
CHECK_URI_COMPONENT(uri->user!=NULL,"user",components_use->user,components_use->name)
CHECK_URI_COMPONENT(uri->host!=NULL,"host",components_use->host,components_use->name)
CHECK_URI_COMPONENT(uri->port>0,"port",components_use->port,components_use->name)
CHECK_URI_COMPONENT(belle_sip_parameters_has_parameter(&uri->params,"maddr"),"maddr-param",components_use->maddr_param,components_use->name)
CHECK_URI_COMPONENT(belle_sip_parameters_has_parameter(&uri->params,"ttl"),"ttl-param",components_use->ttl_param,components_use->name)
CHECK_URI_COMPONENT(belle_sip_parameters_has_parameter(&uri->params,"transport"),"transp.-param",components_use->transp_param,components_use->name)
CHECK_URI_COMPONENT(belle_sip_parameters_has_parameter(&uri->params,"lr"),"lr-param",components_use->lr_param,components_use->name)
/*..*/
CHECK_URI_COMPONENT(belle_sip_list_size(belle_sip_parameters_get_parameters(uri->header_list))>0,"headers",components_use->headers,components_use->name)
return TRUE;
}
/*return 0 if not compliant*/
int belle_sip_uri_check_components_from_request_uri(const belle_sip_uri_t* uri) {
return check_uri_components(uri,&uri_component_use_for_request);
}
int belle_sip_uri_check_components_from_context(const belle_sip_uri_t* uri,const char* method,const char* header_name) {
if (strcasecmp(BELLE_SIP_FROM,header_name)==0)
return check_uri_components(uri,&uri_component_use_for_header_from);
else if (strcasecmp(BELLE_SIP_TO,header_name)==0)
return check_uri_components(uri,&uri_component_use_for_header_to);
else if (strcasecmp(BELLE_SIP_CONTACT,header_name)==0 && method && strcasecmp("REGISTER",method)==0)
return check_uri_components(uri,&uri_component_use_for_contact_in_reg);
else if (strcasecmp(BELLE_SIP_CONTACT,header_name)==0
|| strcasecmp(BELLE_SIP_RECORD_ROUTE,header_name)==0
|| strcasecmp(BELLE_SIP_ROUTE,header_name)==0)
return check_uri_components(uri,&uri_component_use_for_dialog_ct_rr_ro);
else if (strcasecmp(BELLE_SIP_REFER_TO, header_name) == 0)
return check_uri_components(uri, &uri_component_use_for_header_refer_to);
else
return check_uri_components(uri,&uri_component_use_for_external);
}
/*fast uri implemenation*/
typedef belle_sip_uri_t belle_sip_fast_uri_t;
BELLE_SIP_PARSE(fast_uri);
belle-sip-5.2.0+dfsg/src/belle_sip_utils.c 0000664 0000000 0000000 00000041316 14346131365 0020435 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#define _CRT_RAND_S
#include
#include
#include
#include "belle_sip_internal.h"
#include "bctoolbox/parser.h"
#include "bctoolbox/crypto.h"
#include "clock_gettime.h" /*for apple*/
#ifndef _WIN32
#include
#include /*for gettimeofday*/
#include /* available on POSIX system only */
#else
#include
#endif
belle_sip_error_code belle_sip_snprintf(char *buff, size_t buff_size, size_t *offset, const char *fmt, ...) {
belle_sip_error_code ret;
va_list args;
va_start(args, fmt);
ret = belle_sip_snprintf_valist(buff, buff_size, offset, fmt, args);
va_end(args);
return ret;
}
belle_sip_error_code belle_sip_snprintf_valist(char *buff, size_t buff_size, size_t *offset, const char *fmt, va_list args) {
int ret;
belle_sip_error_code error = BELLE_SIP_OK;
ret = vsnprintf(buff + *offset, buff_size - *offset, fmt, args);
if ((ret < 0)
|| (ret >= (int)(buff_size - *offset))) {
error = BELLE_SIP_BUFFER_OVERFLOW;
*offset = buff_size;
} else {
*offset += ret;
}
return error;
}
#if defined(_WIN32) || defined(_WIN32_WCE)
#define ENDLINE "\r\n"
#else
#define ENDLINE "\n"
#endif
#ifdef _WIN32
static int belle_sip_gettimeofday (struct timeval *tv, void* tz)
{
union
{
__int64 ns100; /*time since 1 Jan 1601 in 100ns units */
FILETIME fileTime;
} now;
GetSystemTimeAsFileTime (&now.fileTime);
tv->tv_usec = (long) ((now.ns100 / 10LL) % 1000000LL);
tv->tv_sec = (long) ((now.ns100 - 116444736000000000LL) / 10000000LL);
return 0;
}
#else
#define belle_sip_gettimeofday gettimeofday
#endif
#ifndef _WIN32
static int find_best_clock_id (void) {
#if 0
struct timespec ts;
static int clock_id=-1;
#ifndef __ANDROID__
#define DEFAULT_CLOCK_MODE CLOCK_MONOTONIC
#else
#define DEFAULT_CLOCK_MODE CLOCK_REALTIME /*monotonic clock stop during sleep mode*/
#endif
if (clock_id==-1) {
if (clock_gettime(DEFAULT_CLOCK_MODE,&ts)!=1){
clock_id=DEFAULT_CLOCK_MODE;
} else if (clock_gettime(CLOCK_REALTIME,&ts)!=1){
clock_id=CLOCK_REALTIME;
} else {
belle_sip_fatal("Cannot find suitable clock mode");
}
}
return clock_id;
#else
/* Tt seems that both Linux, iOS, and MacOS stop incrementing the CLOCK_MONOTONIC during sleep time.
* This is a real problem, because all refreshable requests (SUBSCRIBE, REGISTER, PUBLISH) won't be sent on time due to
* system going to sleep. Let's take an example: a REGISTER is sent at T0 with expire 3600, then the macbook suspends at T0+60s.
* When the macbook resumes at T0+8000, nothing happens. The REGISTER refresh will be sent at T0+8000+3600-60.
* The only reason for seeing the register is if the network address has changed, in which case it will trigger a shutdown of all sockets.
* As a result, we fallback to CLOCK_REALTIME until the OS correctly implement CLOCK_MONOTONIC according to POSIX specifications
*/
#ifdef __APPLE__
#ifdef CLOCK_REALTIME
#undef CLOCK_REALTIME
#endif
#define CLOCK_REALTIME BC_CLOCK_REALTIME
#endif
return CLOCK_REALTIME;
#endif
}
uint64_t belle_sip_time_ms(void){
#ifdef __APPLE__
#define clock_gettime bc_clock_gettime
#endif
struct timespec ts;
if (clock_gettime(find_best_clock_id(),&ts)==-1){
belle_sip_error("clock_gettime() error for clock_id=%i: %s",find_best_clock_id(),strerror(errno));
return 0;
}
return (ts.tv_sec*1000LL) + (ts.tv_nsec/1000000LL);
}
#else
uint64_t belle_sip_time_ms(void){
#ifdef BELLE_SIP_WINDOWS_DESKTOP
return GetTickCount();
#else
return GetTickCount64();
#endif
}
#endif
/**
* parser parameter pair
*/
belle_sip_param_pair_t* belle_sip_param_pair_new(const char* name,const char* value) {
belle_sip_param_pair_t* lPair = (belle_sip_param_pair_t*)belle_sip_new0(belle_sip_param_pair_t);
lPair->name=name?belle_sip_strdup(name):NULL;
lPair->value=value?belle_sip_strdup(value):NULL;
return lPair;
}
void belle_sip_param_pair_destroy(belle_sip_param_pair_t* pair) {
if (pair->name) belle_sip_free(pair->name);
if (pair->value) belle_sip_free(pair->value);
belle_sip_free(pair);
}
int belle_sip_param_pair_comp_func(const belle_sip_param_pair_t *a, const char*b) {
return strcmp(a->name,b);
}
int belle_sip_param_pair_case_comp_func(const belle_sip_param_pair_t *a, const char*b) {
return strcasecmp(a->name,b);
}
char* _belle_sip_str_dup_and_unquote_string(const char* quoted_string) {
size_t value_size = strlen(quoted_string);
char* unquoted_string = belle_sip_malloc0(value_size-2+1);
strncpy(unquoted_string,quoted_string+1,value_size-2);
return unquoted_string;
}
char *belle_sip_unquote_strdup(const char *str){
const char *p;
if (str==NULL) return NULL;
for(p=str;*p!='\0';++p){
switch(*p){
case ' ':
case '\t':
break;
case '"':
return _belle_sip_str_dup_and_unquote_string(p);
default:
return belle_sip_strdup(str);
break;
}
}
return belle_sip_strdup(str);
}
void belle_sip_set_socket_api(bctbx_vsocket_api_t* my_api){
bctbx_vsocket_api_set_default(my_api);
}
static const char *symbols="aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789-~";
/**
* Write a random text token of supplied size.
**/
char * belle_sip_random_token(char *ret, size_t size){
return belle_sip_random_token_with_charset(ret, size, symbols, 64);
}
char * belle_sip_random_token_with_charset(char *ret, size_t size, const char * charset, size_t charset_length){
unsigned int i;
belle_sip_random_bytes((unsigned char *)ret, size-1);
for(i=0;ibuffer=buffer;
reader->buf_size=bufsize;
reader->bit_index=0;
}
static int bits_reader_read(bits_reader_t *reader, int count, unsigned int *ret){
unsigned int tmp;
size_t byte_index=reader->bit_index/8;
size_t bit_index=reader->bit_index % 8;
int shift=32-(int)bit_index-count;
if (count>=24){
belle_sip_error("This bit reader cannot read more than 24 bits at once.");
return -1;
}
if (byte_indexbuf_size)
tmp=((unsigned int)reader->buffer[byte_index++])<<24;
else{
belle_sip_error("Bit reader goes end of stream.");
return -1;
}
if (byte_indexbuf_size)
tmp|=((unsigned int)reader->buffer[byte_index++])<<16;
if (byte_indexbuf_size)
tmp|=((unsigned int)reader->buffer[byte_index++])<<8;
if (byte_indexbuf_size)
tmp|=((unsigned int)reader->buffer[byte_index++]);
tmp=tmp>>shift;
tmp=tmp & ((1<bit_index+=count;
*ret=tmp;
return 0;
}
char * belle_sip_octets_to_text(const uint8_t *hash, size_t hash_len, char *ret, size_t size){
int i;
bits_reader_t bitctx;
bits_reader_init(&bitctx,hash,hash_len);
for(i=0;i<(int)size-1;++i){
unsigned int val=0;
if (bits_reader_read(&bitctx,6,&val)==0){
ret[i]=symbols[val];
}else break;
}
ret[i]=0;
return ret;
}
void belle_sip_util_copy_headers(belle_sip_message_t *orig, belle_sip_message_t *dest, const char*header, int multiple){
const belle_sip_list_t *elem;
elem=belle_sip_message_get_headers(orig,header);
for (;elem!=NULL;elem=elem->next){
belle_sip_header_t *ref_header=(belle_sip_header_t*)elem->data;
if (ref_header){
ref_header=(belle_sip_header_t*)belle_sip_object_clone((belle_sip_object_t*)ref_header);
if (!multiple){
belle_sip_message_set_header(dest,ref_header);
break;
}else
belle_sip_message_add_header(dest,ref_header);
}
}
}
char* belle_sip_to_unescaped_string(const char* buff) {
return bctbx_unescaped_string(buff);
}
size_t belle_sip_get_char(const char* a, char *b) {
return bctbx_get_char(a,b);
}
/*
static void print_noescapes_map(char noescapes[BELLE_SIP_NO_ESCAPES_SIZE], const char *name) {
unsigned int i;
printf("Noescapes %s :", name);
for (i=' '; i <= '~'; ++i) {
if (noescapes[i] == 1) printf ("%c", i);
//if (noescapes[i] == 1) printf ("%c %d - %d\n", i, (char)i, noescapes[i]);
}
printf ("init: %d\n", noescapes[BELLE_SIP_NO_ESCAPES_SIZE-1]);
}
*/
static const bctbx_noescape_rules_t* get_sip_uri_username_noescapes(void) {
static bctbx_noescape_rules_t noescapes = {0};
if (noescapes[BCTBX_NOESCAPE_RULES_USER_INDEX] == 0) {
// concurrent initialization should not be an issue
/*user = 1*( unreserved / escaped / user-unreserved )
unreserved = alphanum / mark
mark = "-" / "_" / "." / "!" / "~" / "*" / "'"
/ "(" / ")"
user-unreserved = "&" / "=" / "+" / "$" / "," / ";" / "?" / "/"
*/
bctbx_noescape_rules_add_alfanums(noescapes);
/*mark*/
bctbx_noescape_rules_add_list(noescapes, "-_.!~*'()");
/*user-unreserved*/
bctbx_noescape_rules_add_list(noescapes, "&=+$,;?/");
noescapes[BCTBX_NOESCAPE_RULES_USER_INDEX] = 1; // initialized
// print_noescapes_map(noescapes, "uri_username");
}
return (const bctbx_noescape_rules_t*)&noescapes;/*gcc asks for a cast, clang not*/
}
/*
*
* password = *( unreserved / escaped /
"&" / "=" / "+" / "$" / "," )
* */
static const bctbx_noescape_rules_t* get_sip_uri_userpasswd_noescapes(void) {
static bctbx_noescape_rules_t noescapes = {0};
if (noescapes[BCTBX_NOESCAPE_RULES_USER_INDEX] == 0) {
// unreserved
bctbx_noescape_rules_add_alfanums(noescapes);
bctbx_noescape_rules_add_list(noescapes, "-_.!~*'()");
bctbx_noescape_rules_add_list(noescapes, "&=+$,");
noescapes[BCTBX_NOESCAPE_RULES_USER_INDEX] = 1; // initialized
}
return (const bctbx_noescape_rules_t*)&noescapes;/*gcc asks for a cast, clang not*/
}
static const bctbx_noescape_rules_t* get_sip_uri_parameter_noescapes(void) {
static bctbx_noescape_rules_t noescapes= {0};
if (noescapes[BCTBX_NOESCAPE_RULES_USER_INDEX] == 0) {
/*
other-param = pname [ "=" pvalue ]
pname = 1*paramchar
pvalue = 1*paramchar
paramchar = param-unreserved / unreserved / escaped
param-unreserved = "[" / "]" / "/" / ":" / "&" / "+" / "$"
unreserved = alphanum / mark
mark = "-" / "_" / "." / "!" / "~" / "*" / "'"
/ "(" / ")"
escaped = "%" HEXDIG HEXDIG
token = 1*(alphanum / "-" / "." / "!" / "%" / "*"
/ "_" / "+" / "`" / "'" / "~" )
*/
//param-unreserved =
bctbx_noescape_rules_add_list(noescapes,"[]/:&+$");
// token
bctbx_noescape_rules_add_alfanums(noescapes);
bctbx_noescape_rules_add_list(noescapes, "-.!%*_+`'~");
// unreserved
bctbx_noescape_rules_add_list(noescapes, "-_.!~*'()");
noescapes[BCTBX_NOESCAPE_RULES_USER_INDEX] = 1; // initialized
// print_noescapes_map(noescapes, "uri_parameter");
}
return (const bctbx_noescape_rules_t*)&noescapes;/*gcc asks for a cast, clang not*/
}
static const bctbx_noescape_rules_t* get_sip_uri_header_noescapes(void) {
static bctbx_noescape_rules_t noescapes= {0};
if (noescapes[BCTBX_NOESCAPE_RULES_USER_INDEX] == 0) {
/*
unreserved = alphanum / mark
mark = "-" / "_" / "." / "!" / "~" / "*" / "'"
/ "(" / ")"
escaped = "%" HEXDIG HEXDIG
//....
header = hname "=" hvalue
hname = 1*( hnv-unreserved / unreserved / escaped )
hvalue = *( hnv-unreserved / unreserved / escaped )
hnv-unreserved = "[" / "]" / "/" / "?" / ":" / "+" / "$"
*/
// unreserved
//alphanum
bctbx_noescape_rules_add_alfanums(noescapes);
//mark
bctbx_noescape_rules_add_list(noescapes, "-_.!~*'()");
bctbx_noescape_rules_add_list(noescapes, "[]/?:+$");
//hnv-unreserved
noescapes[BCTBX_NOESCAPE_RULES_USER_INDEX] = 1; // initialized
// print_noescapes_map(noescapes, "uri_parameter");
}
return (const bctbx_noescape_rules_t*)&noescapes;/*gcc asks for a cast, clang not*/
}
char* belle_sip_uri_to_escaped_username(const char* buff) {
return bctbx_escape(buff, *get_sip_uri_username_noescapes());
}
char* belle_sip_username_unescape_unnecessary_characters(const char* buff) {
return bctbx_unescaped_string_only_chars_in_rules(buff, *get_sip_uri_username_noescapes());
}
char* belle_sip_uri_to_escaped_userpasswd(const char* buff) {
return bctbx_escape(buff, *get_sip_uri_userpasswd_noescapes());
}
char* belle_sip_uri_to_escaped_parameter(const char* buff) {
return bctbx_escape(buff, *get_sip_uri_parameter_noescapes());
}
char* belle_sip_uri_to_escaped_header(const char* buff) {
return bctbx_escape(buff, *get_sip_uri_header_noescapes());
}
/*uri (I.E RFC 2396)*/
static const bctbx_noescape_rules_t *get_generic_uri_query_noescapes(void) {
static bctbx_noescape_rules_t noescapes= {0};
if (noescapes[BCTBX_NOESCAPE_RULES_USER_INDEX] == 0) {
/*
uric = reserved | unreserved | escaped
reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
"$" | ","
unreserved = alphanum | mark
mark = "-" | "_" | "." | "!" | "~" | "*" | "'" |
"(" | ")"
3.4. Query Component
query = *uric
Within a query component, the characters ";", "/", "?", ":", "@",
"&", "=", "+", ",", and "$" are reserved.
*/
/*unreserved*/
bctbx_noescape_rules_add_alfanums(noescapes);
/*mark*/
bctbx_noescape_rules_add_list(noescapes, "-_.!~*'()");
bctbx_noescape_rules_add_list(noescapes, "=&"); // otherwise how to pass parameters?
noescapes[BCTBX_NOESCAPE_RULES_USER_INDEX] = 1; // initialized
}
return (const bctbx_noescape_rules_t*)&noescapes;/*gcc asks for a cast, clang not*/
}
static const bctbx_noescape_rules_t *get_generic_uri_path_noescapes(void) {
static bctbx_noescape_rules_t noescapes= {0};
if (noescapes[BCTBX_NOESCAPE_RULES_USER_INDEX] == 0) {
/*
3.3. Path Component
The path component contains data, specific to the authority (or the
scheme if there is no authority component), identifying the resource
within the scope of that scheme and authority.
path = [ abs_path | opaque_part ]
path_segments = segment *( "/" segment )
segment = *pchar *( ";" param )
param = *pchar
pchar = unreserved | escaped |
":" | "@" | "&" | "=" | "+" | "$" | ","
The path may consist of a sequence of path segments separated by a
single slash "/" character. Within a path segment, the characters
"/", ";", "=", and "?" are reserved. Each path segment may include a
sequence of parameters, indicated by the semicolon ";" character.
The parameters are not significant to the parsing of relative
references.
*/
/*unreserved*/
bctbx_noescape_rules_add_alfanums(noescapes);
/*mark*/
bctbx_noescape_rules_add_list(noescapes, "-_.!~*'()");
/*pchar*/
bctbx_noescape_rules_add_list(noescapes, ":@&=+$,");
/*;*/
bctbx_noescape_rules_add_list(noescapes, ";");
bctbx_noescape_rules_add_list(noescapes, "/");
noescapes[BCTBX_NOESCAPE_RULES_USER_INDEX] = 1; // initialized
}
return (const bctbx_noescape_rules_t*)&noescapes;/*gcc asks for a cast, clang not*/
}
char* belle_generic_uri_to_escaped_query(const char* buff) {
return bctbx_escape(buff, *get_generic_uri_query_noescapes());
}
char* belle_generic_uri_to_escaped_path(const char* buff) {
return bctbx_escape(buff, *get_generic_uri_path_noescapes());
}
char* belle_sip_string_to_backslash_less_unescaped_string(const char* buff) {
size_t buff_len = strlen(buff);
char *output_buff=belle_sip_malloc(buff_len+1);
unsigned int i;
unsigned int out_buff_index=0;
for(i=0; buff[i] != '\0'; i++) {
if (buff[i] == '\\' && i + 1 < buff_len ) { /*make sure escaped caracter exist*/
i++;/*skip \*/
}
/*make sure to only remove one \ in case of \\*/
output_buff[out_buff_index++]=buff[i];
}
output_buff[out_buff_index]='\0';
return output_buff;
}
char* belle_sip_display_name_to_backslashed_escaped_string(const char* buff) {
char output_buff[BELLE_SIP_MAX_TO_STRING_SIZE];
unsigned int i;
unsigned int out_buff_index=0;
for(i=0; buff[i] != '\0' && out_buff_index < sizeof(output_buff)-2; i++) {
/*-3 to make sure last param can be stored in escaped form*/
const char c = buff[i];
if (c == '\"' || c == '\\') {
output_buff[out_buff_index++]='\\'; /*insert escape character*/
}
output_buff[out_buff_index++]=c;
}
output_buff[out_buff_index]='\0';
return belle_sip_strdup(output_buff);
}
belle-sip-5.2.0+dfsg/src/bodyhandler.c 0000664 0000000 0000000 00000133617 14346131365 0017560 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "belle_sip_internal.h"
#include "bctoolbox/vfs.h"
#ifdef HAVE_ZLIB
#include "zlib.h"
#endif
/*
* Body handler base class implementation
*/
struct belle_sip_body_handler{
belle_sip_object_t base;
belle_sip_body_handler_progress_callback_t progress_cb;
size_t expected_size; /* 0 if unknown*/
size_t transfered_size;
belle_sip_list_t *headers; /**> used when this body is part of a multipart message to store the header of this part */
char *headerStringBuffer; /**> buffer populated with a string created from marshaling the headers */
void *user_data;
};
static void belle_sip_body_handler_clone(belle_sip_body_handler_t *obj, const belle_sip_body_handler_t *orig){
obj->progress_cb=orig->progress_cb;
obj->user_data=orig->user_data;
obj->expected_size=orig->expected_size;
obj->transfered_size=orig->transfered_size;
obj->headers=belle_sip_list_copy_with_data(orig->headers,(void *(*)(void*))belle_sip_object_clone_and_ref);
if (orig->headerStringBuffer!=NULL) {
obj->headerStringBuffer = strdup(orig->headerStringBuffer);
}
}
static void belle_sip_body_handler_destroy(belle_sip_body_handler_t *obj){
belle_sip_list_free_with_data(obj->headers,belle_sip_object_unref);
belle_sip_free(obj->headerStringBuffer);
}
static belle_sip_error_code belle_sip_body_handler_marshal(belle_sip_body_handler_t *obj, char *buff, size_t buff_size, size_t *offset) {
int ret;
size_t len;
if (*offset == 0) belle_sip_body_handler_begin_send_transfer(obj);
do {
len = buff_size - *offset;
ret = belle_sip_body_handler_send_chunk(obj, NULL, (uint8_t*)buff + *offset, &len);
*offset += len;
} while ((ret == BELLE_SIP_CONTINUE) && (len > 0));
if ((ret == BELLE_SIP_CONTINUE) || (ret == BELLE_SIP_BUFFER_OVERFLOW)) return BELLE_SIP_BUFFER_OVERFLOW;
if (ret == BELLE_SIP_STOP) belle_sip_body_handler_end_transfer(obj);
return BELLE_SIP_OK;
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_body_handler_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_body_handler_t)
{
BELLE_SIP_VPTR_INIT(belle_sip_body_handler_t,belle_sip_object_t,TRUE),
(belle_sip_object_destroy_t) belle_sip_body_handler_destroy,
(belle_sip_object_clone_t) belle_sip_body_handler_clone,
(belle_sip_object_marshal_t) belle_sip_body_handler_marshal,
(belle_sip_object_on_first_ref_t) NULL,
(belle_sip_object_on_last_ref_t) NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
NULL, /* begin_recv_transfer */
NULL, /* begin_send_transfer */
NULL, /* end_transfer */
NULL, /*chunk_recv*/
NULL /*chunk_send*/
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
void belle_sip_body_handler_init(belle_sip_body_handler_t *obj, belle_sip_body_handler_progress_callback_t progress_cb, void *user_data){
obj->user_data=user_data;
obj->progress_cb=progress_cb;
obj->headers = NULL; /* header is not used in most of the case, set it using a dedicated function if needed */
obj->headerStringBuffer = NULL; /* header string buffer is set when adding a body handler to a multipart body handler */
}
void belle_sip_body_handler_add_header(belle_sip_body_handler_t *obj, belle_sip_header_t *header) {
if (header != NULL) {
obj->headers=belle_sip_list_append(obj->headers,belle_sip_object_ref(header));
}
}
void belle_sip_body_handler_remove_header_from_ptr(belle_sip_body_handler_t *obj, belle_sip_header_t* header) {
belle_sip_list_t* it = belle_sip_list_find(obj->headers, header);
if (it) {
belle_sip_object_unref(header);
obj->headers = belle_sip_list_delete_link(obj->headers, it);
}
}
const belle_sip_list_t* belle_sip_body_handler_get_headers(const belle_sip_body_handler_t *obj) {
return obj->headers;
}
size_t belle_sip_body_handler_get_size(const belle_sip_body_handler_t *obj){
return obj->expected_size;
}
void belle_sip_body_handler_set_size(belle_sip_body_handler_t *obj, size_t size){
obj->expected_size=size;
}
size_t belle_sip_body_handler_get_transfered_size(const belle_sip_body_handler_t *obj){
return obj->transfered_size;
}
static void update_progress(belle_sip_body_handler_t *obj, belle_sip_message_t *msg){
belle_sip_debug("body handler [%p] : %llu bytes exchanged of %llu ", obj, (unsigned long long)obj->transfered_size, (unsigned long long)obj->expected_size);
if (obj->progress_cb)
obj->progress_cb(obj,msg,obj->user_data,obj->transfered_size,obj->expected_size);
}
void belle_sip_body_handler_begin_recv_transfer(belle_sip_body_handler_t *obj){
BELLE_SIP_OBJECT_VPTR_TYPE(belle_sip_body_handler_t) *vptr = BELLE_SIP_OBJECT_VPTR(obj, belle_sip_body_handler_t);
if (vptr->begin_recv_transfer != NULL) {
vptr->begin_recv_transfer(obj);
}
obj->transfered_size=0;
}
void belle_sip_body_handler_begin_send_transfer(belle_sip_body_handler_t *obj) {
BELLE_SIP_OBJECT_VPTR_TYPE(belle_sip_body_handler_t) *vptr = BELLE_SIP_OBJECT_VPTR(obj, belle_sip_body_handler_t);
if (vptr->begin_send_transfer != NULL) {
vptr->begin_send_transfer(obj);
}
obj->transfered_size = 0;
}
void belle_sip_body_handler_recv_chunk(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, uint8_t *buf, size_t size){
BELLE_SIP_OBJECT_VPTR(obj,belle_sip_body_handler_t)->chunk_recv(obj,msg,(off_t)obj->transfered_size,buf,size);
obj->transfered_size+=size;
update_progress(obj,msg);
}
int belle_sip_body_handler_send_chunk(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, uint8_t *buf, size_t *size){
int ret;
size_t to_send = *size;
if (obj->expected_size!=0){
to_send=MIN(*size,obj->expected_size-obj->transfered_size);
}
if (to_send==0 && obj->transfered_size==obj->expected_size) {
// An eWouldBlock error added a call to the function, nothing to send so return
// In some case to_send=0 because not buffer is available but sendings not finished.
belle_sip_message("body handler [%p] : Nothing to send",obj);
*size=0;
return BELLE_SIP_STOP;
}
ret=BELLE_SIP_OBJECT_VPTR(obj,belle_sip_body_handler_t)->chunk_send(obj,msg,(off_t)obj->transfered_size,buf,&to_send);
obj->transfered_size+=to_send;
*size=to_send;
update_progress(obj,msg);
if (obj->expected_size!=0){
if (obj->transfered_size==obj->expected_size) {
return BELLE_SIP_STOP;
}
if (ret==BELLE_SIP_STOP && obj->transfered_sizeexpected_size){
belle_sip_error("body handler [%p] transfered only [%i] bytes while [%i] were expected",obj,
(int)obj->transfered_size,(int)obj->expected_size);
}
}
return ret;
}
void belle_sip_body_handler_end_transfer(belle_sip_body_handler_t *obj){
BELLE_SIP_OBJECT_VPTR_TYPE(belle_sip_body_handler_t) *vptr = BELLE_SIP_OBJECT_VPTR(obj, belle_sip_body_handler_t);
if (vptr->end_transfer != NULL) {
vptr->end_transfer(obj);
}
if (obj->expected_size==0)
obj->expected_size=obj->transfered_size;
}
/*
* memory body handler implementation.
**/
struct belle_sip_memory_body_handler{
belle_sip_body_handler_t base;
uint8_t *buffer;
uint8_t encoding_applied;
};
static void belle_sip_memory_body_handler_destroy(belle_sip_memory_body_handler_t *obj){
if (obj->buffer) belle_sip_free(obj->buffer);
}
static void belle_sip_memory_body_handler_clone(belle_sip_memory_body_handler_t *obj, const belle_sip_memory_body_handler_t *orig){
if (orig->buffer) {
obj->buffer=belle_sip_malloc(orig->base.expected_size+1);
memcpy(obj->buffer,orig->buffer,orig->base.expected_size);
obj->buffer[orig->base.expected_size]='\0';
}
obj->encoding_applied = orig->encoding_applied;
}
static void belle_sip_memory_body_handler_recv_chunk(belle_sip_body_handler_t *base, belle_sip_message_t *msg, off_t offset, uint8_t *buf, size_t size){
belle_sip_memory_body_handler_t *obj=(belle_sip_memory_body_handler_t*)base;
obj->buffer=belle_sip_realloc(obj->buffer,offset+size+1);
memcpy(obj->buffer+offset,buf,size);
obj->buffer[offset+size]='\0';
}
static int belle_sip_memory_body_handler_send_chunk(belle_sip_body_handler_t *base, belle_sip_message_t *msg, off_t offset, uint8_t *buf, size_t *size){
belle_sip_memory_body_handler_t *obj=(belle_sip_memory_body_handler_t*)base;
size_t to_send=MIN(*size,obj->base.expected_size-offset);
if (obj->buffer == NULL) return BELLE_SIP_STOP;
memcpy(buf,obj->buffer+offset,to_send);
*size=to_send;
return (obj->base.expected_size-offset==*size) ? BELLE_SIP_STOP : BELLE_SIP_CONTINUE;
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_memory_body_handler_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_memory_body_handler_t)
{
{
BELLE_SIP_VPTR_INIT(belle_sip_memory_body_handler_t,belle_sip_body_handler_t,TRUE),
(belle_sip_object_destroy_t) belle_sip_memory_body_handler_destroy,
(belle_sip_object_clone_t)belle_sip_memory_body_handler_clone,
NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
NULL,
NULL,
NULL,
belle_sip_memory_body_handler_recv_chunk,
belle_sip_memory_body_handler_send_chunk
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
void *belle_sip_memory_body_handler_get_buffer(const belle_sip_memory_body_handler_t *obj){
return obj->buffer;
}
void belle_sip_memory_body_handler_set_buffer(belle_sip_memory_body_handler_t *obj, void *buffer) {
if (obj->buffer != NULL) belle_sip_free(obj->buffer);
obj->buffer = (uint8_t *)buffer;
}
#define BELLE_SIP_MEMORY_BODY_HANDLER_MINIMUM_DEFLATE_INPUT_SIZE 256
#define BELLE_SIP_MEMORY_BODY_HANDLER_ZLIB_INITIAL_SIZE 2048
int belle_sip_memory_body_handler_apply_encoding(belle_sip_memory_body_handler_t *obj, const char *encoding) {
if (obj->encoding_applied == TRUE)
return 0;
if (!obj->buffer || (belle_sip_body_handler_get_size(BELLE_SIP_BODY_HANDLER(obj)) < BELLE_SIP_MEMORY_BODY_HANDLER_MINIMUM_DEFLATE_INPUT_SIZE))
return -1;
#ifdef HAVE_ZLIB
if (strcmp(encoding, "deflate") == 0) {
z_stream strm;
size_t initial_size = belle_sip_body_handler_get_size(BELLE_SIP_BODY_HANDLER(obj));
size_t final_size;
unsigned int avail_out = BELLE_SIP_MEMORY_BODY_HANDLER_ZLIB_INITIAL_SIZE;
unsigned int outbuf_size = avail_out;
unsigned char *outbuf = belle_sip_malloc(outbuf_size);
unsigned char *outbuf_ptr = outbuf;
int ret;
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
ret = deflateInit(&strm, Z_DEFAULT_COMPRESSION);
if (ret != Z_OK) {
belle_sip_free(outbuf);
return -1;
}
strm.avail_in = (uInt)initial_size;
strm.next_in = obj->buffer;
do {
if (avail_out < BELLE_SIP_MEMORY_BODY_HANDLER_ZLIB_INITIAL_SIZE) {
unsigned int cursize = (unsigned int)(outbuf_ptr - outbuf);
outbuf_size *= 2;
outbuf = belle_sip_realloc(outbuf, outbuf_size);
outbuf_ptr = outbuf + cursize;
}
strm.avail_out = avail_out;
strm.next_out = outbuf_ptr;
deflate(&strm, Z_FINISH);
outbuf_ptr += avail_out - strm.avail_out;
avail_out = outbuf_size - (unsigned int)(outbuf_ptr - outbuf);
} while (strm.avail_out == 0);
deflateEnd(&strm);
final_size = outbuf_ptr - outbuf;
if ((final_size + 27) >= initial_size) { // 27 is the size of the Content-Encoding header
belle_sip_message("Body not compressed because its size would have increased");
belle_sip_free(outbuf);
return -1;
}
belle_sip_message("Body has been compressed: %u->%u:\n%s", (unsigned int)initial_size, (unsigned int)final_size, obj->buffer);
belle_sip_free(obj->buffer);
obj->buffer = outbuf;
belle_sip_body_handler_set_size(BELLE_SIP_BODY_HANDLER(obj), final_size);
obj->encoding_applied = TRUE;
return 0;
} else
#endif
{
belle_sip_warning("%s: unknown encoding '%s'", __FUNCTION__, encoding);
return -1;
}
}
int belle_sip_memory_body_handler_unapply_encoding(belle_sip_memory_body_handler_t *obj, const char *encoding) {
if (obj->buffer == NULL) return -1;
#ifdef HAVE_ZLIB
if (strcmp(encoding, "deflate") == 0) {
z_stream strm;
size_t initial_size = belle_sip_body_handler_get_size(BELLE_SIP_BODY_HANDLER(obj));
size_t final_size;
unsigned int avail_out = BELLE_SIP_MEMORY_BODY_HANDLER_ZLIB_INITIAL_SIZE;
unsigned int outbuf_size = avail_out;
unsigned char *outbuf = belle_sip_malloc(outbuf_size);
unsigned char *outbuf_ptr = outbuf;
bool_t outbuf_too_small = FALSE;
int ret;
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
strm.avail_in = 0;
strm.next_in = Z_NULL;
ret = inflateInit(&strm);
if (ret != Z_OK) return -1;
strm.avail_in = (uInt)initial_size;
strm.next_in = obj->buffer;
do {
if ((avail_out < BELLE_SIP_MEMORY_BODY_HANDLER_ZLIB_INITIAL_SIZE) || (outbuf_too_small == TRUE)) {
unsigned int cursize = (unsigned int)(outbuf_ptr - outbuf);
unsigned int increase = outbuf_size;
outbuf_size *= 2;
outbuf = belle_sip_realloc(outbuf, outbuf_size);
outbuf_ptr = outbuf + cursize;
avail_out += increase;
}
outbuf_too_small = FALSE;
strm.avail_out = avail_out;
strm.next_out = outbuf_ptr;
ret = inflate(&strm, Z_NO_FLUSH);
switch (ret) {
case Z_OK:
/* Error handling for truncated input buffer. Z_STREAM_END is not returned but there is no further input content */
if (strm.avail_out > 0) {
belle_sip_error("%s: truncated compressed body. Cannot uncompress it...", __FUNCTION__);
return -1;
}
break;
case Z_STREAM_END:
// Everything is ok, continue
break;
case Z_BUF_ERROR:
// Ask for more output space
outbuf_too_small = TRUE;
break;
case Z_NEED_DICT:
case Z_DATA_ERROR:
case Z_STREAM_ERROR:
case Z_MEM_ERROR:
default:
inflateEnd(&strm);
belle_sip_free(outbuf);
return -1;
}
outbuf_ptr += avail_out - strm.avail_out;
avail_out = outbuf_size - (unsigned int)(outbuf_ptr - outbuf);
} while (ret != Z_STREAM_END);
inflateEnd(&strm);
final_size = outbuf_ptr - outbuf;
if (final_size == outbuf_size) {
/* If not enough space get it to be able to put the final NULL character. */
outbuf = belle_sip_realloc(outbuf, outbuf_size + 1);
outbuf_ptr = outbuf + final_size;
}
*outbuf_ptr = '\0';
belle_sip_message("Body has been uncompressed: %u->%u:\n%s", (unsigned int)initial_size, (unsigned int)final_size, outbuf);
belle_sip_free(obj->buffer);
obj->buffer = outbuf;
belle_sip_body_handler_set_size(BELLE_SIP_BODY_HANDLER(obj), final_size);
return 0;
} else
#endif
{
belle_sip_warning("%s: unknown encoding '%s'", __FUNCTION__, encoding);
return -1;
}
}
belle_sip_memory_body_handler_t *belle_sip_memory_body_handler_new(belle_sip_body_handler_progress_callback_t cb, void *user_data){
belle_sip_memory_body_handler_t *obj=belle_sip_object_new(belle_sip_memory_body_handler_t);
belle_sip_body_handler_init((belle_sip_body_handler_t*)obj,cb,user_data);
return obj;
}
belle_sip_memory_body_handler_t *belle_sip_memory_body_handler_new_from_buffer(void *buffer, size_t bufsize, belle_sip_body_handler_progress_callback_t cb, void *user_data){
belle_sip_memory_body_handler_t *obj=belle_sip_object_new(belle_sip_memory_body_handler_t);
belle_sip_body_handler_init((belle_sip_body_handler_t*)obj,cb,user_data);
obj->buffer=(uint8_t*)buffer;
obj->base.expected_size=bufsize;
return obj;
}
belle_sip_memory_body_handler_t *belle_sip_memory_body_handler_new_copy_from_buffer(const void *buffer, size_t bufsize, belle_sip_body_handler_progress_callback_t cb, void *user_data){
belle_sip_memory_body_handler_t *obj=belle_sip_object_new(belle_sip_memory_body_handler_t);
belle_sip_body_handler_init((belle_sip_body_handler_t*)obj,cb,user_data);
obj->buffer=(uint8_t*)belle_sip_malloc(bufsize+1);
obj->buffer[bufsize]='\0';
obj->base.expected_size=bufsize;
memcpy(obj->buffer,buffer,bufsize);
return obj;
}
/*
* Buffer manager, used for buffering user or file body handler
*/
typedef struct belle_sip_body_handler_buffer {
size_t size; /**< the maximum buffer size + 1, if != 0, all received chunks are modified to have a size which is 0 mod (buffer_size) */
size_t index; /**< amount of data currently stored in buffer */
uint8_t *data; /**< data stored from previous chunk */
off_t next_offset; /**< store the next offset value */
} belle_sip_body_handler_buffer_t;
/**
* Clone a belle_sip_body_handler_buffer_t structure
*/
static void belle_sip_body_handler_buffer_clone(belle_sip_body_handler_buffer_t *dst, const belle_sip_body_handler_buffer_t *src) {
dst->size=src->size;
dst->index=src->index;
dst->next_offset=src->next_offset;
if (src->data != NULL) {
dst->data=(uint8_t *)belle_sip_malloc(src->size);
memcpy(dst->data, src->data, src->size);
} else {
dst->data=NULL;
}
}
/*
* Buffer the received data if needed
* if buffer.size is not 0, reorganise the incoming data to deliver chunk of which size is 0 mod buffer.size
*
* @param[in/out] buffer holds buffer and indexes
* @param[in/out] offset points at the end of processed data
* @param[in] input points to the incoming data
* @param[out output points to the data affected by the buffering
* @param[in/out] size of the incoming buffer and of the outgoing one
* @param[out] free_output_flag set to TRUE if the caller must free the output buffer after usage
*/
static void belle_sip_buffering_recv(belle_sip_body_handler_buffer_t *buffer, off_t *offset, uint8_t *input, uint8_t **output, size_t *size, bool_t *free_output_flag) {
*free_output_flag=FALSE; // default is: do not free the output
/* Do we need to buffer stuff ? */
if (buffer->size > 0) {
size_t bufferized_size = buffer->index;
*offset = buffer->next_offset; /* adjust the offset to keep track of past bufferized parts */
size_t total_size = buffer->index+*size;
if (total_size >= buffer->size) { /* we have enough data to produce a chunk of at least buffer size */
/* we must bufferize what is over for next time */
buffer->index = total_size%buffer->size; /* save the pointer to the part we shall bufferize as we cannot crash the buffer yet */
uint8_t *next_buffer_input = input + *size - buffer->index;
*size = total_size - buffer->index; /* size must be 0 mod (buffer index) */
buffer->next_offset += (off_t)*size;
/* create this chunk */
if (bufferized_size > 0) { /* if we had some previously buffered data, prepend, otherwise, directly use the input, the modified size will do the trick */
*output = (uint8_t *)belle_sip_malloc(*size);
memcpy(*output, buffer->data, bufferized_size);
memcpy(*output+bufferized_size, input, *size-bufferized_size);
*free_output_flag=TRUE;
} else {
*output = input;
}
/* crash the buffer with content needed for next round */
memcpy(buffer->data, next_buffer_input, buffer->index);
} else if (*size == 0 ) { /* this is the end, pass the content of the buffer */
*size = buffer->index;
buffer->next_offset += (off_t)*size;
*output = buffer->data;
} else { /* just add the current chunk into the buffer */
memcpy(buffer->data+buffer->index, input, *size);
buffer->index += *size;
*size = 0; /* be sure we won't do anything with current data */
*output=NULL;
}
} else { /* nothing to do, just pass the input */
*output = input;
}
}
/*
* User body handler implementation
*/
struct belle_sip_user_body_handler{
belle_sip_body_handler_t base;
belle_sip_user_body_handler_start_callback_t start_cb;
belle_sip_user_body_handler_recv_callback_t recv_cb;
belle_sip_user_body_handler_send_callback_t send_cb;
belle_sip_user_body_handler_stop_callback_t stop_cb;
belle_sip_body_handler_buffer_t buffer;
};
static void belle_sip_user_body_handler_destroy(belle_sip_user_body_handler_t *obj) {
if (obj->buffer.data) {
belle_sip_free(obj->buffer.data);
obj->buffer.data=NULL;
}
};
static void belle_sip_user_body_handler_begin_transfer(belle_sip_body_handler_t *base) {
belle_sip_user_body_handler_t *obj = (belle_sip_user_body_handler_t *)base;
if (obj->start_cb)
obj->start_cb((belle_sip_user_body_handler_t*)base, base->user_data);
}
static void belle_sip_user_body_handler_recv_chunk(belle_sip_body_handler_t *base, belle_sip_message_t *msg, off_t offset, uint8_t *buf, size_t size){
belle_sip_user_body_handler_t *obj=(belle_sip_user_body_handler_t*)base;
if (obj->recv_cb) {
/* buffer the incoming data if requested */
uint8_t *bufferized_data = NULL;
bool_t free_output_flag = FALSE;
belle_sip_buffering_recv(&(obj->buffer), &offset, buf, &bufferized_data, &size, &free_output_flag);
/* send it to the callback if there is data to process */
if (size > 0) {
obj->recv_cb((belle_sip_user_body_handler_t*)base, msg, base->user_data, offset, bufferized_data, size);
}
/* cleaning */
if (free_output_flag) {
belle_sip_free(bufferized_data);
}
} else {
belle_sip_warning("belle_sip_user_body_handler_t ignoring received chunk.");
}
}
static int belle_sip_user_body_handler_send_chunk(belle_sip_body_handler_t *base, belle_sip_message_t *msg, off_t offset, uint8_t *buf, size_t *size){
belle_sip_user_body_handler_t *obj=(belle_sip_user_body_handler_t*)base;
if (obj->send_cb)
return obj->send_cb((belle_sip_user_body_handler_t*)base, msg, base->user_data, offset, buf, size);
else belle_sip_warning("belle_sip_user_body_handler_t ignoring send chunk.");
*size=0;
return BELLE_SIP_STOP;
}
static void belle_sip_user_body_handler_end_transfer(belle_sip_body_handler_t *base) {
belle_sip_user_body_handler_t *obj = (belle_sip_user_body_handler_t *)base;
/* Are we bufferizing things ? */
if (obj->buffer.size > 0 && obj->buffer.index > 0) {
/* call the recv_chunk function with the buffer content */
belle_sip_user_body_handler_recv_chunk(base, NULL, obj->buffer.next_offset, NULL, 0);
}
if (obj->stop_cb)
obj->stop_cb((belle_sip_user_body_handler_t*)base, base->user_data);
}
static void belle_sip_user_body_handler_clone(belle_sip_user_body_handler_t *obj, const belle_sip_user_body_handler_t *orig){
obj->start_cb=orig->start_cb;
obj->recv_cb=orig->recv_cb;
obj->send_cb=orig->send_cb;
obj->stop_cb=orig->stop_cb;
belle_sip_body_handler_buffer_clone(&(obj->buffer), &(orig->buffer));
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_user_body_handler_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_user_body_handler_t)
{
{
BELLE_SIP_VPTR_INIT(belle_sip_user_body_handler_t,belle_sip_body_handler_t,TRUE),
(belle_sip_object_destroy_t)belle_sip_user_body_handler_destroy,
(belle_sip_object_clone_t)belle_sip_user_body_handler_clone,
NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
belle_sip_user_body_handler_begin_transfer,
belle_sip_user_body_handler_begin_transfer,
belle_sip_user_body_handler_end_transfer,
belle_sip_user_body_handler_recv_chunk,
belle_sip_user_body_handler_send_chunk
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
belle_sip_user_body_handler_t *belle_sip_user_body_handler_new(
size_t total_size,
belle_sip_body_handler_progress_callback_t progress_cb,
belle_sip_user_body_handler_start_callback_t start_cb,
belle_sip_user_body_handler_recv_callback_t recv_cb,
belle_sip_user_body_handler_send_callback_t send_cb,
belle_sip_user_body_handler_stop_callback_t stop_cb,
void *data){
belle_sip_user_body_handler_t * obj=belle_sip_object_new(belle_sip_user_body_handler_t);
belle_sip_body_handler_init((belle_sip_body_handler_t*)obj,progress_cb,data);
obj->base.expected_size=total_size;
obj->start_cb=start_cb;
obj->recv_cb=recv_cb;
obj->send_cb=send_cb;
obj->stop_cb=stop_cb;
obj->buffer.size=0;
obj->buffer.index=0;
obj->buffer.data=NULL;
obj->buffer.next_offset=0;
return obj;
}
belle_sip_user_body_handler_t *belle_sip_buffering_user_body_handler_new(
size_t total_size,
size_t buffer_size,
belle_sip_body_handler_progress_callback_t progress_cb,
belle_sip_user_body_handler_start_callback_t start_cb,
belle_sip_user_body_handler_recv_callback_t recv_cb,
belle_sip_user_body_handler_send_callback_t send_cb,
belle_sip_user_body_handler_stop_callback_t stop_cb,
void *data){
belle_sip_user_body_handler_t *obj = belle_sip_user_body_handler_new(total_size, progress_cb, start_cb, recv_cb, send_cb, stop_cb, data);
obj->buffer.size=buffer_size;
obj->buffer.data=(uint8_t *)belle_sip_malloc(buffer_size);
return obj;
}
/**
* File body handler implementation
**/
struct belle_sip_file_body_handler{
belle_sip_body_handler_t base;
char *filepath;
bctbx_vfs_file_t *file;
belle_sip_user_body_handler_t *user_bh;
belle_sip_body_handler_buffer_t buffer;
};
static void belle_sip_file_body_handler_destroy(belle_sip_file_body_handler_t *obj) {
if (obj->filepath) belle_sip_free(obj->filepath);
if (obj->file) {
ssize_t ret;
ret = bctbx_file_close(obj->file);
if (ret == BCTBX_VFS_ERROR) {
bctbx_error("Can't close file %s", obj->filepath);
}
obj->file = NULL;
}
if (obj->buffer.data) {
belle_sip_free(obj->buffer.data);
obj->buffer.data=NULL;
}
if (obj->user_bh) {
belle_sip_object_unref(obj->user_bh);
obj->user_bh = NULL;
}
}
static void belle_sip_file_body_handler_clone(belle_sip_file_body_handler_t *obj, const belle_sip_file_body_handler_t *orig) {
obj->filepath = belle_sip_strdup(orig->filepath);
obj->file = orig->file;
obj->user_bh = orig->user_bh;
if (obj->user_bh) {
belle_sip_object_ref(obj->user_bh);
} else {
obj->user_bh = NULL;
}
belle_sip_body_handler_buffer_clone(&(obj->buffer), &(orig->buffer));
}
static void belle_sip_file_body_handler_begin_recv_transfer(belle_sip_body_handler_t *base) {
belle_sip_file_body_handler_t *obj = (belle_sip_file_body_handler_t *)base;
bctbx_vfs_t *vfs = bctbx_vfs_get_default();
if (obj->filepath == NULL) return;
obj->file = bctbx_file_open(vfs, obj->filepath, "r+");
if (!obj->file) {
bctbx_error("Can't open file %s", obj->filepath);
}
if (obj->user_bh && obj->user_bh->start_cb) {
obj->user_bh->start_cb((belle_sip_user_body_handler_t*)&(obj->user_bh->base), obj->user_bh->base.user_data);
}
}
static void belle_sip_file_body_handler_begin_send_transfer(belle_sip_body_handler_t *base) {
belle_sip_file_body_handler_t *obj = (belle_sip_file_body_handler_t *)base;
bctbx_vfs_t *vfs = bctbx_vfs_get_default();
if (obj->filepath == NULL) return;
obj->file = bctbx_file_open(vfs, obj->filepath, "r");
if (!obj->file) {
bctbx_error("Can't open file %s", obj->filepath);
}
if (obj->user_bh && obj->user_bh->start_cb) {
obj->user_bh->start_cb((belle_sip_user_body_handler_t*)&(obj->user_bh->base), obj->user_bh->base.user_data);
}
}
static void belle_sip_file_body_handler_recv_chunk(belle_sip_body_handler_t *base, belle_sip_message_t *msg, off_t offset, uint8_t *buf, size_t size) {
belle_sip_file_body_handler_t *obj = (belle_sip_file_body_handler_t *)base;
ssize_t ret=0;
if (obj->file == NULL) return;
uint8_t *bufferized_data = NULL;
bool_t free_output_flag = FALSE;
if (obj->user_bh && obj->user_bh->recv_cb) {
// pass the incoming data through buffering
belle_sip_buffering_recv(&(obj->buffer), &offset, buf, &bufferized_data, &size, &free_output_flag);
if (size>0) {
obj->user_bh->recv_cb((belle_sip_user_body_handler_t*)&(obj->user_bh->base), msg, obj->user_bh->base.user_data, offset, bufferized_data, size);
}
}
if (size > 0 ) {
ret = bctbx_file_write(obj->file, bufferized_data, size, offset);
}
if (free_output_flag == TRUE) {
belle_sip_free(bufferized_data);
}
if (ret == BCTBX_VFS_ERROR) {
bctbx_error("File body handler recv write error at offset %lu", (unsigned long)offset);
}
}
static void belle_sip_file_body_handler_end_transfer(belle_sip_body_handler_t *base) {
belle_sip_file_body_handler_t *obj = (belle_sip_file_body_handler_t *)base;
/* Are we bufferizing things ? */
if (obj->buffer.size > 0 && obj->buffer.index > 0) {
/* call the recv_chunk function with the buffer content */
belle_sip_file_body_handler_recv_chunk(base, NULL, obj->buffer.next_offset, NULL, 0);
}
if (obj->file) {// Close the file before calling stop callback to let cb to do file modifications like renaming.
ssize_t ret;
ret = bctbx_file_close(obj->file);
if (ret == BCTBX_VFS_ERROR) {
bctbx_error("Can't close file %s", obj->filepath);
}
obj->file = NULL;
}
if (obj->user_bh && obj->user_bh->stop_cb) {
obj->user_bh->stop_cb((belle_sip_user_body_handler_t*)&(obj->user_bh->base), obj->user_bh->base.user_data);
}
}
static int belle_sip_file_body_handler_send_chunk(belle_sip_body_handler_t *base, belle_sip_message_t *msg, off_t offset, uint8_t *buf, size_t *size) {
belle_sip_file_body_handler_t *obj = (belle_sip_file_body_handler_t *)base;
ssize_t size_t_ret;
size_t to_send = MIN(*size, obj->base.expected_size - offset);
if (obj->file == NULL) return BELLE_SIP_STOP;
size_t_ret = bctbx_file_read(obj->file, buf, to_send, offset);
if (size_t_ret == BCTBX_VFS_ERROR) {
bctbx_error("File body handler send read error at offset %lu", (unsigned long)offset);
return BELLE_SIP_STOP;
}
*size = (size_t)size_t_ret;
if (obj->user_bh && obj->user_bh->send_cb) {
int result = obj->user_bh->send_cb((belle_sip_user_body_handler_t*)&(obj->user_bh->base), msg, obj->user_bh->base.user_data, offset, buf, size);
if (result == BELLE_SIP_STOP) return result;
}
return (((obj->base.expected_size - offset) == (size_t)size_t_ret) || (*size == 0)) ? BELLE_SIP_STOP : BELLE_SIP_CONTINUE;
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_file_body_handler_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_file_body_handler_t)
{
{
BELLE_SIP_VPTR_INIT(belle_sip_file_body_handler_t,belle_sip_body_handler_t,TRUE),
(belle_sip_object_destroy_t) belle_sip_file_body_handler_destroy,
(belle_sip_object_clone_t)belle_sip_file_body_handler_clone,
NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
belle_sip_file_body_handler_begin_recv_transfer,
belle_sip_file_body_handler_begin_send_transfer,
belle_sip_file_body_handler_end_transfer,
belle_sip_file_body_handler_recv_chunk,
belle_sip_file_body_handler_send_chunk
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
belle_sip_file_body_handler_t *belle_sip_file_body_handler_new(const char *filepath, belle_sip_body_handler_progress_callback_t progress_cb, void *data) {
// Get file size if it exists
int64_t expected_size = BCTBX_VFS_ERROR;
struct stat statbuf;
if (stat(filepath, &statbuf) == 0) {
bctbx_vfs_t *vfs = bctbx_vfs_get_default();
bctbx_vfs_file_t *fp = bctbx_file_open(vfs, filepath, "r");
expected_size = bctbx_file_size(fp);
bctbx_file_close(fp);
}
belle_sip_file_body_handler_t *obj = belle_sip_object_new(belle_sip_file_body_handler_t);
belle_sip_body_handler_init((belle_sip_body_handler_t*)obj, progress_cb, data);
obj->filepath = belle_sip_strdup(filepath);
obj->user_bh = NULL;
if (expected_size != BCTBX_VFS_ERROR) {
obj->base.expected_size = (size_t)expected_size;
belle_sip_message("file body handler created for file [%s] with size [%zu]", filepath, obj->base.expected_size);
} else {
belle_sip_message("file body handler created for file [%s] with unknown size", filepath);
}
obj->buffer.size=0;
obj->buffer.index=0;
obj->buffer.data=NULL;
obj->buffer.next_offset=0;
return obj;
}
belle_sip_file_body_handler_t *belle_sip_buffering_file_body_handler_new(const char *filepath, const size_t buffer_size, belle_sip_body_handler_progress_callback_t progress_cb, void *data) {
belle_sip_file_body_handler_t *obj = belle_sip_file_body_handler_new(filepath, progress_cb, data);
obj->buffer.size=buffer_size;
obj->buffer.data=(uint8_t *)belle_sip_malloc(buffer_size);
return obj;
}
size_t belle_sip_file_body_handler_get_file_size(belle_sip_file_body_handler_t *file_bh) {
return file_bh->base.expected_size;
}
void belle_sip_file_body_handler_set_user_body_handler(belle_sip_file_body_handler_t *file_bh, belle_sip_user_body_handler_t *user_bh) {
if (file_bh) {
file_bh->user_bh = user_bh;
belle_sip_object_ref(file_bh->user_bh);
}
}
/*
* Multipart body handler implementation
* TODO
**/
static void belle_sip_multipart_body_handler_parse_final(belle_sip_multipart_body_handler_t *obj);
struct belle_sip_multipart_body_handler{
belle_sip_body_handler_t base;
belle_sip_list_t *parts;
belle_sip_list_t *transfer_current_part;
char *boundary;
uint8_t *buffer;
unsigned int related;
};
GET_SET_BOOL(belle_sip_multipart_body_handler,related,is);
static void belle_sip_multipart_body_handler_destroy(belle_sip_multipart_body_handler_t *obj){
belle_sip_list_free_with_data(obj->parts,belle_sip_object_unref);
if (obj->buffer != NULL) belle_sip_free(obj->buffer);
if (obj->boundary != NULL) belle_sip_free(obj->boundary);
}
static void belle_sip_multipart_body_handler_clone(belle_sip_multipart_body_handler_t *obj, const belle_sip_multipart_body_handler_t*other){
belle_sip_fatal("belle_sip_multipart_body_handler_clone() not implemenented.");
}
static void belle_sip_multipart_body_handler_begin_recv_transfer(belle_sip_body_handler_t *obj) {
const belle_sip_list_t *it;
belle_sip_multipart_body_handler_t *obj_multipart = (belle_sip_multipart_body_handler_t *)obj;
for (it = obj_multipart->parts; it != NULL; it = it->next) {
belle_sip_body_handler_t *bh = BELLE_SIP_BODY_HANDLER(it->data);
belle_sip_body_handler_begin_recv_transfer(bh);
}
obj_multipart->transfer_current_part = obj_multipart->parts;
}
static void belle_sip_multipart_body_handler_begin_send_transfer(belle_sip_body_handler_t *obj) {
const belle_sip_list_t *it;
belle_sip_multipart_body_handler_t *obj_multipart = (belle_sip_multipart_body_handler_t *)obj;
for (it = obj_multipart->parts; it != NULL; it = it->next) {
belle_sip_body_handler_t *bh = BELLE_SIP_BODY_HANDLER(it->data);
belle_sip_body_handler_begin_send_transfer(bh);
}
obj_multipart->transfer_current_part = obj_multipart->parts;
}
static void belle_sip_multipart_body_handler_end_transfer(belle_sip_body_handler_t *obj) {
const belle_sip_list_t *it;
belle_sip_multipart_body_handler_t *obj_multipart = (belle_sip_multipart_body_handler_t *)obj;
if (obj_multipart->parts == NULL){
/* this was a receive transfer */
belle_sip_multipart_body_handler_parse_final(obj_multipart);
}else{
for (it = obj_multipart->parts; it != NULL; it = it->next) {
belle_sip_body_handler_t *bh = BELLE_SIP_BODY_HANDLER(it->data);
belle_sip_body_handler_end_transfer(bh);
}
obj_multipart->transfer_current_part = NULL;
}
}
static void belle_sip_multipart_body_handler_recv_chunk(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, off_t offset,
uint8_t *buffer, size_t size){
/* Store the whole buffer, the parts will be split when belle_sip_multipart_body_handler_progress_cb() is called with transfered size equal to expected size. */
belle_sip_multipart_body_handler_t *obj_multipart = (belle_sip_multipart_body_handler_t *)obj;
obj_multipart->buffer = belle_sip_realloc(obj_multipart->buffer,offset + size + 1);
memcpy(obj_multipart->buffer + offset, buffer, size);
obj_multipart->buffer[offset + size] = '\0';
}
static int belle_sip_multipart_body_handler_send_chunk(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, off_t offset,
uint8_t *buffer, size_t *size){
belle_sip_multipart_body_handler_t *obj_multipart=(belle_sip_multipart_body_handler_t*)obj;
if (obj_multipart->transfer_current_part && obj_multipart->transfer_current_part->data) { /* we have a part, get its content from handler */
int retval = BELLE_SIP_STOP;
size_t offsetSize = 0; /* used to store size of data added by this function and not given by the body handler of current part */
size_t boundary_len = strlen(obj_multipart->boundary);
belle_sip_body_handler_t *current_part = (belle_sip_body_handler_t *)obj_multipart->transfer_current_part->data;
*size -= strlen(obj_multipart->boundary) + 8; /* just in case it will be the end of the message, ask for less characters than possible in order to be able to add the multipart message termination. 8 is for "\r\n--" and "--\r\n" */
if (current_part->transfered_size == 0) { /* Nothing transfered yet on this part, include a separator and the header if exists */
size_t headersSize = 0;
if (current_part != (belle_sip_body_handler_t *)obj_multipart->parts->data) {
offsetSize += 2; /*delimiter := CRLF dash-boundary*/
}
offsetSize += boundary_len + 4; /* 4 is for "--" and "\r\n" */
if (current_part->headerStringBuffer != NULL) {
headersSize = strlen(current_part->headerStringBuffer);
}
/* check if buffer is large enough to get the whole header + separtor and at least a byte of data */
if (*size < headersSize+offsetSize+1) {
return BELLE_SIP_BUFFER_OVERFLOW;
}
/* insert separator */
if (current_part != (belle_sip_body_handler_t *)obj_multipart->parts->data) {
snprintf((char*)buffer, *size, "\r\n--%s\r\n",obj_multipart->boundary); /*delimiter := CRLF dash-boundary*/
} else {
snprintf((char*)buffer, *size, "--%s\r\n",obj_multipart->boundary);
}
/* insert part header */
if (headersSize!=0) {
memcpy(buffer+offsetSize, current_part->headerStringBuffer, headersSize);
offsetSize += headersSize;
}
*size -=offsetSize; /* decrease data length requested to the current part handler */
}
retval = belle_sip_body_handler_send_chunk(current_part, msg, buffer+offsetSize, size); /* add offsetSize to the buffer address in order to point at the begining of free space (after header if included) */
*size +=offsetSize; /* restore total of data given including potential separator and header */
if (retval == BELLE_SIP_CONTINUE) {
return BELLE_SIP_CONTINUE; /* there is still data to be sent, continue */
} else { /* this part has reach the end, pass to next one if there is one */
if (obj_multipart->transfer_current_part->next!=NULL) { /* there is an other part to be sent */
obj_multipart->transfer_current_part = belle_sip_list_next(obj_multipart->transfer_current_part);
return BELLE_SIP_CONTINUE;
} else { /* there is nothing else, close the message and return STOP */
size_t boundary_len = strlen(obj_multipart->boundary);
memcpy(buffer + *size, "\r\n--", 4);
memcpy(buffer + *size + 4, obj_multipart->boundary, boundary_len);
memcpy(buffer + *size + 4 + boundary_len, "--\r\n", 4);
*size+=boundary_len + 8;
return BELLE_SIP_STOP;
}
}
}
return BELLE_SIP_STOP;
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_multipart_body_handler_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_multipart_body_handler_t)
{
{
BELLE_SIP_VPTR_INIT(belle_sip_multipart_body_handler_t,belle_sip_body_handler_t,TRUE),
(belle_sip_object_destroy_t) belle_sip_multipart_body_handler_destroy,
(belle_sip_object_clone_t)belle_sip_multipart_body_handler_clone,
NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
belle_sip_multipart_body_handler_begin_recv_transfer,
belle_sip_multipart_body_handler_begin_send_transfer,
belle_sip_multipart_body_handler_end_transfer,
belle_sip_multipart_body_handler_recv_chunk,
belle_sip_multipart_body_handler_send_chunk
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
static const char *boundary_charset = "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789-";
static void belle_sip_multipart_body_handler_set_boundary(belle_sip_multipart_body_handler_t *obj, const char *boundary) {
if (obj->boundary != NULL) {
belle_sip_free(obj->boundary);
}
if (boundary != NULL) {
obj->boundary = belle_sip_strdup(boundary);
} else {
char random_token[60];// Use a random boundary to reduce the probability of having the same boundary in file (like uploading file logs with file transfer).
obj->boundary = belle_sip_strdup_printf("----------%s", belle_sip_random_token_with_charset(random_token, sizeof(random_token), boundary_charset, 63));
}
}
const char *belle_sip_multipart_body_handler_get_boundary(const belle_sip_multipart_body_handler_t *obj) {
return obj->boundary;
}
belle_sip_multipart_body_handler_t *belle_sip_multipart_body_handler_new(belle_sip_body_handler_progress_callback_t progress_cb, void *data,
belle_sip_body_handler_t *first_part, const char *boundary){
belle_sip_multipart_body_handler_t *obj=belle_sip_object_new(belle_sip_multipart_body_handler_t);
belle_sip_body_handler_init((belle_sip_body_handler_t*)obj,progress_cb,data);
belle_sip_multipart_body_handler_set_boundary(obj, boundary);
obj->base.expected_size = strlen(obj->boundary) + 8; /* body's length will be part length(including boundary) + multipart end. 8 is for "\r\n--" and "--\r\n" */
if (first_part) belle_sip_multipart_body_handler_add_part(obj,first_part);
return obj;
}
belle_sip_multipart_body_handler_t *belle_sip_multipart_body_handler_new_from_buffer(const void *buffer, size_t bufsize, const char *boundary) {
belle_sip_multipart_body_handler_t *obj_multipart = belle_sip_object_new(belle_sip_multipart_body_handler_t);
belle_sip_body_handler_t *obj = (belle_sip_body_handler_t *)obj_multipart;
belle_sip_body_handler_init((belle_sip_body_handler_t *)obj, NULL, NULL);
belle_sip_multipart_body_handler_set_boundary(obj_multipart, boundary);
obj_multipart->base.expected_size = bufsize;
belle_sip_body_handler_begin_recv_transfer(obj);
belle_sip_body_handler_recv_chunk(obj, NULL, (uint8_t *)buffer, bufsize);
belle_sip_body_handler_end_transfer(obj);
return obj_multipart;
}
#define DEFAULT_HEADER_STRING_SIZE 512
void belle_sip_multipart_body_handler_add_part(belle_sip_multipart_body_handler_t *obj, belle_sip_body_handler_t *part){
if (obj->parts != NULL) {
obj->base.expected_size += 2; /*delimiter := CRLF dash-boundary*/
//add initial CRLF*/
}
obj->base.expected_size+=part->expected_size+strlen(obj->boundary) + 4; /* add the separator length to the body length as each part start with a separator. 4 is for "--" and "\r\n" */
if (part->headers != NULL) { /* there is a declared header for this part, add its length to the expected total length */
size_t headerStringBufferSize = DEFAULT_HEADER_STRING_SIZE;
size_t offset = 0;
belle_sip_list_t *headerList = part->headers;
part->headerStringBuffer = (char *)belle_sip_malloc(DEFAULT_HEADER_STRING_SIZE);
while (headerList != NULL) {
size_t offsetBackup=offset; /* we must backup the offset as it will be messed up by the marshal function in case of failure */
belle_sip_error_code returnCode = belle_sip_object_marshal(headerList->data, part->headerStringBuffer, headerStringBufferSize-5, &offset); /* -5 to leave room for carriage returns */
if (returnCode == BELLE_SIP_BUFFER_OVERFLOW) { /* increase buffer size */
offset=offsetBackup; /* restore the offset, no data were written to the buffer */
headerStringBufferSize+=DEFAULT_HEADER_STRING_SIZE;
part->headerStringBuffer = (char *)belle_sip_realloc(part->headerStringBuffer, headerStringBufferSize);
} else if (returnCode == BELLE_SIP_OK) { /* add the carriage return chars */
part->headerStringBuffer[offset++]='\r';
part->headerStringBuffer[offset++]='\n';
headerList = belle_sip_list_next(headerList);
}
}
part->headerStringBuffer[offset++]='\r';
part->headerStringBuffer[offset++]='\n';
obj->base.expected_size += offset;
part->headerStringBuffer[offset++]='\0'; /* null terminate the buffer in order to be able to get it length later using strlen */
}
obj->parts=belle_sip_list_append(obj->parts,belle_sip_object_ref(part));
}
const belle_sip_list_t* belle_sip_multipart_body_handler_get_parts(const belle_sip_multipart_body_handler_t *obj) {
return obj->parts;
}
static void belle_sip_multipart_body_handler_parse_final(belle_sip_multipart_body_handler_t *obj_multipart){
/* The full multipart body has been received, we can now parse it and split the different parts,
* creating a belle_sip_memory_body_handler for each part and adding them to the belle_sip_multipart_body_handler
* parts list. */
belle_sip_memory_body_handler_t *memorypart;
belle_sip_header_t *header;
uint8_t *end_part_cursor;
uint8_t *end_headers_cursor;
uint8_t *end_header_cursor;
uint8_t *cursor = obj_multipart->buffer;
char *dash_boundary = belle_sip_strdup_printf("--%s", obj_multipart->boundary);
size_t expected_size = obj_multipart->base.expected_size; /* Save expected size. Indeed add_parts() plays with it
* for the composing process. For parsing process we actually don't need this, so the correct size will be restored at the end.*/
if (strncmp((char *)cursor, dash_boundary, strlen(dash_boundary))) {
belle_sip_warning("belle_sip_multipart_body_handler [%p]: body not starting by specified boundary '%s'", obj_multipart, obj_multipart->boundary);
belle_sip_free(dash_boundary);
return;
}
cursor += strlen(dash_boundary);
do {
bool_t delimiter_contains_crlf = FALSE;
if (strncmp((char *)cursor, "\r\n", 2)) {
belle_sip_warning("belle_sip_multipart_body_handler [%p]: no new-line after boundary", obj_multipart);
belle_sip_free(dash_boundary);
return;
}
cursor += 2;
end_part_cursor = (uint8_t *)strstr((char *)cursor, dash_boundary);
if (end_part_cursor == NULL) {
belle_sip_error("belle_sip_multipart_body_handler [%p]: cannot find next boundary", obj_multipart);
belle_sip_free(dash_boundary);
return;
} else {
if (*(end_part_cursor-1) == '\n' && *(end_part_cursor-2) == '\r') {
end_part_cursor-=2; /* delimiter is well formed: delimiter := CRLF dash-boundary */
delimiter_contains_crlf = TRUE;
}
*end_part_cursor = 0;
end_headers_cursor = (uint8_t *)strstr((char *)cursor, "\r\n\r\n");
if (end_headers_cursor == NULL) {
memorypart = belle_sip_memory_body_handler_new_copy_from_buffer(cursor, strlen((char *)cursor), NULL, NULL);
} else {
uint8_t *begin_body_cursor = end_headers_cursor + 4;
memorypart = belle_sip_memory_body_handler_new_copy_from_buffer(begin_body_cursor, strlen((char *)begin_body_cursor), NULL, NULL);
do {
end_header_cursor = (uint8_t *)strstr((char *)cursor, "\r\n");
*end_header_cursor = 0;
header = belle_sip_header_parse((char *)cursor);
if (header != NULL) {
belle_sip_body_handler_add_header(BELLE_SIP_BODY_HANDLER(memorypart), header);
}
cursor = end_header_cursor + 2;
} while (end_header_cursor != end_headers_cursor);
}
belle_sip_multipart_body_handler_add_part(obj_multipart, BELLE_SIP_BODY_HANDLER(memorypart));
cursor = end_part_cursor + strlen(dash_boundary);
if (delimiter_contains_crlf)
cursor += 2;
}
} while (strncmp((char *)cursor, "--\r\n", 4));
belle_sip_free(dash_boundary);
obj_multipart->base.expected_size = expected_size;
}
belle-sip-5.2.0+dfsg/src/channel.c 0000664 0000000 0000000 00000175452 14346131365 0016700 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "belle_sip_internal.h"
#include
#include
#include
#ifdef __ANDROID__
#include "wakelock_internal.h"
#endif
#define BELLE_SIP_CHANNEL_INVOKE_MESSAGE_HEADERS_LISTENERS(channel,msg) \
BELLE_SIP_INVOKE_LISTENERS_ARG1_ARG2(channel->full_listeners, belle_sip_channel_listener_t, on_message_headers, channel, msg)
#define BELLE_SIP_CHANNEL_INVOKE_SENDING_LISTENERS(channel,msg) \
BELLE_SIP_INVOKE_LISTENERS_ARG1_ARG2(channel->full_listeners, belle_sip_channel_listener_t, on_sending, channel, msg)
#define BELLE_SIP_CHANNEL_INVOKE_STATE_LISTENERS(channel,state) \
BELLE_SIP_INVOKE_LISTENERS_REVERSE_ARG1_ARG2(channel->full_listeners, belle_sip_channel_listener_t, on_state_changed, channel, state) \
BELLE_SIP_INVOKE_LISTENERS_REVERSE_ARG1_ARG2(channel->state_listeners, belle_sip_channel_listener_t, on_state_changed, channel, state)
static void channel_prepare_continue(belle_sip_channel_t *obj);
static void channel_process_queue(belle_sip_channel_t *obj);
static void channel_begin_send_background_task(belle_sip_channel_t *obj);
static void channel_end_send_background_task(belle_sip_channel_t *obj);
static void channel_begin_recv_background_task(belle_sip_channel_t *obj);
static void channel_end_recv_background_task(belle_sip_channel_t *obj);
static void channel_process_queue(belle_sip_channel_t *obj);
static char *make_logbuf(belle_sip_channel_t *obj, belle_sip_log_level level, const char *buffer, size_t size);
static void channel_remove_listener(belle_sip_channel_t *obj, belle_sip_channel_listener_t *l);
static void free_ewouldblock_buffer(belle_sip_channel_t *obj);
const char *belle_sip_channel_state_to_string(belle_sip_channel_state_t state){
switch(state){
case BELLE_SIP_CHANNEL_INIT:
return "INIT";
case BELLE_SIP_CHANNEL_RES_IN_PROGRESS:
return "RES_IN_PROGRESS";
case BELLE_SIP_CHANNEL_RES_DONE:
return "RES_DONE";
case BELLE_SIP_CHANNEL_CONNECTING:
return "CONNECTING";
case BELLE_SIP_CHANNEL_RETRY:
return "RETRY";
case BELLE_SIP_CHANNEL_READY:
return "READY";
case BELLE_SIP_CHANNEL_ERROR:
return "ERROR";
case BELLE_SIP_CHANNEL_DISCONNECTED:
return "DISCONNECTED";
}
return "BAD";
}
static belle_sip_list_t * for_each_weak_unref_free(belle_sip_list_t *l, belle_sip_object_destroy_notify_t notify, void *ptr){
belle_sip_list_t *elem,*next;
for(elem=l;elem!=NULL;elem=next){
next=elem->next;
belle_sip_object_weak_unref(elem->data,notify,ptr);
belle_sip_free(elem);
}
return NULL;
}
static void belle_sip_channel_input_stream_rewind(belle_sip_channel_input_stream_t* input_stream){
int remaining;
remaining=(int)(input_stream->write_ptr-input_stream->read_ptr);
if (remaining>0){
/* copy remaning bytes at top of buffer*/
memmove(input_stream->buff,input_stream->read_ptr,remaining);
input_stream->read_ptr=input_stream->buff;
input_stream->write_ptr=input_stream->buff+remaining;
*input_stream->write_ptr='\0';
}else{
input_stream->read_ptr=input_stream->write_ptr=input_stream->buff;
}
}
static void belle_sip_channel_input_stream_reset(belle_sip_channel_input_stream_t* input_stream) {
belle_sip_channel_input_stream_rewind(input_stream);
input_stream->state=WAITING_MESSAGE_START;
if (input_stream->msg != NULL) belle_sip_object_unref(input_stream->msg);
input_stream->msg=NULL;
input_stream->chuncked_mode=FALSE;
input_stream->content_length=-1;
}
static size_t belle_sip_channel_input_stream_get_buff_length(belle_sip_channel_input_stream_t* input_stream) {
return sizeof(input_stream->buff) - (input_stream->write_ptr-input_stream->buff);
}
static void belle_sip_channel_destroy(belle_sip_channel_t *obj){
belle_sip_channel_input_stream_reset(&obj->input_stream);
if (obj->peer_cname) belle_sip_free(obj->peer_cname);
belle_sip_free(obj->peer_name);
if (obj->local_ip) belle_sip_free(obj->local_ip);
obj->state_listeners=for_each_weak_unref_free(obj->state_listeners,(belle_sip_object_destroy_notify_t)channel_remove_listener,obj);
obj->full_listeners=for_each_weak_unref_free(obj->full_listeners,(belle_sip_object_destroy_notify_t)channel_remove_listener,obj);
if (obj->resolver_ctx != NULL) {
belle_sip_resolver_context_cancel(obj->resolver_ctx);
belle_sip_object_unref(obj->resolver_ctx);
}
SET_OBJECT_PROPERTY(obj, resolver_results, NULL);
if (obj->static_peer_list) bctbx_freeaddrinfo(obj->static_peer_list);
if (obj->inactivity_timer){
belle_sip_main_loop_remove_source(obj->stack->ml,obj->inactivity_timer);
belle_sip_object_unref(obj->inactivity_timer);
}
if (obj->dns_ttl_timer) {
belle_sip_main_loop_remove_source(obj->stack->ml, obj->dns_ttl_timer);
belle_sip_object_unref(obj->dns_ttl_timer);
}
if (obj->public_ip) belle_sip_free(obj->public_ip);
if (obj->outgoing_messages) belle_sip_list_free_with_data(obj->outgoing_messages,belle_sip_object_unref);
if (obj->incoming_messages) belle_sip_list_free_with_data(obj->incoming_messages,belle_sip_object_unref);
free_ewouldblock_buffer(obj);
if (obj->cur_out_message){
belle_sip_object_unref(obj->cur_out_message);
obj->cur_out_message=NULL;
}
channel_end_send_background_task(obj);
channel_end_recv_background_task(obj);
/*normally this should do nothing because it sould have been terminated already,
however leaving a background task open is so dangerous that we have to be paranoid*/
belle_sip_message("Channel [%p] destroyed",obj);
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_channel_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_channel_t)
{
BELLE_SIP_VPTR_INIT(belle_sip_channel_t,belle_sip_source_t,FALSE),
(belle_sip_object_destroy_t)belle_sip_channel_destroy,
NULL, /*clone*/
NULL, /*marshal*/
NULL, /*on_first_ref*/
NULL, /*on_last_ref*/
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
NULL, /* transport */
0, /* reliable */
NULL, /* connect */
NULL, /* channel_send */
NULL, /* channel_recv */
NULL /* close */
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
static void fix_incoming_via(belle_sip_request_t *msg, const struct addrinfo* origin){
char received[NI_MAXHOST];
char rport[NI_MAXSERV];
belle_sip_header_via_t *via;
int err;
struct sockaddr_storage saddr;
socklen_t slen=sizeof(saddr);
if (!origin) {
belle_sip_warning("cannot fix via for message [%p], probably a test",msg);
return;
}
bctbx_sockaddr_remove_v4_mapping(origin->ai_addr, (struct sockaddr*)&saddr, &slen);
err=bctbx_getnameinfo(
(struct sockaddr*)&saddr,slen,received,sizeof(received),
rport,sizeof(rport),NI_NUMERICHOST|NI_NUMERICSERV
);
if (err!=0){
belle_sip_error("fix_via: getnameinfo() failed: %s",gai_strerror(errno));
return;
}
via=BELLE_SIP_HEADER_VIA(belle_sip_message_get_header((belle_sip_message_t*)msg,"via"));
if (via){
const char* host = belle_sip_header_via_get_host(via);
if (strcmp(host,received)!=0)
belle_sip_header_via_set_received(via,received);
if (belle_sip_parameters_has_parameter(BELLE_SIP_PARAMETERS(via),"rport")){
int port = belle_sip_header_via_get_listening_port(via);
int rport_int=atoi(rport);
if (rport_int!=port) belle_sip_header_via_set_rport(via,atoi(rport));
}
}
}
// token = 1*(alphanum / "-" / "." / "!" / "%" / "*" / "_" / "+" / "`" / "'" / "~" )
static int is_token(const char* buff,size_t bufflen ) {
size_t i;
for (i=0; i='0' && buff[i]<='9')
|| (buff[i]>='A' && buff[i]<='Z')
|| (buff[i]>='a' && buff[i]<='z')
|| (buff[i]=='\0'))
continue;
else
return 0;
}
}
return 1;
}
static int get_message_start_pos(char *buff, size_t bufflen) {
/*FIXME still to optimize and better test, specially REQUEST PATH and error path*/
int i;
int res=0;
int status_code;
char method[17]={0};
char saved_char1;
char sip_version[10]={0};
size_t saved_char1_index;
for(i=0; i<(int)bufflen-12;i++) { /*9=strlen( SIP/2.0\r\n)*/
switch (buff[i]) { /*to avoid this character to be ignored by scanf*/
case '\r':
case '\n':
case ' ' :
case '\t':
continue;
default:
break;
}
saved_char1_index=bufflen-1;
saved_char1=buff[saved_char1_index]; /*make sure buff is null terminated*/
buff[saved_char1_index]='\0';
res=sscanf(buff+i,"SIP/2.0 %d ",&status_code);
if (res!=1) res=sscanf(buff+i,"HTTP/1.%*i %d ",&status_code); /*might be HTTP ?*/
if (res!=1) {
res= sscanf(buff+i,"%16s %*s %9s\r\n",method,sip_version)==2
&& is_token(method,sizeof(method))
&& (strcmp("SIP/2.0",sip_version)==0 || strncmp("HTTP/1.",sip_version,strlen("HTTP/1."))==0);
}
buff[saved_char1_index]=saved_char1;
if (res==1) return i;
}
return -1;
}
void belle_sip_channel_set_public_ip_port(belle_sip_channel_t *obj, const char *public_ip, int port){
if (obj->public_ip){
int ip_changed=0;
int port_changed=0;
if (public_ip && strcmp(obj->public_ip,public_ip)!=0){
ip_changed=1;
}
if (port!=obj->public_port){
port_changed=1;
}
if (ip_changed || port_changed){
belle_sip_warning("channel [%p]: public ip is changed from [%s:%i] to [%s:%i]",obj,obj->public_ip,obj->public_port,public_ip,port);
}
belle_sip_free(obj->public_ip);
obj->public_ip=NULL;
}else if (public_ip){
belle_sip_message("channel [%p]: discovered public ip and port are [%s:%i]",obj,public_ip,port);
}
if (public_ip){
obj->public_ip=belle_sip_strdup(public_ip);
}
obj->public_port=port;
}
static void belle_sip_channel_learn_public_ip_port(belle_sip_channel_t *obj, belle_sip_response_t *resp){
belle_sip_header_via_t *via=belle_sip_message_get_header_by_type(resp,belle_sip_header_via_t);
const char *received;
int rport;
if (!via){
belle_sip_error("channel [%p]: no via in response.",obj);
return;
}
if (!(received=belle_sip_header_via_get_received(via))) {
/*use address from via*/;
received=belle_sip_header_via_get_host(via);
}
rport=belle_sip_header_via_get_rport(via);
if (rport<=0){
/* no rport, the via port might be good then*/
rport=belle_sip_header_via_get_listening_port(via);
}
belle_sip_channel_set_public_ip_port(obj,received,rport);
obj->learnt_ip_port=TRUE;
}
static void uncompress_body_if_required(belle_sip_message_t *msg) {
belle_sip_body_handler_t *bh = belle_sip_message_get_body_handler(msg);
belle_sip_memory_body_handler_t *mbh = NULL;
belle_sip_header_t *ceh = NULL;
size_t body_len = 0;
if (bh != NULL) {
body_len = belle_sip_message_get_body_size(msg);
ceh = belle_sip_message_get_header(msg, "Content-Encoding");
}
if ((body_len > 0) && (ceh != NULL)) {
const char *content_encoding = belle_sip_header_get_unparsed_value(ceh);
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(bh, belle_sip_memory_body_handler_t)) {
mbh = BELLE_SIP_MEMORY_BODY_HANDLER(bh);
if (belle_sip_memory_body_handler_unapply_encoding(mbh, content_encoding) == 0) {
belle_sip_header_content_type_t *content_type = belle_sip_message_get_header_by_type(msg, belle_sip_header_content_type_t);
belle_sip_header_content_length_t *content_length = belle_sip_message_get_header_by_type(msg, belle_sip_header_content_length_t);
belle_sip_header_content_length_set_content_length(content_length, belle_sip_body_handler_get_size(BELLE_SIP_BODY_HANDLER(mbh)));
belle_sip_message_remove_header_from_ptr(msg, ceh);
if (content_type && (strcmp(belle_sip_header_content_type_get_type(content_type), "multipart") == 0)) {
const char *boundary = belle_sip_parameters_get_parameter(BELLE_SIP_PARAMETERS(content_type), "boundary");
bh = (belle_sip_body_handler_t *)belle_sip_multipart_body_handler_new_from_buffer(
belle_sip_memory_body_handler_get_buffer(mbh), belle_sip_body_handler_get_size((belle_sip_body_handler_t *)mbh), boundary);
belle_sip_message_set_body_handler(msg, bh);
}
}
} else {
belle_sip_warning("message [%p] has Content-Encoding [%s] that cannot be unapplied", msg, content_encoding);
}
}
}
static void belle_sip_channel_message_ready(belle_sip_channel_t *obj){
belle_sip_message_t *msg=obj->input_stream.msg;
belle_sip_body_handler_t *bh=belle_sip_message_get_body_handler(msg);
if (bh) belle_sip_body_handler_end_transfer(bh);
if (belle_sip_message_is_response(msg)) belle_sip_channel_learn_public_ip_port(obj,BELLE_SIP_RESPONSE(msg));
uncompress_body_if_required(msg);
obj->incoming_messages=belle_sip_list_append(obj->incoming_messages,belle_sip_object_ref(msg));
obj->stop_logging_buffer=0;
belle_sip_channel_input_stream_reset(&obj->input_stream);
}
static void feed_body(belle_sip_channel_t *obj, size_t len){
belle_sip_message_t *msg=obj->input_stream.msg;
belle_sip_body_handler_t *bh=belle_sip_message_get_body_handler(msg);
belle_sip_body_handler_recv_chunk(bh,msg,(uint8_t*)obj->input_stream.read_ptr,len);
obj->input_stream.read_ptr+=len;
belle_sip_channel_input_stream_rewind(&obj->input_stream);
}
/*returns TRUE if a body is expected, and initialize a few things in the input stream context*/
static int check_body(belle_sip_channel_t *obj){
belle_sip_message_t *msg=obj->input_stream.msg;
belle_sip_header_content_length_t* content_length_header = belle_sip_message_get_header_by_type(msg,belle_sip_header_content_length_t);
int expect_body=FALSE;
obj->input_stream.content_length= content_length_header ? belle_sip_header_content_length_get_content_length(content_length_header) : 0;
expect_body=obj->input_stream.content_length>0;
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(msg,belle_http_response_t) || BELLE_SIP_OBJECT_IS_INSTANCE_OF(msg,belle_http_request_t)){
/*http chunked mode handling*/
if (belle_sip_message_get_header_by_type(msg, belle_sip_header_content_type_t)!=NULL){
belle_sip_header_t *transfer_encoding=belle_sip_message_get_header(msg,"Transfer-Encoding");
if (transfer_encoding){
const char *value=belle_sip_header_get_unparsed_value(transfer_encoding);
if (strstr(value,"chunked")!=0){
obj->input_stream.chuncked_mode=1;
obj->input_stream.content_length=0;
obj->input_stream.chunk_size=-1;
obj->input_stream.chunk_read_size=0;
}
}
expect_body=TRUE;
}
}
if (expect_body){
belle_sip_body_handler_t *bh;
// Should notify the listeners
BELLE_SIP_CHANNEL_INVOKE_MESSAGE_HEADERS_LISTENERS(obj,msg);
// Check if the listener has setup a body handler, otherwise create a default one
bh = belle_sip_message_get_body_handler(msg);
if (!bh) {
belle_sip_header_t *content_encoding = belle_sip_message_get_header(msg, "Content-Encoding");
belle_sip_header_content_type_t *content_type = belle_sip_message_get_header_by_type(msg, belle_sip_header_content_type_t);
if (content_encoding) {
bh = (belle_sip_body_handler_t *)belle_sip_memory_body_handler_new(NULL, NULL);
belle_sip_body_handler_add_header(bh, content_encoding);
} else if (content_type && (strcmp(belle_sip_header_content_type_get_type(content_type), "multipart") == 0)) {
const char *boundary = belle_sip_parameters_get_parameter(BELLE_SIP_PARAMETERS(content_type), "boundary");
bh = (belle_sip_body_handler_t *)belle_sip_multipart_body_handler_new(NULL, NULL, NULL, boundary);
} else {
bh = (belle_sip_body_handler_t *)belle_sip_memory_body_handler_new(NULL, NULL);
}
belle_sip_body_handler_set_size(bh, obj->input_stream.content_length);
belle_sip_body_handler_add_header(bh, BELLE_SIP_HEADER(content_length_header));
belle_sip_body_handler_add_header(bh, BELLE_SIP_HEADER(content_type));
belle_sip_message_set_body_handler(msg, bh);
}
belle_sip_body_handler_begin_recv_transfer(bh);
}
return expect_body;
}
static int acquire_body_simple(belle_sip_channel_t *obj, int end_of_stream){
size_t content_length=obj->input_stream.content_length;
size_t to_read=obj->input_stream.write_ptr-obj->input_stream.read_ptr;
belle_sip_message_t *msg=obj->input_stream.msg;
belle_sip_body_handler_t *bh=belle_sip_message_get_body_handler(msg);
size_t cursize=belle_sip_body_handler_get_transfered_size(bh);
if ((cursize == 0) && (to_read == 0)) {
/**
* No data has been received yet, so do not call feed_body() with a size
* of 0 that is meaning that the transfer is finished.
*/
} else {
to_read=MIN(content_length-cursize, to_read);
feed_body(obj,to_read);
}
if (end_of_stream || belle_sip_body_handler_get_transfered_size(bh)>=content_length){
/*great body completed*/
belle_sip_message("channel [%p] read [%i] bytes of body from [%s:%i]" ,obj
,(int)content_length
,obj->peer_name
,obj->peer_port);
belle_sip_channel_message_ready(obj);
return BELLE_SIP_CONTINUE;
}
/*body is not finished, we need more data*/
return BELLE_SIP_STOP;
}
static int acquire_chuncked_body(belle_sip_channel_t *obj){
belle_sip_channel_input_stream_t *st=&obj->input_stream;
int readsize;
do{
if (st->chunk_size==-1){
char *tmp;
/*belle_sip_message("seeing: %s",st->read_ptr);*/
while ( (tmp=strstr(st->read_ptr,"\r\n"))==st->read_ptr){/*skip \r\n*/
st->read_ptr+=2;
}
if (tmp!=NULL){
/*the chunk length is there*/
long chunksize=strtol(st->read_ptr,NULL,16);
if (chunksize>=0 && chunksize!=LONG_MAX){
if (chunksize==0){
belle_sip_message("Got end of chunked body");
st->read_ptr=tmp+4; /*last chunk indicator finishes with two \r\n*/
if (st->read_ptr>st->write_ptr) st->read_ptr=st->write_ptr;
belle_sip_channel_message_ready(obj);
return BELLE_SIP_CONTINUE;
}else{
belle_sip_message("Will get a chunk of %i bytes",(int)chunksize);
st->chunk_size=chunksize;
st->chunk_read_size=0;
st->read_ptr=tmp+2;
}
}else{
belle_sip_error("Chunk parse error");
belle_sip_channel_input_stream_reset(st);
return BELLE_SIP_CONTINUE;
}
}else{
/*need more data*/
return BELLE_SIP_STOP;
}
}
readsize=MIN((int)(st->write_ptr-st->read_ptr),st->chunk_size-st->chunk_read_size);
if (readsize>0){
feed_body(obj,readsize);
st->chunk_read_size+=readsize;
}
if (st->chunk_size==st->chunk_read_size){
/*we have a chunk completed*/
st->content_length+=st->chunk_size;
belle_sip_message("Chunk of [%i] bytes completed",st->chunk_size);
st->chunk_size=-1;/*wait for next chunk indicator*/
}else{
/*need more data*/
return BELLE_SIP_STOP;
}
}while(st->write_ptr-st->read_ptr>0); /*no need to continue if nothing to read*/
return BELLE_SIP_STOP;
}
static int acquire_body(belle_sip_channel_t *obj, int end_of_stream){
if (obj->input_stream.chuncked_mode)
return acquire_chuncked_body(obj);
else return acquire_body_simple(obj,end_of_stream);
}
static void notify_incoming_messages(belle_sip_channel_t *obj){
belle_sip_list_t *elem,*l_it;
belle_sip_list_t *listeners=belle_sip_list_copy_with_data(obj->full_listeners,(void *(*)(void*))belle_sip_object_ref);
for(l_it=listeners;l_it!=NULL;l_it=l_it->next){
belle_sip_channel_listener_t *listener=(belle_sip_channel_listener_t*)l_it->data;
for(elem=obj->incoming_messages;elem!=NULL;elem=elem->next){
belle_sip_message_t *msg=(belle_sip_message_t*)elem->data;
BELLE_SIP_INTERFACE_METHODS_TYPE(belle_sip_channel_listener_t) *methods;
methods=BELLE_SIP_INTERFACE_GET_METHODS(listener,belle_sip_channel_listener_t);
if (methods->on_message)
methods->on_message(listener,obj,msg);
}
}
belle_sip_list_free_with_data(listeners,belle_sip_object_unref);
belle_sip_list_free_with_data(obj->incoming_messages,belle_sip_object_unref);
obj->incoming_messages=NULL;
}
void belle_sip_channel_parse_stream(belle_sip_channel_t *obj, int end_of_stream){
int offset;
size_t read_size=0;
int num;
while ((num=(int)(obj->input_stream.write_ptr-obj->input_stream.read_ptr))>0){
if (obj->input_stream.state == WAITING_MESSAGE_START) {
int i;
/*first, make sure there is \r\n in the buffer, otherwise, micro parser cannot conclude, because we need a complete request or response line somewhere*/
for (i=0;iinput_stream.read_ptr[i]=='\r' && obj->input_stream.read_ptr[i+1]=='\n')
|| belle_sip_channel_input_stream_get_buff_length(&obj->input_stream) <= 1 /*1 because null terminated*/ /*if buffer full try to parse in any case*/) {
/*good, now we can start searching for request/response*/
if ((offset=get_message_start_pos(obj->input_stream.read_ptr,num)) >=0 ) {
/*message found !*/
if (offset>0) {
belle_sip_warning("trashing [%i] bytes in front of sip message on channel [%p]",offset,obj);
obj->input_stream.read_ptr+=offset;
}
obj->input_stream.state=MESSAGE_AQUISITION;
} else {
belle_sip_debug("Unexpected [%s] received on channel [%p], trashing",obj->input_stream.read_ptr,obj);
obj->input_stream.read_ptr=obj->input_stream.write_ptr;
belle_sip_channel_input_stream_reset(&obj->input_stream);
continue;
}
break;
}
}
if (i >= num-1) {
belle_sip_debug("[%s] received on channel [%p], cannot determine if expected or not, waiting for new data",obj->input_stream.read_ptr,obj);
break;
}
}
if (obj->input_stream.state==MESSAGE_AQUISITION) {
/*search for \r\n\r\n*/
char* end_of_message=NULL;
if ((end_of_message=strstr(obj->input_stream.read_ptr,"\r\n\r\n"))){
int bytes_to_parse;
char tmp;
/*end of message found*/
end_of_message+=4;/*add \r\n\r\n*/
bytes_to_parse=(int)(end_of_message-obj->input_stream.read_ptr);
tmp=*end_of_message;
*end_of_message='\0';/*this is in order for the following log to print the message only to its end.*/
/*belle_sip_message("channel [%p] read message of [%i] bytes:\n%.40s...",obj, bytes_to_parse, obj->input_stream.read_ptr);*/
obj->input_stream.msg=belle_sip_message_parse_raw(obj->input_stream.read_ptr
,bytes_to_parse
,&read_size);
*end_of_message=tmp;
obj->input_stream.read_ptr+=read_size;
if (obj->input_stream.msg && read_size > 0){
belle_sip_message("channel [%p] [%i] bytes parsed",obj,(int)read_size);
belle_sip_object_ref(obj->input_stream.msg);
if (belle_sip_message_is_request(obj->input_stream.msg)) fix_incoming_via(BELLE_SIP_REQUEST(obj->input_stream.msg),obj->current_peer);
/*check for body*/
if (check_body(obj)){
obj->input_stream.state=BODY_AQUISITION;
} else {
/*no body*/
belle_sip_channel_message_ready(obj);
continue;
}
}else{
belle_sip_error("Could not parse [%s], on channel [%p] skipping to [%s]",obj->input_stream.read_ptr
,obj
,end_of_message);
obj->input_stream.read_ptr=end_of_message;
obj->input_stream.state=WAITING_MESSAGE_START;
continue;
}
}else break; /*The message isn't finished to be receive, we need more data*/
}
if (obj->input_stream.state==BODY_AQUISITION) {
if (acquire_body(obj,end_of_stream)==BELLE_SIP_STOP) break;
}
}
}
static void belle_sip_channel_process_stream(belle_sip_channel_t *obj, int eos){
belle_sip_channel_parse_stream(obj,eos);
if (obj->incoming_messages) {
if (obj->simulated_recv_return == 1500) {
belle_sip_list_t *elem;
for(elem=obj->incoming_messages;elem!=NULL;elem=elem->next){
belle_sip_message_t *msg=(belle_sip_message_t*)elem->data;
char* dump = belle_sip_message_to_string(msg);
belle_sip_message("Silently discarding incoming message [%.50s...] on channel [%p]",dump, obj);
belle_sip_free(dump);
}
belle_sip_list_free_with_data(obj->incoming_messages,belle_sip_object_unref);
obj->incoming_messages=NULL;
} else {
notify_incoming_messages(obj);
}
}
}
static int belle_sip_channel_process_read_data(belle_sip_channel_t *obj){
int num;
int ret=BELLE_SIP_CONTINUE;
/*prevent system to suspend the process until we have finish reading everything from the socket and notified the upper layer*/
if (obj->input_stream.state == WAITING_MESSAGE_START) {
channel_begin_recv_background_task(obj);
}
if (obj->simulated_recv_return>0) {
num=belle_sip_channel_recv(obj,obj->input_stream.write_ptr,belle_sip_channel_input_stream_get_buff_length(&obj->input_stream)-1);
} else {
belle_sip_message("channel [%p]: simulating recv() returning %i",obj,obj->simulated_recv_return);
num=obj->simulated_recv_return;
}
if (num>0){
char *begin=obj->input_stream.write_ptr;
obj->input_stream.write_ptr+=num;
/*first null terminate the read buff*/
*obj->input_stream.write_ptr='\0';
if (num>20 || obj->input_stream.state != WAITING_MESSAGE_START ) /*to avoid tracing server based keep alives*/ {
char *logbuf = make_logbuf(obj, BELLE_SIP_LOG_MESSAGE ,begin,num);
if (logbuf) {
belle_sip_message("channel [%p]: received [%i] new bytes from [%s://%s:%i]:\n%s",
obj,
num,
belle_sip_channel_get_transport_name(obj),
obj->peer_name,
obj->peer_port,
logbuf);
belle_sip_free(logbuf);
}
}
belle_sip_channel_process_stream(obj,FALSE);
if (obj->input_stream.state == WAITING_MESSAGE_START){
channel_end_recv_background_task(obj);
}/*if still in message acquisition state, keep the backgroud task*/
} else if (num == 0) {
/*before closing the channel, check if there was a pending message to receive, whose body acquisition is to be finished.*/
belle_sip_channel_process_stream(obj,TRUE);
obj->closed_by_remote = TRUE;
channel_set_state(obj,BELLE_SIP_CHANNEL_DISCONNECTED);
ret=BELLE_SIP_STOP;
} else if (belle_sip_error_code_is_would_block(-num)){
belle_sip_message("channel [%p]: recv() EWOULDBLOCK",obj);
ret=BELLE_SIP_CONTINUE;
}else{
belle_sip_error("Receive error on channel [%p]",obj);
channel_set_state(obj,BELLE_SIP_CHANNEL_ERROR);
ret=BELLE_SIP_STOP;
}
return ret;
}
int belle_sip_channel_process_data(belle_sip_channel_t *obj,unsigned int revents){
int ret=BELLE_SIP_CONTINUE;
belle_sip_object_ref(obj);
if (revents & BELLE_SIP_EVENT_READ) {
int rret=belle_sip_channel_process_read_data(obj);
if (rret==BELLE_SIP_STOP) ret=BELLE_SIP_STOP;
}
if (revents & BELLE_SIP_EVENT_WRITE){
/*if we are here, this is because we had an EWOULDBLOCK while sending a message*/
/*continue to send pending messages but before check the channel is still alive because
it may have been closed by belle_sip_channel_process_read_data() above.*/
if (obj->state == BELLE_SIP_CHANNEL_READY){
channel_process_queue(obj);
}
}
belle_sip_object_unref(obj);
return ret;
}
static int channel_inactive_timeout(void *data, unsigned int event){
belle_sip_channel_t *obj=(belle_sip_channel_t *)data;
belle_sip_message("Channel [%p]: inactivity timeout reached.",obj);
channel_set_state(obj,BELLE_SIP_CHANNEL_DISCONNECTED);
return BELLE_SIP_STOP;
}
static void update_inactivity_timer(belle_sip_channel_t *obj, int from_recv){
int inactive_timeout=belle_sip_stack_get_inactive_transport_timeout(obj->stack)*1000;
if (inactive_timeout>0){
if (!obj->inactivity_timer ){
obj->inactivity_timer=belle_sip_main_loop_create_timeout(obj->stack->ml,channel_inactive_timeout,obj,inactive_timeout,"Channel inactivity timer");
}else{
/*restart the timer for new period*/
belle_sip_source_set_timeout_int64(obj->inactivity_timer,inactive_timeout);
}
}else{
if (obj->inactivity_timer){
belle_sip_main_loop_remove_source(obj->stack->ml,obj->inactivity_timer);
belle_sip_object_unref(obj->inactivity_timer);
obj->inactivity_timer=NULL;
}
}
if (from_recv)
obj->last_recv_time=belle_sip_time_ms();
}
/*constructor for channels creating an outgoing connection
* bindip local ip address to bind on, typically 0.0.0.0 or ::0
* locaport locaport to use for binding, can be set to 0 if port doesn't matter
* peer_cname canonical name of remote host, used for TLS verification
* peername peer's hostname, either ip address or DNS name
* peer_port peer's port to connect to.
*/
void belle_sip_channel_init(belle_sip_channel_t *obj, belle_sip_stack_t *stack,const char *bindip,int localport,const char *peer_cname, const char *peername, int peer_port, int no_srv){
/*to initialize our base class:*/
belle_sip_channel_set_socket(obj,-1,NULL);
belle_sip_message("belle_sip_channel_init(); peer_cname=%s", peer_cname);
/*then initialize members*/
obj->ai_family=AF_INET;
obj->peer_cname=peer_cname ? belle_sip_strdup(peer_cname) : NULL;
obj->peer_name=belle_sip_strdup(peername);
obj->peer_port=peer_port;
obj->no_srv = (unsigned char)no_srv;
obj->stack=stack;
if (bindip){
if (strcmp(bindip,"::0")!=0 && strcmp(bindip,"0.0.0.0")!=0)
obj->local_ip=belle_sip_strdup(bindip);
if (strchr(bindip,':')!=NULL)
obj->ai_family=AF_INET6;
}
obj->local_port=localport;
obj->simulated_recv_return=1;/*not set*/
if (peername){
/*check if we are given a real dns name or just an ip address*/
struct addrinfo *ai=bctbx_ip_address_to_addrinfo(AF_UNSPEC,SOCK_STREAM,peername,peer_port);
if (ai) bctbx_freeaddrinfo(ai);
else obj->has_name=TRUE;
}
belle_sip_channel_input_stream_reset(&obj->input_stream);
update_inactivity_timer(obj,FALSE);
}
/*constructor for channels created by incoming connections*/
void belle_sip_channel_init_with_addr(belle_sip_channel_t *obj, belle_sip_stack_t *stack, const char *bindip, int localport, const struct sockaddr *peer_addr, socklen_t addrlen){
char remoteip[64];
struct addrinfo ai;
int peer_port;
memset(&ai,0,sizeof(ai));
ai.ai_family=peer_addr->sa_family;
ai.ai_addr=(struct sockaddr*)peer_addr;
ai.ai_addrlen=addrlen;
bctbx_addrinfo_to_ip_address(&ai,remoteip,sizeof(remoteip),&peer_port);
belle_sip_channel_init(obj,stack,bindip,localport,NULL,remoteip,peer_port, TRUE);
obj->peer_list = obj->current_peer = obj->static_peer_list = bctbx_ip_address_to_addrinfo(ai.ai_family, ai.ai_socktype, obj->peer_name,obj->peer_port);
obj->ai_family=ai.ai_family;
}
void belle_sip_channel_set_socket(belle_sip_channel_t *obj, belle_sip_socket_t sock, belle_sip_source_func_t datafunc){
belle_sip_socket_source_init((belle_sip_source_t*)obj
, datafunc
, obj
, sock
, BELLE_SIP_EVENT_READ|BELLE_SIP_EVENT_WRITE
, -1);
}
static bool_t is_state_only_listener(const belle_sip_channel_listener_t *listener) {
BELLE_SIP_INTERFACE_METHODS_TYPE(belle_sip_channel_listener_t) *methods;
methods=BELLE_SIP_INTERFACE_GET_METHODS(listener,belle_sip_channel_listener_t);
return methods->on_state_changed && !(methods->on_message_headers || methods->on_message || methods->on_sending || methods->on_auth_requested);
}
static void channel_remove_listener(belle_sip_channel_t *obj, belle_sip_channel_listener_t *l){
if (is_state_only_listener(l))
obj->state_listeners=belle_sip_list_remove(obj->state_listeners,l);
else
obj->full_listeners=belle_sip_list_remove(obj->full_listeners,l);
}
void belle_sip_channel_add_listener(belle_sip_channel_t *obj, belle_sip_channel_listener_t *l){
if (is_state_only_listener(l)) {
obj->state_listeners=belle_sip_list_prepend(
obj->state_listeners,
belle_sip_object_weak_ref(l, (belle_sip_object_destroy_notify_t)channel_remove_listener,obj)
);
} else {
obj->full_listeners=belle_sip_list_prepend(
obj->full_listeners,
belle_sip_object_weak_ref(l, (belle_sip_object_destroy_notify_t)channel_remove_listener,obj)
);
}
}
void belle_sip_channel_remove_listener(belle_sip_channel_t *obj, belle_sip_channel_listener_t *l){
belle_sip_object_weak_unref(l,(belle_sip_object_destroy_notify_t)channel_remove_listener,obj);
channel_remove_listener(obj,l);
}
int belle_sip_channel_matches(const belle_sip_channel_t *obj, const belle_sip_hop_t *hop, const struct addrinfo *addr){
if (hop){
if (obj->current_peer_cname && strcasecmp(hop->host, obj->current_peer_cname)==0 && hop->port==obj->peer_port){
/*We are matching a specific node of a SRV record set. */
if (hop->cname && obj->peer_cname && strcasecmp(hop->cname,obj->current_peer_cname) != 0)
return 0; /*cname mismatch*/
return 1;
}
if (strcmp(hop->host,obj->peer_name)==0 && (hop->port==obj->peer_port || obj->srv_overrides_port)){
/*We may be matching the general name of the service, in that case the port doesn't matter.*/
if (hop->cname && obj->peer_cname && strcasecmp(hop->cname,obj->peer_cname) != 0){
return 0; /*cname mismatch*/
}
return 1;
}
}
if (addr && obj->current_peer)
return bctbx_sockaddr_equals(addr->ai_addr,obj->current_peer->ai_addr);
return 0;
}
const char *belle_sip_channel_get_local_address(belle_sip_channel_t *obj, int *port){
if (port) *port=obj->local_port;
return obj->local_ip;
}
const char *belle_sip_channel_get_public_address(belle_sip_channel_t *obj, int *port){
const char *ret = obj->public_ip ? obj->public_ip : obj->local_ip;
if (*port) *port= obj->public_port;
return ret;
}
belle_sip_uri_t *belle_sip_channel_create_routable_uri(belle_sip_channel_t *chan) {
const char *transport = belle_sip_channel_get_transport_name_lower_case(chan);
belle_sip_uri_t* uri = belle_sip_uri_new();
unsigned char natted = chan->public_ip && strcmp(chan->public_ip,chan->local_ip)!=0;
if (natted) {
belle_sip_uri_set_host(uri, chan->public_ip);
belle_sip_uri_set_port(uri, chan->public_port);
} else {
belle_sip_uri_set_host(uri, chan->local_ip);
// With streamed protocols listening port is what we want
if (chan->lp)
belle_sip_uri_set_port(uri, belle_sip_uri_get_port(chan->lp->listening_uri));
else belle_sip_uri_set_port(uri,chan->local_port);
}
belle_sip_uri_set_transport_param(uri, transport);
belle_sip_uri_set_lr_param(uri, TRUE);
return uri;
}
int belle_sip_channel_is_reliable(const belle_sip_channel_t *obj){
return BELLE_SIP_OBJECT_VPTR(obj,belle_sip_channel_t)->reliable;
}
const char * belle_sip_channel_get_transport_name_lower_case(const belle_sip_channel_t *obj){
const char* transport = belle_sip_channel_get_transport_name(obj);
if (strcasecmp("udp",transport)==0) return "udp";
else if (strcasecmp("tcp",transport)==0) return "tcp";
else if (strcasecmp("tls",transport)==0) return "tls";
else if (strcasecmp("dtls",transport)==0) return "dtls";
else {
belle_sip_message("Cannot convert [%s] to lower case",transport);
return transport;
}
}
const char * belle_sip_channel_get_transport_name(const belle_sip_channel_t *obj){
return BELLE_SIP_OBJECT_VPTR(obj,belle_sip_channel_t)->transport;
}
int belle_sip_channel_send(belle_sip_channel_t *obj, const void *buf, size_t buflen){
update_inactivity_timer(obj,FALSE);
return BELLE_SIP_OBJECT_VPTR(obj,belle_sip_channel_t)->channel_send(obj,buf,buflen);
}
int belle_sip_channel_recv(belle_sip_channel_t *obj, void *buf, size_t buflen){
update_inactivity_timer(obj,TRUE);
return BELLE_SIP_OBJECT_VPTR(obj,belle_sip_channel_t)->channel_recv(obj,buf,buflen);
}
void belle_sip_channel_close(belle_sip_channel_t *obj){
if (BELLE_SIP_OBJECT_VPTR(obj,belle_sip_channel_t)->close)
BELLE_SIP_OBJECT_VPTR(obj,belle_sip_channel_t)->close(obj); /*udp channel doesn't have close function*/
belle_sip_main_loop_remove_source(obj->stack->ml,(belle_sip_source_t*)obj);
belle_sip_source_uninit((belle_sip_source_t*)obj);
}
const struct addrinfo * belle_sip_channel_get_peer(belle_sip_channel_t *obj){
return obj->current_peer;
}
static void channel_on_send_background_task_ended(belle_sip_channel_t *obj){
belle_sip_warning("channel [%p]: send background task has to be ended now, but work isn't finished.",obj);
channel_end_send_background_task(obj);
}
static void channel_begin_send_background_task(belle_sip_channel_t *obj){
if (obj->bg_task_id==0){
obj->bg_task_id=belle_sip_begin_background_task("belle-sip send channel",(void (*)(void*))channel_on_send_background_task_ended, obj);
if (obj->bg_task_id) belle_sip_message("channel [%p]: starting send background task with id=[%lx].",obj,obj->bg_task_id);
}
}
static void channel_end_send_background_task(belle_sip_channel_t *obj){
if (obj->bg_task_id){
belle_sip_message("channel [%p]: ending send background task with id=[%lx].",obj,obj->bg_task_id);
belle_sip_end_background_task(obj->bg_task_id);
obj->bg_task_id=0;
}
}
static void channel_on_recv_background_task_ended(belle_sip_channel_t *obj){
belle_sip_warning("channel [%p]: recv background task has to be ended now, but work isn't finished.",obj);
channel_end_recv_background_task(obj);
}
static void channel_begin_recv_background_task(belle_sip_channel_t *obj){
if (obj->recv_bg_task_id==0){
obj->recv_bg_task_id=belle_sip_begin_background_task("belle-sip recv channel",(void (*)(void*))channel_on_recv_background_task_ended, obj);
if (obj->recv_bg_task_id) belle_sip_message("channel [%p]: starting recv background task with id=[%lx].",obj,obj->recv_bg_task_id);
}
}
static void channel_end_recv_background_task(belle_sip_channel_t *obj){
if (obj->recv_bg_task_id){
belle_sip_message("channel [%p]: ending recv background task with id=[%lx].",obj,obj->recv_bg_task_id);
belle_sip_end_background_task(obj->recv_bg_task_id);
obj->recv_bg_task_id=0;
}
}
static void channel_invoke_state_listener(belle_sip_channel_t *obj){
int close = FALSE;
switch(obj->state){
case BELLE_SIP_CHANNEL_DISCONNECTED:
case BELLE_SIP_CHANNEL_ERROR:
/*the background tasks must be released "after" notifying the app of the disconnected or error state
By "after" it is means not before the main loop iteration that will notify the app.
This is the reason why these calls are done here rather than in the channel_set_state() function.*/
channel_end_send_background_task(obj);
channel_end_recv_background_task(obj);
close = TRUE;
break;
default:
break;
}
/*Channel listeners may drop the last reference of the channel, so protect by ref/unref until we finish.*/
belle_sip_object_ref(obj);
BELLE_SIP_CHANNEL_INVOKE_STATE_LISTENERS(obj,obj->state);
if (close) belle_sip_channel_close(obj);
belle_sip_object_unref(obj);
}
static void channel_notify_error_to_listeners(belle_sip_channel_t *obj){
/* The channel may have been passed to DISCONNECTED state due to _force_close() method.
* Do not notify the error in this case, since the channel is already closed.
*/
if (obj->state == BELLE_SIP_CHANNEL_ERROR){
channel_invoke_state_listener(obj);
}
belle_sip_object_unref(obj);
}
static void channel_connect_next(belle_sip_channel_t *obj){
if (obj->state == BELLE_SIP_CHANNEL_RETRY){
belle_sip_channel_connect(obj);
}
belle_sip_object_unref(obj);
}
static void channel_set_current_peer(belle_sip_channel_t *obj, const struct addrinfo *ai){
if (obj->resolver_results){
const belle_sip_dns_srv_t *srv = belle_sip_resolver_results_get_srv_from_addrinfo(obj->resolver_results, ai);
obj->current_peer_cname = srv ? belle_sip_dns_srv_get_target(srv) : NULL;
if (obj->current_peer_cname){
belle_sip_message("channel[%p]: current peer hostname is [%s] on port [%i].", obj,
obj->current_peer_cname, belle_sip_dns_srv_get_port(srv));
}
}else{
obj->current_peer_cname = NULL;
}
obj->current_peer = ai;
}
static void belle_sip_channel_handle_error(belle_sip_channel_t *obj){
if (obj->state!=BELLE_SIP_CHANNEL_READY || obj->soft_error){
/* Previous connection attempts were failed (channel could not get ready) OR soft error reported*/
obj->soft_error = FALSE;
/* See if you can retry on an alternate ip address.*/
if (obj->current_peer && obj->current_peer->ai_next){ /*obj->current_peer may be null in case of dns error*/
channel_set_current_peer(obj, obj->current_peer->ai_next);
channel_set_state(obj,BELLE_SIP_CHANNEL_RETRY);
belle_sip_channel_close(obj);
belle_sip_main_loop_do_later(obj->stack->ml,(belle_sip_callback_t)channel_connect_next,belle_sip_object_ref(obj));
return;
}/*else we have already tried all the ip addresses, so give up and notify the error*/
}/*else the channel was previously working good with the current ip address but now fails, so let's notify the error*/
obj->state=BELLE_SIP_CHANNEL_ERROR;
/*Because error notification will in practice trigger the destruction of possible transactions and this channel,
* it is safer to invoke the listener outside the current call stack.
* Indeed the channel encounters network errors while being called for transmiting by a transaction.
*/
belle_sip_main_loop_do_later(obj->stack->ml,(belle_sip_callback_t)channel_notify_error_to_listeners,belle_sip_object_ref(obj));
}
int belle_sip_channel_notify_timeout(belle_sip_channel_t *obj){
const uint64_t too_long = 60;
if (obj->state != BELLE_SIP_CHANNEL_READY){
/*no need to notify the timeout if the channel is already in error or retry state*/
return FALSE;
}
if ((belle_sip_time_ms() - obj->last_recv_time) >= too_long * 1000){
belle_sip_message("A timeout related to this channel occured and no message received during last %i seconds. This channel is suspect, moving to error state", (int)too_long);
obj->soft_error = TRUE;
channel_set_state(obj,BELLE_SIP_CHANNEL_ERROR);
return TRUE;
}
return FALSE;
}
void belle_sip_channel_notify_server_error(belle_sip_channel_t *obj){
belle_sip_message("channel[%p]: this server is encountering internal errors, moving to error state to eventually connect to another IP.", obj);
obj->soft_error = TRUE;
channel_set_state(obj,BELLE_SIP_CHANNEL_ERROR);
}
void channel_set_state(belle_sip_channel_t *obj, belle_sip_channel_state_t state) {
belle_sip_message("channel[%p]: entering state %s",obj,belle_sip_channel_state_to_string(state));
if (obj->state == state) {
belle_sip_error("channel_set_state() called twice with the same state. This is a programming mistake.");
return;
}
if (state==BELLE_SIP_CHANNEL_ERROR){
belle_sip_channel_handle_error(obj);
}else{
obj->state=state;
channel_invoke_state_listener(obj);
}
}
static void free_ewouldblock_buffer(belle_sip_channel_t *obj){
if (obj->ewouldblock_buffer){
belle_sip_free(obj->ewouldblock_buffer);
obj->ewouldblock_buffer=NULL;
obj->ewouldblock_size=0;
obj->ewouldblock_offset=0;
}
}
static void handle_ewouldblock(belle_sip_channel_t *obj, const char *buffer, size_t size){
belle_sip_source_set_events((belle_sip_source_t*)obj,BELLE_SIP_EVENT_READ|BELLE_SIP_EVENT_WRITE|BELLE_SIP_EVENT_ERROR);
free_ewouldblock_buffer(obj);
obj->ewouldblock_buffer=belle_sip_malloc(size);
obj->ewouldblock_size=size;
memcpy(obj->ewouldblock_buffer,buffer,size);
}
static size_t find_non_printable(const char *buffer, size_t size){
#if 0
size_t i;
for(i=0;i 255)) return i;
#endif
if (!isprint(buffer[i]) && !isspace(buffer[i])) return i;
}
return size;
#else
size_t i=0;
mbstate_t mbs;
memset(&mbs, 0, sizeof(mbs));
do {
size_t valid_multibyte_len = mbrlen(buffer+i, size-i, &mbs);
if (valid_multibyte_len == (size_t)-1 || valid_multibyte_len == (size_t)-2 || valid_multibyte_len == 0) break;
i += valid_multibyte_len;
}while(1);
return i;
#endif
}
/*
* this function is to avoid logging too much or non-ascii data received.
*/
static char *make_logbuf(belle_sip_channel_t *obj, belle_sip_log_level level, const char *buffer, size_t size){
char *logbuf;
char truncate_msg[128]={0};
size_t limit=7000; /*big message when many ice candidates*/
if (!belle_sip_log_level_enabled(level)){
return NULL;
}
if (obj->stop_logging_buffer == 1) {
return NULL;
}
size = MIN(size,limit);
limit=find_non_printable(buffer, size);
if (limit < size) {
belle_sip_message("channel [%p]: found binary data in buffer, will stop logging it now.", obj);
obj->stop_logging_buffer = 1;
if (limit == 0){
snprintf(truncate_msg,sizeof(truncate_msg)-1,"... (binary data)");
} else {
snprintf(truncate_msg,sizeof(truncate_msg)-1,"... (first %u bytes shown)",(unsigned int)limit);
}
}
size = limit;
size += strlen(truncate_msg);
logbuf=belle_sip_malloc(size+1);
strncpy(logbuf, buffer, size);
if (truncate_msg[0]!=0){
strcpy(logbuf+limit,truncate_msg);
}
logbuf[size]='\0';
return logbuf;
}
static int send_buffer(belle_sip_channel_t *obj, const char *buffer, size_t size){
int ret=0;
char *logbuf=NULL;
if (obj->stack->send_error == 0){
ret=belle_sip_channel_send(obj,buffer,size);
}else if (obj->stack->send_error<0){
/*for testing purpose only */
belle_sip_message("channel[%p]: simulating socket error [%i].", obj, (int) obj->stack->send_error);
ret=obj->stack->send_error;
} else {
ret=(int)size; /*to silently discard message*/
belle_sip_message("channel[%p]: %i bytes are silently discarded, to simulate loss of data.", obj, (int) size);
}
if (ret<0){
if (!belle_sip_error_code_is_would_block(-ret)){
belle_sip_error("channel [%p]: could not send [%i] bytes from [%s://%s:%i] to [%s:%i]" ,obj
,(int)size
,belle_sip_channel_get_transport_name(obj)
,obj->local_ip
,obj->local_port
,obj->peer_name
,obj->peer_port);
channel_set_state(obj,BELLE_SIP_CHANNEL_ERROR);
}/*ewouldblock error has to be handled by caller*/
}else if (size==(size_t)ret){
logbuf=make_logbuf(obj, BELLE_SIP_LOG_MESSAGE, buffer,size);
if (logbuf) {
belle_sip_message("channel [%p]: message %s to [%s://%s:%i], size: [%i] bytes\n%s"
,obj
,obj->stack->send_error==0?"sent":"silently discarded"
,belle_sip_channel_get_transport_name(obj)
,obj->peer_name
,obj->peer_port
,ret
,logbuf);
}
}else{
logbuf=make_logbuf(obj, BELLE_SIP_LOG_MESSAGE,buffer,ret);
if (logbuf) {
belle_sip_message("channel [%p]: message partly sent to [%s://%s:%i], sent: [%i/%i] bytes:\n%s"
,obj
,belle_sip_channel_get_transport_name(obj)
,obj->peer_name
,obj->peer_port
,ret
,(int)size
,logbuf);
}
}
if (logbuf) belle_sip_free(logbuf);
return ret;
}
static void check_content_length(belle_sip_message_t *msg, size_t body_len){
belle_sip_header_content_length_t *ctlen=belle_sip_message_get_header_by_type(msg,belle_sip_header_content_length_t);
size_t value=ctlen ? belle_sip_header_content_length_get_content_length(ctlen) : 0;
if (body_len){
if (ctlen==NULL){
belle_sip_message("message [%p] has body of size ["FORMAT_SIZE_T"] but no Content-Length, adding it.",msg,body_len);
belle_sip_message_add_header(msg,
(belle_sip_header_t*)belle_sip_header_content_length_create(body_len)
);
}else{
if (value!=body_len){
belle_sip_warning("message [%p] has Content-Length ["FORMAT_SIZE_T"] and body size ["FORMAT_SIZE_T"] which are inconsistent, fixing it.",
msg, value, body_len);
belle_sip_header_content_length_set_content_length(ctlen,body_len);
}
}
}else{
/*no body, or undetermined size body*/
if (ctlen && value!=0){
belle_sip_error("message [%p] has Content-Length ["FORMAT_SIZE_T"], but without body or body with undetermined size. Fix your app.",
msg,value);
}
}
}
static void compress_body_if_required(belle_sip_message_t *msg) {
belle_sip_body_handler_t *bh = belle_sip_message_get_body_handler(msg);
belle_sip_memory_body_handler_t *mbh = NULL;
belle_sip_header_t *ceh = NULL;
size_t body_len = 0;
if (bh != NULL) {
body_len = belle_sip_message_get_body_size(msg);
ceh = belle_sip_message_get_header(msg, "Content-Encoding");
}
if ((body_len > 0) && (ceh != NULL)) {
const char *content_encoding = belle_sip_header_get_unparsed_value(ceh);
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(bh, belle_sip_multipart_body_handler_t)) {
char *marshalled_content = belle_sip_object_to_string(BELLE_SIP_OBJECT(bh));
mbh = belle_sip_memory_body_handler_new_from_buffer(marshalled_content, strlen(marshalled_content), NULL, NULL);
bh = BELLE_SIP_BODY_HANDLER(mbh);
belle_sip_message_set_body_handler(msg, bh);
}
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(bh, belle_sip_memory_body_handler_t)) {
mbh = BELLE_SIP_MEMORY_BODY_HANDLER(bh);
int ret = belle_sip_memory_body_handler_apply_encoding(mbh, content_encoding);
/* Remove Content-Encoding header if it could not be applied */
if (ret < 0)
belle_sip_message_remove_header_from_ptr(msg, ceh);
} else {
belle_sip_warning("message [%p] has Content-Encoding [%s] that cannot be applied", msg, content_encoding);
}
}
}
static void _send_message(belle_sip_channel_t *obj){
char buffer[belle_sip_send_network_buffer_size];
size_t len=0;
belle_sip_error_code error=BELLE_SIP_OK;
belle_sip_message_t *msg=obj->cur_out_message;
belle_sip_body_handler_t *bh=belle_sip_message_get_body_handler(msg);
size_t body_len=bh ? belle_sip_body_handler_get_size(bh) : 0;
int sendret;
size_t off;
int ret;
while (obj->ewouldblock_buffer){
sendret=send_buffer(obj,(const char*)obj->ewouldblock_buffer+obj->ewouldblock_offset,obj->ewouldblock_size-obj->ewouldblock_offset);
if (sendret>0){
obj->ewouldblock_offset+=sendret;
if (obj->ewouldblock_offset==obj->ewouldblock_size){
free_ewouldblock_buffer(obj);
if (obj->out_state==OUTPUT_STREAM_SENDING_HEADERS)
goto done; //to avoid message to be sent twice
/*else continue body sending*/
}
/* continue to expedite the ewouldblock error until we it is completed or get a new ewouldblock*/
}else if (belle_sip_error_code_is_would_block(-sendret)) {
/*we got an ewouldblock again. Nothing to do, we'll be called later in order to retry*/
return;
}else {/*error or disconnection case*/
goto done;
}
}
if (obj->out_state==OUTPUT_STREAM_SENDING_HEADERS){
BELLE_SIP_CHANNEL_INVOKE_SENDING_LISTENERS(obj,msg);
check_content_length(msg,body_len);
error=belle_sip_object_marshal((belle_sip_object_t*)msg,buffer,sizeof(buffer)-1,&len);
if (error!=BELLE_SIP_OK) {
belle_sip_error("channel [%p] _send_message: marshaling failed.",obj);
goto done;
}
/*send the headers and eventually the body if it fits in our buffer*/
if (bh){
size_t max_body_len=sizeof(buffer)-1-len;
if (body_len>0 && body_len<=max_body_len){ /*if size is known and fits into our buffer, send together with headers*/
belle_sip_body_handler_begin_send_transfer(bh);
do{
max_body_len=sizeof(buffer)-1-len;
ret=belle_sip_body_handler_send_chunk(bh,msg,(uint8_t*)buffer+len,&max_body_len);
if (max_body_len==0)
belle_sip_warning("belle_sip_body_handler_send_chunk on channel [%p], 0 bytes read",obj);
len+=max_body_len;
}while(ret==BELLE_SIP_CONTINUE);
belle_sip_body_handler_end_transfer(bh);
}else{
if (body_len==0){
belle_sip_fatal("Sending bodies whose size is not known must be done in chunked mode, which is not supported yet.");
}
belle_sip_body_handler_begin_send_transfer(bh);
obj->out_state=OUTPUT_STREAM_SENDING_BODY;
}
}
off=0;
do{
sendret=send_buffer(obj,buffer+off,len-off);
if (sendret>0){
off+=sendret;
if (off==len){
break;
}
}else if (belle_sip_error_code_is_would_block(-sendret)) {
handle_ewouldblock(obj,buffer+off,len-off);
return;
}else {/*error or disconnection case*/
goto done;
}
}while(1);
}
if (obj->out_state==OUTPUT_STREAM_SENDING_BODY){
do{
size_t chunk_len=sizeof(buffer)-1;
ret=belle_sip_body_handler_send_chunk(bh,msg,(uint8_t*)buffer,&chunk_len);
if (chunk_len!=0){
off=0;
do{
sendret=send_buffer(obj,buffer+off,chunk_len-off);
if (sendret>0){
off+=sendret;
if (off==chunk_len){
break;
}
}else if (belle_sip_error_code_is_would_block(-sendret)) {
handle_ewouldblock(obj,buffer+off,chunk_len-off);
return;
}else {/*error or disconnection case*/
goto done;
}
}while(1);
}
}while(ret==BELLE_SIP_CONTINUE);
belle_sip_body_handler_end_transfer(bh);
}
done:
/*we get ready to send another message*/
belle_sip_source_set_events((belle_sip_source_t*)obj,BELLE_SIP_EVENT_READ|BELLE_SIP_EVENT_ERROR);
free_ewouldblock_buffer(obj);
obj->out_state=OUTPUT_STREAM_IDLE;
obj->stop_logging_buffer=0;
belle_sip_object_unref(obj->cur_out_message);
obj->cur_out_message=NULL;
}
static void send_message(belle_sip_channel_t *obj, belle_sip_message_t *msg){
obj->cur_out_message=(belle_sip_message_t*)belle_sip_object_ref(msg);
obj->out_state=OUTPUT_STREAM_SENDING_HEADERS;
compress_body_if_required(obj->cur_out_message);
_send_message(obj);
}
void belle_sip_channel_prepare(belle_sip_channel_t *obj){
channel_prepare_continue(obj);
}
static void channel_push_outgoing(belle_sip_channel_t *obj, belle_sip_message_t *msg){
obj->outgoing_messages=belle_sip_list_append(obj->outgoing_messages,msg);
}
static belle_sip_message_t *channel_pop_outgoing(belle_sip_channel_t *obj){
belle_sip_message_t *msg=NULL;
if (obj->outgoing_messages){
msg=(belle_sip_message_t*)obj->outgoing_messages->data;
obj->outgoing_messages=belle_sip_list_delete_link(obj->outgoing_messages,obj->outgoing_messages);
}
return msg;
}
static void channel_prepare_continue(belle_sip_channel_t *obj){
switch(obj->state){
case BELLE_SIP_CHANNEL_INIT:
channel_begin_send_background_task(obj);
belle_sip_channel_resolve(obj);
break;
case BELLE_SIP_CHANNEL_RES_DONE:
belle_sip_channel_connect(obj);
break;
case BELLE_SIP_CHANNEL_READY:
channel_process_queue(obj);
break;
default:
break;
}
}
static void channel_process_queue(belle_sip_channel_t *obj){
belle_sip_message_t *msg;
belle_sip_object_ref(obj);/* we need to ref ourself because code below may trigger our destruction*/
if (obj->out_state != OUTPUT_STREAM_IDLE) {
_send_message(obj);
}
while (obj->state == BELLE_SIP_CHANNEL_READY && obj->out_state == OUTPUT_STREAM_IDLE && (msg = channel_pop_outgoing(obj)) != NULL) {
send_message(obj, msg);
belle_sip_object_unref(msg);
}
if (obj->state == BELLE_SIP_CHANNEL_READY && obj->out_state == OUTPUT_STREAM_IDLE) {
channel_end_send_background_task(obj);
}
belle_sip_object_unref(obj);
}
void belle_sip_channel_set_ready(belle_sip_channel_t *obj, const struct sockaddr *addr, socklen_t slen){
char name[NI_MAXHOST];
char serv[NI_MAXSERV];
if (obj->local_ip==NULL){
struct sockaddr_storage saddr;
socklen_t slen2=sizeof(saddr);
int err;
bctbx_sockaddr_remove_v4_mapping(addr,(struct sockaddr*) &saddr,&slen2);
err=bctbx_getnameinfo((struct sockaddr*)&saddr,slen2,name,sizeof(name),serv,sizeof(serv),NI_NUMERICHOST|NI_NUMERICSERV);
if (err!=0){
belle_sip_error("belle_sip_channel_set_ready(): getnameinfo() failed: %s",gai_strerror(err));
}else{
obj->local_ip=belle_sip_strdup(name);
obj->local_port=atoi(serv);
belle_sip_message("Channel has local address %s:%s",name,serv);
}
}
channel_set_state(obj,BELLE_SIP_CHANNEL_READY);
channel_process_queue(obj);
}
static int channel_dns_ttl_timeout(void *data, unsigned int event) {
belle_sip_channel_t *obj = (belle_sip_channel_t *)data;
belle_sip_message("Channel [%p]: DNS TTL timeout reached.", obj);
obj->dns_ttl_timedout = TRUE;
return BELLE_SIP_STOP;
}
/* returns the addrinfo from list that matches 'ai' in terms of content*/
static const struct addrinfo* addrinfo_in_list(const struct addrinfo *ai, const struct addrinfo *list) {
const struct addrinfo *item = list;
while (item != NULL) {
if ((ai->ai_family == item->ai_family) && (bctbx_sockaddr_equals(ai->ai_addr, item->ai_addr))) {
return item;
}
item = item->ai_next;
}
return NULL;
}
/* returns the first addrinfo from list, if it is matching 'ai' in terms content*/
static const struct addrinfo * addrinfo_is_first(const struct addrinfo *ai, const struct addrinfo *list) {
if (list != NULL && (ai->ai_family == list->ai_family) && (bctbx_sockaddr_equals(ai->ai_addr, list->ai_addr)))
return list;
return NULL;
}
static void channel_res_done(void *data, belle_sip_resolver_results_t *results){
belle_sip_channel_t *obj=(belle_sip_channel_t*)data;
const struct addrinfo *ai_list = NULL;
const char *name = NULL;
belle_sip_resolver_results_t *prev_dns_results = obj->resolver_results;
if (obj->resolver_ctx){
belle_sip_object_unref(obj->resolver_ctx);
obj->resolver_ctx=NULL;
}
if (results){
/*update current resolver_results, peer_list. current_peer still points to an element of the old list, if it exists*/
obj->peer_list = ai_list = belle_sip_resolver_results_get_addrinfos(results);
belle_sip_object_ref(results);
name = belle_sip_resolver_results_get_name(results);
}
obj->resolver_results = results;
if (ai_list){
int ttl = belle_sip_resolver_results_get_ttl(results);
/* setup now our current_peer. It can be initialized for the first time, kept as before, or changed*/
if (!obj->current_peer) {
/*first time we connect*/
channel_set_current_peer(obj, ai_list);
channel_set_state(obj,BELLE_SIP_CHANNEL_RES_DONE);
} else {
const struct addrinfo *existing_peer;
if (belle_sip_stack_reconnect_to_primary_asap_enabled(obj->stack)) {
existing_peer = addrinfo_is_first(obj->current_peer, ai_list);
} else {
/*find if the current_peer we had is still existing in the new list. If yes, we will keep it*/
existing_peer = addrinfo_in_list(obj->current_peer, ai_list);
}
if (existing_peer) {
belle_sip_message("channel[%p]: DNS resolution returned the currently used address, continue using it", obj);
channel_set_current_peer(obj, existing_peer);
channel_set_state(obj, BELLE_SIP_CHANNEL_READY);
} else {
belle_sip_message("channel[%p]: DNS resolution returned an address different than the one being used, reconnect to the new address", obj);
channel_set_current_peer(obj, ai_list);
belle_sip_channel_close(obj);
belle_sip_main_loop_do_later(obj->stack->ml, (belle_sip_callback_t)channel_connect_next, belle_sip_object_ref(obj));
channel_set_state(obj, BELLE_SIP_CHANNEL_RETRY);
}
}
channel_prepare_continue(obj);
if (ttl > 0){
if (!obj->dns_ttl_timer ) {
obj->dns_ttl_timer = belle_sip_main_loop_create_timeout(obj->stack->ml, channel_dns_ttl_timeout, obj, ttl * 1000, "Channel DNS TTL timer");
} else {
/* Restart the timer for new period. */
belle_sip_source_set_timeout_int64(obj->dns_ttl_timer, ttl * 1000LL);
belle_sip_main_loop_add_source(obj->stack->ml, obj->dns_ttl_timer);
}
}
}else{
channel_set_current_peer(obj, NULL);
belle_sip_error("%s: DNS resolution failed for %s", __FUNCTION__, name);
channel_set_state(obj,BELLE_SIP_CHANNEL_ERROR);
}
/*now free the old resolver results if any, since we don't need the old current_peer*/
if (prev_dns_results) belle_sip_object_unref(prev_dns_results);
}
void belle_sip_channel_resolve(belle_sip_channel_t *obj){
belle_sip_message("channel [%p]: starting resolution of %s", obj, obj->peer_name);
channel_set_state(obj,BELLE_SIP_CHANNEL_RES_IN_PROGRESS);
if (belle_sip_stack_dns_srv_enabled(obj->stack) && obj->lp!=NULL && obj->no_srv == 0)
obj->resolver_ctx=belle_sip_stack_resolve(obj->stack, "sip", belle_sip_channel_get_transport_name_lower_case(obj), obj->peer_name, obj->peer_port, obj->ai_family, channel_res_done, obj);
else
obj->resolver_ctx=belle_sip_stack_resolve_a(obj->stack, obj->peer_name, obj->peer_port, obj->ai_family, channel_res_done, obj);
if (obj->resolver_ctx){
belle_sip_object_ref(obj->resolver_ctx);
}
return ;
}
void belle_sip_channel_connect(belle_sip_channel_t *obj){
char ip[64];
int port=obj->peer_port;
channel_set_state(obj,BELLE_SIP_CHANNEL_CONNECTING);
bctbx_addrinfo_to_ip_address(obj->current_peer,ip,sizeof(ip),&port);
/* update peer_port as it may have been overriden by SRV resolution*/
if (port!=obj->peer_port){
/*the SRV resolution provided a port number that must be used*/
obj->srv_overrides_port=TRUE;
obj->peer_port=port;
}
belle_sip_message("Trying to connect to [%s://%s:%i]",belle_sip_channel_get_transport_name(obj),ip,obj->peer_port);
if(BELLE_SIP_OBJECT_VPTR(obj,belle_sip_channel_t)->connect(obj,obj->current_peer)) {
belle_sip_error("Cannot connect to [%s://%s:%i]",belle_sip_channel_get_transport_name(obj),obj->peer_name,obj->peer_port);
channel_set_state(obj,BELLE_SIP_CHANNEL_ERROR);
}
return;
}
static void queue_message(belle_sip_channel_t *obj, belle_sip_message_t *msg){
belle_sip_object_ref(msg);
channel_push_outgoing(obj,msg);
if (obj->state==BELLE_SIP_CHANNEL_INIT){
belle_sip_channel_prepare(obj);
}else if (obj->state==BELLE_SIP_CHANNEL_READY) {
channel_process_queue(obj);
}
}
typedef struct delay_send{
belle_sip_channel_t *chan;
belle_sip_message_t *msg;
}delay_send_t;
/* just to emulate network transmission delay */
static int on_delayed_send_do(delay_send_t *ctx){
belle_sip_message("on_delayed_send_do(): sending now");
if (ctx->chan->state!=BELLE_SIP_CHANNEL_ERROR && ctx->chan->state!=BELLE_SIP_CHANNEL_DISCONNECTED){
queue_message(ctx->chan,ctx->msg);
}
belle_sip_object_unref(ctx->chan);
belle_sip_object_unref(ctx->msg);
belle_sip_free(ctx);
return FALSE;
}
static void queue_message_delayed(belle_sip_channel_t *obj, belle_sip_message_t *msg){
delay_send_t *ctx=belle_sip_malloc(sizeof(delay_send_t));
ctx->chan=(belle_sip_channel_t*)belle_sip_object_ref(obj);
ctx->msg=(belle_sip_message_t*)belle_sip_object_ref(msg);
belle_sip_main_loop_add_timeout(obj->stack->ml,(belle_sip_source_func_t)on_delayed_send_do,ctx,obj->stack->tx_delay);
belle_sip_message("channel %p: message sending delayed by %i ms",obj,obj->stack->tx_delay);
}
int belle_sip_channel_queue_message(belle_sip_channel_t *obj, belle_sip_message_t *msg){
if (obj->stack->tx_delay>0){
queue_message_delayed(obj,msg);
}else queue_message(obj,msg);
return 0;
}
void belle_sip_channel_force_close(belle_sip_channel_t *obj){
obj->force_close=1;
channel_set_state(obj,BELLE_SIP_CHANNEL_DISCONNECTED);
}
belle_sip_channel_t *belle_sip_channel_find_from_list_with_addrinfo(belle_sip_list_t *l, const belle_sip_hop_t *hop, const struct addrinfo *addr){
belle_sip_list_t *elem;
belle_sip_channel_t *chan;
for(elem=l;elem!=NULL;elem=elem->next){
chan=(belle_sip_channel_t*)elem->data;
if (chan->state == BELLE_SIP_CHANNEL_DISCONNECTED || chan->state == BELLE_SIP_CHANNEL_ERROR) continue;
if (!chan->about_to_be_closed && belle_sip_channel_matches(chan,hop,addr)){
return chan;
}
}
return NULL;
}
/* search a matching channel from a list according to supplied hop. The ai_family tells which address family is supported by the list of channels*/
belle_sip_channel_t *belle_sip_channel_find_from_list(belle_sip_list_t *l, int ai_family, const belle_sip_hop_t *hop){
belle_sip_channel_t *chan=NULL;
struct addrinfo *res = bctbx_ip_address_to_addrinfo(ai_family,SOCK_STREAM/*needed on some platforms that return an error otherwise (QNX)*/,hop->host,hop->port);
chan=belle_sip_channel_find_from_list_with_addrinfo(l,hop,res);
if (res) bctbx_freeaddrinfo(res);
return chan;
}
void belle_sip_channel_check_dns_reusability(belle_sip_channel_t *obj) {
if (obj->dns_ttl_timedout) {
obj->dns_ttl_timedout = FALSE;
belle_sip_channel_resolve(obj);
}
}
#ifdef __ANDROID__
unsigned long belle_sip_begin_background_task(const char *name, belle_sip_background_task_end_callback_t cb, void *data){
return wake_lock_acquire(name);
}
void belle_sip_end_background_task(unsigned long id){
wake_lock_release(id);
}
#elif !TARGET_OS_IPHONE && !defined(__APPLE__)
/*defines stubs*/
unsigned long belle_sip_begin_background_task(const char *name, belle_sip_background_task_end_callback_t cb, void *data){
return 0;
}
void belle_sip_end_background_task(unsigned long id){
return;
}
#endif
belle-sip-5.2.0+dfsg/src/channel.h 0000664 0000000 0000000 00000027251 14346131365 0016676 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef BELLE_SIP_CHANNEL_H
#define BELLE_SIP_CHANNEL_H
#ifndef _WIN32
#include
#include
#else
#endif
#define belle_sip_network_buffer_size 65535
#define belle_sip_send_network_buffer_size 16384
typedef enum belle_sip_channel_state{
BELLE_SIP_CHANNEL_INIT,
BELLE_SIP_CHANNEL_RES_IN_PROGRESS,
BELLE_SIP_CHANNEL_RES_DONE,
BELLE_SIP_CHANNEL_CONNECTING,
BELLE_SIP_CHANNEL_RETRY,
BELLE_SIP_CHANNEL_READY,
BELLE_SIP_CHANNEL_ERROR,
BELLE_SIP_CHANNEL_DISCONNECTED
}belle_sip_channel_state_t;
const char * belle_sip_channel_state_to_string(belle_sip_channel_state_t state);
/**
* belle_sip_channel_t is an object representing a single communication channel ( socket or file descriptor),
* unlike the belle_sip_listening_point_t that can owns several channels for TCP or TLS (incoming server child sockets or
* outgoing client sockets).
**/
typedef struct belle_sip_channel belle_sip_channel_t;
BELLE_SIP_DECLARE_INTERFACE_BEGIN(belle_sip_channel_listener_t)
void (*on_state_changed)(belle_sip_channel_listener_t *l, belle_sip_channel_t *, belle_sip_channel_state_t state);
void (*on_message_headers)(belle_sip_channel_listener_t *l, belle_sip_channel_t *obj, belle_sip_message_t *msg);
void (*on_message)(belle_sip_channel_listener_t *l, belle_sip_channel_t *obj, belle_sip_message_t *msg);
void (*on_sending)(belle_sip_channel_listener_t *l, belle_sip_channel_t *obj, belle_sip_message_t *msg);
int (*on_auth_requested)(belle_sip_channel_listener_t *l, belle_sip_channel_t *obj, const char* distinghised_name);
BELLE_SIP_DECLARE_INTERFACE_END
#define BELLE_SIP_CHANNEL_LISTENER(obj) BELLE_SIP_INTERFACE_CAST(obj,belle_sip_channel_listener_t)
typedef enum input_stream_state {
WAITING_MESSAGE_START,
MESSAGE_AQUISITION,
BODY_AQUISITION
}input_stream_state_t;
typedef enum output_stream_state{
OUTPUT_STREAM_IDLE,
OUTPUT_STREAM_SENDING_HEADERS,
OUTPUT_STREAM_SENDING_BODY
}output_stream_state_t;
typedef struct belle_sip_channel_input_stream{
input_stream_state_t state;
char buff[belle_sip_network_buffer_size];
char* read_ptr;
char* write_ptr;
belle_sip_message_t *msg;
size_t content_length;
int chuncked_mode;
int chunk_size;
int chunk_read_size;
}belle_sip_channel_input_stream_t;
typedef struct belle_sip_stream_channel belle_sip_stream_channel_t;
typedef struct belle_sip_tls_channel belle_sip_tls_channel_t;
struct belle_sip_channel{
belle_sip_source_t base;
belle_sip_stack_t *stack;
belle_sip_listening_point_t *lp; /*the listening point that owns this channel*/
belle_sip_channel_state_t state;
belle_sip_list_t *state_listeners;
belle_sip_list_t *full_listeners;
int ai_family;
char *peer_cname; /* A or SRV name */
char *peer_name; /* A or SRV name */
int peer_port;
char *local_ip;
int local_port;
char *public_ip;
int public_port;
belle_sip_resolver_context_t* resolver_ctx;
belle_sip_resolver_results_t* resolver_results;
struct addrinfo *static_peer_list; /*this is the addrinfo when the channel is instanciated from destination IP address directly (no dns resolution)*/
const struct addrinfo *peer_list; /*points to the addrinfo list in resolver_results, or to the static_peer_list*/
const struct addrinfo *current_peer; /*points in the currently used element in peer_list */
const char *current_peer_cname; /*name of the host we are currently connected to. Set only in SRV case*/
belle_sip_list_t *outgoing_messages;
belle_sip_message_t *cur_out_message;
output_stream_state_t out_state;
uint8_t *ewouldblock_buffer;
size_t ewouldblock_size;
size_t ewouldblock_offset;
belle_sip_channel_input_stream_t input_stream;
belle_sip_list_t* incoming_messages;
belle_sip_source_t *inactivity_timer;
belle_sip_source_t *dns_ttl_timer;
uint64_t last_recv_time;
int simulated_recv_return; /* used to simulate network error. 0= no data (disconnected) >0= do nothing -1= network error, 1500 special number to silently discard incoming buffer*/
unsigned long bg_task_id;
unsigned long recv_bg_task_id;
unsigned char force_close; /* when channel is intentionnaly disconnected, in order to prevent looping notifications*/
unsigned char learnt_ip_port;
unsigned char has_name; /*set when the name of the peer is known, which is not the case of inboud connections*/
unsigned char about_to_be_closed;
unsigned char srv_overrides_port; /*set when this channel was connected to destination port provided by SRV resolution*/
unsigned char soft_error; /*set when this channel enters ERROR state because of error detected in upper layer */
unsigned char stop_logging_buffer; /*log buffer content only if this is non binary data, and stop it at the first occurence*/
unsigned char closed_by_remote; /*If the channel has been remotely closed*/
unsigned char dns_ttl_timedout;
unsigned char no_srv; /* Set to 1 if SRV must be skipped */
};
#define BELLE_SIP_CHANNEL(obj) BELLE_SIP_CAST(obj,belle_sip_channel_t)
BELLE_SIP_BEGIN_DECLS
void belle_sip_channel_add_listener(belle_sip_channel_t *chan, belle_sip_channel_listener_t *l);
void belle_sip_channel_remove_listener(belle_sip_channel_t *obj, belle_sip_channel_listener_t *l);
int belle_sip_channel_matches(const belle_sip_channel_t *obj, const belle_sip_hop_t *hop, const struct addrinfo *addr);
void belle_sip_channel_resolve(belle_sip_channel_t *obj);
void belle_sip_channel_connect(belle_sip_channel_t *obj);
void belle_sip_channel_prepare(belle_sip_channel_t *obj);
void belle_sip_channel_close(belle_sip_channel_t *obj);
/**
*
* returns number of send byte or <0 in case of error
*/
int belle_sip_channel_send(belle_sip_channel_t *obj, const void *buf, size_t buflen);
int belle_sip_channel_recv(belle_sip_channel_t *obj, void *buf, size_t buflen);
/*only used by channels implementation*/
void belle_sip_channel_set_ready(belle_sip_channel_t *obj, const struct sockaddr *addr, socklen_t slen);
void belle_sip_channel_init(belle_sip_channel_t *obj, belle_sip_stack_t *stack, const char *bindip,int localport, const char *peer_cname, const char *peername, int peer_port, int no_srv);
void belle_sip_channel_init_with_addr(belle_sip_channel_t *obj, belle_sip_stack_t *stack, const char *bindip, int localport, const struct sockaddr *peer_addr, socklen_t addrlen);
void belle_sip_channel_set_socket(belle_sip_channel_t *obj, belle_sip_socket_t sock, belle_sip_source_func_t datafunc);
/*end of channel implementations*/
/**
* Get a received message from the receive queue. This caller takes the ownership of the message.
*/
belle_sip_message_t* belle_sip_channel_pick_message(belle_sip_channel_t *obj);
int belle_sip_channel_queue_message(belle_sip_channel_t *obj, belle_sip_message_t *msg);
int belle_sip_channel_is_reliable(const belle_sip_channel_t *obj);
const char * belle_sip_channel_get_transport_name(const belle_sip_channel_t *obj);
const char * belle_sip_channel_get_transport_name_lower_case(const belle_sip_channel_t *obj);
const struct addrinfo * belle_sip_channel_get_peer(belle_sip_channel_t *obj);
BELLESIP_EXPORT const char *belle_sip_channel_get_local_address(belle_sip_channel_t *obj, int *port);
const char *belle_sip_channel_get_public_address(belle_sip_channel_t *obj, int *port);
/*
* Returns a sip-uri suitable for using in record-route.
* If the channel is not natted, it will return the listening port of the listening point corresponding to the channel.
**/
belle_sip_uri_t *belle_sip_channel_create_routable_uri(belle_sip_channel_t *chan);
#define belle_sip_channel_get_state(chan) ((chan)->state)
void channel_set_state(belle_sip_channel_t *obj, belle_sip_channel_state_t state);
/*
* Process incoming data and synchronously invoke the listeners if
* complete message are received. The invocation of the listeners may
* result in the channel being destroyed (ex: calling belle_sip_listening_point_clean_channels() within
* a transaction completed notification).
* WARNING: As a result, the caller of this function must be take into account that the channel no longer exists
* in return from this function.
*/
int belle_sip_channel_process_data(belle_sip_channel_t *obj,unsigned int revents);
/*this function is to be used only in belle_sip_listening_point_clean_channels()*/
void belle_sip_channel_force_close(belle_sip_channel_t *obj);
/*this function is for transactions to report that a channel seems non working because a timeout occured for example.
It results in the channel possibly entering error state, so that it gets cleaned. Next transactions will re-open a new one and
get a better chance of receiving an answer.
Returns TRUE if the channel enters error state, 0 otherwise (channel is given a second chance) */
int belle_sip_channel_notify_timeout(belle_sip_channel_t *obj);
/*Used by transaction layer to report a server having internal errors, so that we can retry with another IP (in case of DNS SRV)*/
BELLESIP_EXPORT void belle_sip_channel_notify_server_error(belle_sip_channel_t *obj);
/*
* Check if the DNS TTL has expired. If this is the case, set the channel status to RES_IN_PROGRESS.
*/
void belle_sip_channel_check_dns_reusability(belle_sip_channel_t *obj);
BELLE_SIP_END_DECLS
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_channel_t,belle_sip_source_t)
const char *transport;
int reliable;
int (*connect)(belle_sip_channel_t *obj, const struct addrinfo *ai);
int (*channel_send)(belle_sip_channel_t *obj, const void *buf, size_t buflen);
int (*channel_recv)(belle_sip_channel_t *obj, void *buf, size_t buflen);
void (*close)(belle_sip_channel_t *obj);
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
/*
* tls client certificate authentication. might be relevant for both tls and dtls channels.Only implemented in tls channel for now
*/
void belle_sip_tls_channel_set_client_certificates_chain(belle_sip_tls_channel_t *obj, belle_sip_certificates_chain_t* cert_chain);
void belle_sip_tls_channel_set_client_certificate_key(belle_sip_tls_channel_t *obj, belle_sip_signing_key_t* key);
belle_sip_channel_t *belle_sip_channel_find_from_list_with_addrinfo(belle_sip_list_t *l, const belle_sip_hop_t *hop, const struct addrinfo *addr);
belle_sip_channel_t *belle_sip_channel_find_from_list(belle_sip_list_t *l, int ai_family, const belle_sip_hop_t *hop);
#define BELLE_SIP_TLS_CHANNEL(obj) BELLE_SIP_CAST(obj,belle_sip_tls_channel_t)
struct belle_tls_crypto_config{
belle_sip_object_t base;
char *root_ca; /**< path to the trusted certificate chain used when verifiying peer certificate */
char *root_ca_data; /**< content of the trusted certificate chain used when verifiying peer certificate */
int exception_flags; /**< override some exception raised during certificate verification, can be:
BELLE_TLS_VERIFY_NONE do not override any exception
BELLE_TLS_VERIFY_CN_MISMATCH ignore Common Name mismatch exception
BELLE_TLS_VERIFY_ANY_REASON(ignore any exception */
void *ssl_config; /**< externally provided ssl configuration context, will be casted and given to the underlying crypto library, use only if you really know what you're doing */
belle_tls_crypto_config_verify_callback_t verify_cb;
void *verify_cb_data;
belle_tls_crypto_config_postcheck_callback_t postcheck_cb;
void *postcheck_cb_data;
};
#endif
belle-sip-5.2.0+dfsg/src/clock_gettime.c 0000664 0000000 0000000 00000012302 14346131365 0020061 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
/*
* Copyright (c), MM Weiss
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the MM Weiss nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
* SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* clock_gettime_stub.c
* gcc -Wall -c clock_gettime_stub.c
* posix realtime functions; MacOS user space glue
*/
/* @comment
* other possible implementation using intel builtin rdtsc
* rdtsc-workaround: http://www.mcs.anl.gov/~kazutomo/rdtsc.html
*
* we could get the ticks by doing this
*
* __asm __volatile("mov %%ebx, %%esi\n\t"
* "cpuid\n\t"
* "xchg %%esi, %%ebx\n\t"
* "rdtsc"
* : "=a" (a),
* "=d" (d)
* );
* we could even replace our tricky sched_yield call by assembly code to get a better accurency,
* anyway the following C stub will satisfy 99% of apps using posix clock_gettime call,
* moreover, the setter version (clock_settime) could be easly written using mach primitives:
* http://www.opensource.apple.com/source/xnu/xnu-${VERSION}/osfmk/man/ (clock_[set|get]_time)
*
* hackers don't be crackers, don't you use a flush toilet?
*
*
* @see draft: ./posix-realtime-stub/posix-realtime-stub.c
*
*/
#ifdef __APPLE__
#include
#include
#include
#include
#include
#include
#include
#include
#include "clock_gettime.h"
static mach_timebase_info_data_t __clock_gettime_inf;
static clock_serv_t belle_sip_calandar_clk;
static clock_serv_t belle_sip_system_clk;
static int belle_sip_clock_serv_ready=FALSE;
int bc_clock_gettime(bc_clockid_t clk_id, struct timespec *tp) {
kern_return_t ret;
clock_serv_t clk_serv;
mach_timespec_t tm;
uint64_t start, end, delta, nano;
int retval = -1;
if (!belle_sip_clock_serv_ready) { /*host_get_clock_service is pretty slow*/
if (KERN_SUCCESS != host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &belle_sip_calandar_clk)
|| KERN_SUCCESS != host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &belle_sip_system_clk) ) {
return -1;
} else {
belle_sip_clock_serv_ready=TRUE;
}
}
switch (clk_id) {
case BC_CLOCK_REALTIME:
case BC_CLOCK_MONOTONIC:
clk_serv = (clk_id == BC_CLOCK_REALTIME) ? belle_sip_calandar_clk : belle_sip_system_clk;
if (KERN_SUCCESS == (ret = clock_get_time(clk_serv, &tm))) {
tp->tv_sec = tm.tv_sec;
tp->tv_nsec = tm.tv_nsec;
retval = 0;
}
if (KERN_SUCCESS != ret) {
errno = EINVAL;
retval = -1;
}
break;
case BC_CLOCK_PROCESS_CPUTIME_ID:
case BC_CLOCK_THREAD_CPUTIME_ID:
start = mach_absolute_time();
if (clk_id == BC_CLOCK_PROCESS_CPUTIME_ID) {
getpid();
} else {
sched_yield();
}
end = mach_absolute_time();
delta = end - start;
if (0 == __clock_gettime_inf.denom) {
mach_timebase_info(&__clock_gettime_inf);
}
nano = delta * __clock_gettime_inf.numer / __clock_gettime_inf.denom;
tp->tv_sec = nano * 1e-9;
tp->tv_nsec = nano - (tp->tv_sec * 1e9);
retval = 0;
break;
default:
errno = EINVAL;
retval = -1;
}
return retval;
}
#endif // __APPLE__
/* EOF */
belle-sip-5.2.0+dfsg/src/clock_gettime.h 0000664 0000000 0000000 00000002037 14346131365 0020072 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef CLOCK_GETTIME_H_
#define CLOCK_GETTIME_H_
#ifdef __APPLE__
typedef enum {
BC_CLOCK_REALTIME,
BC_CLOCK_MONOTONIC,
BC_CLOCK_PROCESS_CPUTIME_ID,
BC_CLOCK_THREAD_CPUTIME_ID
} bc_clockid_t;
int bc_clock_gettime(bc_clockid_t clk_id, struct timespec *tp) ;
#endif
#endif /* CLOCK_GETTIME_H_ */
belle-sip-5.2.0+dfsg/src/cpp_utils.cc 0000664 0000000 0000000 00000007402 14346131365 0017422 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include
#include
#include "bctoolbox/crypto.hh"
/**
* Write random bytes of supplied size.
**/
unsigned char * belle_sip_random_bytes(unsigned char *ret, size_t size){
bctoolbox::RNG::cRandomize(ret, size);
return ret;
}
uint32_t belle_sip_random(void){
return bctoolbox::RNG::cRandomize();
}
static belle_sip_source_t * _belle_sip_main_loop_create_cpp_timeout(
belle_sip_main_loop_t *ml,
belle_sip_source_cpp_func_t *func,
unsigned int timeout_value_ms,
const char* timer_name
) {
return belle_sip_main_loop_create_timeout_with_remove_cb(
ml,
[](void *user_data, unsigned int events){
return static_cast(user_data)->operator()(events);
},
func,
timeout_value_ms,
timer_name,
[](belle_sip_source_t* source){
delete static_cast(belle_sip_source_get_user_data(source));
belle_sip_source_set_user_data(source, nullptr);
}
);
}
belle_sip_source_t * belle_sip_main_loop_create_cpp_timeout(
belle_sip_main_loop_t *ml,
belle_sip_source_cpp_func_t *func,
unsigned int timeout_value_ms,
const char* timer_name
) {
return _belle_sip_main_loop_create_cpp_timeout(ml, func, timeout_value_ms, timer_name);
}
BelleSipSourcePtr belle_sip_main_loop_create_cpp_timeout(
belle_sip_main_loop_t *ml,
const belle_sip_source_cpp_func_t &func,
unsigned int timeout_value_ms,
const char* timer_name
) {
belle_sip_source_t* source = _belle_sip_main_loop_create_cpp_timeout(
ml,
new belle_sip_source_cpp_func_t{func},
timeout_value_ms,
timer_name
);
return BelleSipSourcePtr{source};
}
void belle_sip_main_loop_cpp_do_later(belle_sip_main_loop_t *ml, const BelleSipDoLaterFunc &func){
belle_sip_main_loop_cpp_do_later(ml, func, nullptr);
}
static void cpp_timer_delete(belle_sip_source_t* source){
std::function *func = static_cast< std::function *>(belle_sip_source_get_user_data(source));
delete func;
belle_sip_source_set_user_data(source,NULL);
}
static int cpp_timer_func(void *ud, unsigned int events){
std::function *func = static_cast< std::function *>(ud);
bool ret = (*func)();
return ret ? BELLE_SIP_CONTINUE : BELLE_SIP_STOP;
}
belle_sip_source_t * belle_sip_main_loop_create_cpp_timeout_2(belle_sip_main_loop_t *ml,
const std::function &func,
unsigned int timeout_value_ms,
const std::string &timer_name){
belle_sip_source_t* source = belle_sip_main_loop_create_timeout( ml
, (belle_sip_source_func_t)cpp_timer_func
, new std::function(func)
, timeout_value_ms
, timer_name.c_str());
belle_sip_source_set_remove_cb(source, cpp_timer_delete);
return source;
}
void belle_sip_main_loop_cpp_do_later(
belle_sip_main_loop_t *ml,
const BelleSipDoLaterFunc &func,
const char *task_name
) {
belle_sip_main_loop_do_later_with_name(
ml,
[](void *ud){
auto func = static_cast(ud);
func->operator()();
delete func;
},
new BelleSipDoLaterFunc{func},
task_name
);
}
belle-sip-5.2.0+dfsg/src/dialog.c 0000664 0000000 0000000 00000155456 14346131365 0016531 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012-2019 Belledonne Communications SARL.
*
* This file is part of belle-sip.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "belle_sip_internal.h"
#include
static void belle_sip_dialog_init_200Ok_retrans(belle_sip_dialog_t *obj, belle_sip_response_t *resp);
static int belle_sip_dialog_handle_200Ok(belle_sip_dialog_t *obj, belle_sip_response_t *msg);
static void belle_sip_dialog_process_queue(belle_sip_dialog_t* dialog);
static belle_sip_request_t *create_request(belle_sip_dialog_t *obj, const char *method, int full);
static void belle_sip_dialog_uninit(belle_sip_dialog_t *obj){
if (obj->route_set)
belle_sip_list_free_with_data(obj->route_set,belle_sip_object_unref);
if (obj->remote_target)
belle_sip_object_unref(obj->remote_target);
if (obj->call_id)
belle_sip_object_unref(obj->call_id);
if (obj->local_party)
belle_sip_object_unref(obj->local_party);
if (obj->remote_party)
belle_sip_object_unref(obj->remote_party);
if (obj->local_tag)
belle_sip_free(obj->local_tag);
if (obj->remote_tag)
belle_sip_free(obj->remote_tag);
if (obj->last_out_invite)
belle_sip_object_unref(obj->last_out_invite);
if (obj->last_out_ack)
belle_sip_object_unref(obj->last_out_ack);
if (obj->last_transaction)
belle_sip_object_unref(obj->last_transaction);
if(obj->privacy)
belle_sip_object_unref(obj->privacy);
if (obj->expiration_timer){ /*In some situations, dialog deleted might not be called*/
belle_sip_main_loop_remove_source(obj->provider->stack->ml, obj->expiration_timer);
belle_sip_object_unref(obj->expiration_timer);
obj->expiration_timer = NULL;
}
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_dialog_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_sip_dialog_t, belle_sip_object_t, belle_sip_dialog_uninit, NULL, NULL, TRUE);
const char* belle_sip_dialog_state_to_string(const belle_sip_dialog_state_t state) {
switch(state) {
case BELLE_SIP_DIALOG_NULL: return "BELLE_SIP_DIALOG_NULL";
case BELLE_SIP_DIALOG_EARLY: return "BELLE_SIP_DIALOG_EARLY";
case BELLE_SIP_DIALOG_CONFIRMED: return "BELLE_SIP_DIALOG_CONFIRMED";
case BELLE_SIP_DIALOG_TERMINATED: return "BELLE_SIP_DIALOG_TERMINATED";
default: return "Unknown state";
}
}
static void set_state(belle_sip_dialog_t *obj,belle_sip_dialog_state_t state) {
obj->previous_state=obj->state;
obj->state=state;
}
static void set_to_tag(belle_sip_dialog_t *obj, belle_sip_header_to_t *to){
const char *to_tag=belle_sip_header_to_get_tag(to);
if (obj->is_server){
if (to_tag && !obj->local_tag)
obj->local_tag=belle_sip_strdup(to_tag);
}else{
if (to_tag && !obj->remote_tag)
obj->remote_tag=belle_sip_strdup(to_tag);
}
}
static void check_route_set(belle_sip_list_t *rs){
if (rs){
belle_sip_header_route_t *r=(belle_sip_header_route_t*)rs->data;
if (!belle_sip_uri_has_lr_param(belle_sip_header_address_get_uri((belle_sip_header_address_t*)r))){
belle_sip_warning("top uri of route set does not contain 'lr', not really supported.");
}
}
}
static int belle_sip_dialog_init_as_uas(belle_sip_dialog_t *obj, belle_sip_request_t *req){
const belle_sip_list_t *elem;
belle_sip_header_contact_t *ct=belle_sip_message_get_header_by_type(req,belle_sip_header_contact_t);
belle_sip_header_cseq_t *cseq=belle_sip_message_get_header_by_type(req,belle_sip_header_cseq_t);
belle_sip_header_via_t *via=belle_sip_message_get_header_by_type(req,belle_sip_header_via_t);
belle_sip_uri_t *requri=belle_sip_request_get_uri(req);
belle_sip_header_to_t *to=belle_sip_message_get_header_by_type(req,belle_sip_header_to_t);
if (!ct){
belle_sip_error("No contact in request.");
return -1;
}
if (!cseq){
belle_sip_error("No cseq in request.");
return -1;
}
if (!via){
belle_sip_error("No via in request.");
return -1;
}
if (!to){
belle_sip_error("No to in request.");
return -1;
}
if (strcasecmp(belle_sip_header_via_get_protocol(via),"TLS")==0
&& belle_sip_uri_is_secure(requri)){
obj->is_secure=TRUE;
}
/* 12.1.1
*The route set MUST be set to the list of URIs in the Record-Route
* header field from the request, taken in order and preserving all URI
* parameters. If no Record-Route header field is present in the
*request, the route set MUST be set to the empty set.
*/
obj->route_set=belle_sip_list_free_with_data(obj->route_set,belle_sip_object_unref);
for(elem=belle_sip_message_get_headers((belle_sip_message_t*)req,BELLE_SIP_RECORD_ROUTE);elem!=NULL;elem=elem->next){
obj->route_set=belle_sip_list_append(obj->route_set,belle_sip_object_ref(belle_sip_header_route_create(
(belle_sip_header_address_t*)elem->data)));
}
check_route_set(obj->route_set);
obj->remote_target=(belle_sip_header_address_t*)belle_sip_object_ref(ct);
obj->remote_cseq=belle_sip_header_cseq_get_seq_number(cseq);
if (strcmp(belle_sip_request_get_method(req),"INVITE")==0){
obj->remote_invite_cseq = belle_sip_header_cseq_get_seq_number(cseq);
}
/*remote party already set */
obj->local_party=(belle_sip_header_address_t*)belle_sip_object_ref(to);
return 0;
}
static void set_last_out_invite(belle_sip_dialog_t *obj, belle_sip_request_t *req){
if (obj->last_out_invite)
belle_sip_object_unref(obj->last_out_invite);
obj->last_out_invite=(belle_sip_request_t*)belle_sip_object_ref(req);
}
static int belle_sip_dialog_init_as_uac(belle_sip_dialog_t *obj, belle_sip_request_t *req){
belle_sip_header_cseq_t *cseq=belle_sip_message_get_header_by_type(req,belle_sip_header_cseq_t);
belle_sip_header_to_t *to=belle_sip_message_get_header_by_type(req,belle_sip_header_to_t);
belle_sip_header_via_t *via=belle_sip_message_get_header_by_type(req,belle_sip_header_via_t);
belle_sip_uri_t *requri=belle_sip_request_get_uri(req);
if (!to){
belle_sip_error("No to in request.");
return -1;
}
if (!cseq){
belle_sip_error("No cseq in request.");
return -1;
}
if (!via){
belle_sip_error("No via in request.");
return -1;
}
if (belle_sip_header_via_get_protocol(via) /*might be null at dialog creation (uac case)*/
&& strcasecmp(belle_sip_header_via_get_protocol(via),"TLS")==0
&& belle_sip_uri_is_secure(requri)){
obj->is_secure=TRUE;
}
obj->local_cseq=belle_sip_header_cseq_get_seq_number(cseq);
/*call id is already set */
/*local_tag is already set*/
obj->remote_party=(belle_sip_header_address_t*)belle_sip_object_ref(to);
/*local party is already set*/
if (strcmp(belle_sip_request_get_method(req),"INVITE")==0){
set_last_out_invite(obj,req);
}
return 0;
}
static int belle_sip_dialog_on_expired(belle_sip_dialog_t *dialog){
belle_sip_message("Dialog [%p] expired", dialog);
dialog->is_expired = TRUE;
belle_sip_dialog_delete(dialog);
return BELLE_SIP_STOP;
}
int belle_sip_dialog_expired(const belle_sip_dialog_t *dialog){
return dialog->is_expired;
}
/*returns BELLE_SIP_STOP if the dialog is to be terminated, BELLE_SIP_CONTINUE otherwise*/
static int belle_sip_dialog_schedule_expiration(belle_sip_dialog_t *dialog, belle_sip_message_t *request){
belle_sip_header_expires_t *expires = belle_sip_message_get_header_by_type(request, belle_sip_header_expires_t);
int expires_value;
if (!expires) return BELLE_SIP_CONTINUE;
expires_value = belle_sip_header_expires_get_expires(expires);
if (dialog->expiration_timer){
belle_sip_main_loop_remove_source(dialog->provider->stack->ml, dialog->expiration_timer);
belle_sip_object_unref(dialog->expiration_timer);
dialog->expiration_timer = NULL;
}
belle_sip_message("belle_sip_dialog_schedule_expiration() dialog=%p expires_value=%i", dialog, expires_value);
if (expires_value == 0) return BELLE_SIP_STOP;
dialog->expiration_timer = belle_sip_main_loop_create_timeout(dialog->provider->stack->ml,
(belle_sip_source_func_t) belle_sip_dialog_on_expired,
dialog,
expires_value * 1000,
"Dialog expiration");
return BELLE_SIP_CONTINUE;
}
int belle_sip_dialog_establish_full(belle_sip_dialog_t *obj, belle_sip_request_t *req, belle_sip_response_t *resp){
belle_sip_header_contact_t *ct=belle_sip_message_get_header_by_type(resp,belle_sip_header_contact_t);
belle_sip_header_to_t *to=belle_sip_message_get_header_by_type(resp,belle_sip_header_to_t);
const belle_sip_list_t *elem;
if (strcmp(belle_sip_request_get_method(req),"INVITE")==0)
obj->needs_ack=TRUE;
if (obj->is_server){
if (strcmp(belle_sip_request_get_method(req),"INVITE")==0){
belle_sip_dialog_init_200Ok_retrans(obj,resp);
}
} else {
if (!ct && !obj->remote_target) {
belle_sip_error("Missing contact header in resp [%p] cannot set remote target for dialog [%p]",resp,obj);
return -1;
}
/* 13.2.2.4 2xx Responses
...
If the dialog identifier in the 2xx response matches the dialog
identifier of an existing dialog, the dialog MUST be transitioned to
the "confirmed" state, and the route set for the dialog MUST be
recomputed based on the 2xx response using the procedures of Section
12.2.1.2.
*/
obj->route_set=belle_sip_list_free_with_data(obj->route_set,belle_sip_object_unref);
for(elem=belle_sip_message_get_headers((belle_sip_message_t*)resp,BELLE_SIP_RECORD_ROUTE);elem!=NULL;elem=elem->next){
obj->route_set=belle_sip_list_prepend(obj->route_set,belle_sip_object_ref(belle_sip_header_route_create(
(belle_sip_header_address_t*)elem->data)));
}
if (ct) {
/*remote Contact header may have changed between early dialog to confirmed*/
if (obj->remote_target) belle_sip_object_unref(obj->remote_target);
obj->remote_target=(belle_sip_header_address_t*)belle_sip_object_ref(ct);
}
}
/*update to tag*/
set_to_tag(obj,to);
set_state(obj,BELLE_SIP_DIALOG_CONFIRMED);
return 0;
}
int belle_sip_dialog_establish(belle_sip_dialog_t *obj, belle_sip_request_t *req, belle_sip_response_t *resp){
belle_sip_header_to_t *to=belle_sip_message_get_header_by_type(resp,belle_sip_header_to_t);
belle_sip_header_via_t *via=belle_sip_message_get_header_by_type(req,belle_sip_header_via_t);
belle_sip_uri_t *requri=belle_sip_request_get_uri(req);
if (obj->state != BELLE_SIP_DIALOG_NULL) {
belle_sip_error("Dialog [%p] already established.",obj);
return -1;
}
if (!to){
belle_sip_error("No to in response.");
return -1;
}
if (!obj->is_server) {
belle_sip_header_contact_t *ct=belle_sip_message_get_header_by_type(resp,belle_sip_header_contact_t);
const belle_sip_list_t* elem;
/*contact might be provided later*/
if (ct)
obj->remote_target=(belle_sip_header_address_t*)belle_sip_object_ref(ct);
/**12.1.2
* The route set MUST be set to the list of URIs in the Record-Route
*header field from the response, taken in reverse order and preserving
*all URI parameters. If no Record-Route header field is present in
*the response, the route set MUST be set to the empty set.
**/
obj->route_set=belle_sip_list_free_with_data(obj->route_set,belle_sip_object_unref);
for(elem=belle_sip_message_get_headers((belle_sip_message_t*)resp,BELLE_SIP_RECORD_ROUTE);elem!=NULL;elem=elem->next){
obj->route_set=belle_sip_list_prepend(obj->route_set,belle_sip_object_ref(belle_sip_header_route_create(
(belle_sip_header_address_t*)elem->data)));
}
check_route_set(obj->route_set);
/*via might be unknown at dialog creation*/
if (strcasecmp(belle_sip_header_via_get_protocol(via),"TLS")==0
&& belle_sip_uri_is_secure(requri)){
obj->is_secure=TRUE;
}
}
set_to_tag(obj,to);
return 0;
}
int belle_sip_dialog_check_incoming_request_ordering(belle_sip_dialog_t *obj, belle_sip_request_t *req){
belle_sip_header_cseq_t *cseqh=belle_sip_message_get_header_by_type(req,belle_sip_header_cseq_t);
unsigned int cseq=belle_sip_header_cseq_get_seq_number(cseqh);
if (obj->remote_cseq==0){
obj->remote_cseq=cseq;
}else if (cseq>obj->remote_cseq){
return 0;
}
belle_sip_warning("Ignoring request because cseq is inconsistent.");
return -1;
}
static int dialog_on_200Ok_timer(belle_sip_dialog_t *dialog){
/*reset the timer */
const belle_sip_timer_config_t *cfg=belle_sip_stack_get_timer_config(dialog->provider->stack);
int64_t prev_timeout=belle_sip_source_get_timeout_int64(dialog->timer_200Ok);
belle_sip_source_set_timeout_int64(dialog->timer_200Ok, MIN(2*prev_timeout,cfg->T2));
belle_sip_message("Dialog sending retransmission of 200Ok");
belle_sip_provider_send_response(dialog->provider,dialog->last_200Ok);
return BELLE_SIP_CONTINUE;
}
static int dialog_on_200Ok_end(belle_sip_dialog_t *dialog){
belle_sip_request_t *bye;
belle_sip_client_transaction_t *trn;
belle_sip_header_reason_t *reason;
belle_sip_dialog_stop_200Ok_retrans(dialog);
belle_sip_error("Dialog [%p] was not ACK'd within T1*64 seconds.", dialog);
if (dialog->last_transaction){
/* Check if a BYE is not already in progress, no need to send a second one.*/
const char * request = belle_sip_request_get_method(belle_sip_transaction_get_request(dialog->last_transaction));
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(dialog->last_transaction,belle_sip_client_transaction_t) && strcmp(request, "BYE") == 0){
return BELLE_SIP_STOP;
}
}
belle_sip_error("Dialog [%p] it is going to be terminated automatically.",dialog);
dialog->state=BELLE_SIP_DIALOG_CONFIRMED;
bye=belle_sip_dialog_create_request(dialog,"BYE");
reason=belle_sip_header_reason_new();
belle_sip_header_reason_set_protocol(reason,"SIP");
belle_sip_header_reason_set_cause(reason,408);
belle_sip_header_reason_set_text(reason,"no ACK received");
belle_sip_message_add_header(BELLE_SIP_MESSAGE(bye), BELLE_SIP_HEADER(reason));
dialog->termination_cause = BELLE_SIP_DIALOG_TERMINATION_CAUSE_ABORT_NO_ACK;
trn=belle_sip_provider_create_client_transaction(dialog->provider,bye);
BELLE_SIP_TRANSACTION(trn)->is_internal=1; /*don't bother user with this transaction*/
belle_sip_client_transaction_send_request(trn);
return BELLE_SIP_STOP;
}
static void belle_sip_dialog_init_200Ok_retrans(belle_sip_dialog_t *obj, belle_sip_response_t *resp){
const belle_sip_timer_config_t *cfg=belle_sip_stack_get_timer_config(obj->provider->stack);
if (obj->timer_200Ok || obj->timer_200Ok_end) {
belle_sip_error("dialog [%p] already has a 200ok retransmition timer ! skipping",obj);
return;
}
obj->timer_200Ok=belle_sip_timeout_source_new((belle_sip_source_func_t)dialog_on_200Ok_timer,obj,cfg->T1);
belle_sip_object_set_name((belle_sip_object_t*)obj->timer_200Ok,"dialog_200Ok_timer");
belle_sip_main_loop_add_source(obj->provider->stack->ml,obj->timer_200Ok);
obj->timer_200Ok_end=belle_sip_timeout_source_new((belle_sip_source_func_t)dialog_on_200Ok_end,obj,cfg->T1*64);
belle_sip_object_set_name((belle_sip_object_t*)obj->timer_200Ok_end,"dialog_200Ok_timer_end");
belle_sip_main_loop_add_source(obj->provider->stack->ml,obj->timer_200Ok_end);
obj->last_200Ok=(belle_sip_response_t*)belle_sip_object_ref(resp);
}
void belle_sip_dialog_stop_200Ok_retrans(belle_sip_dialog_t *obj){
belle_sip_main_loop_t *ml=obj->provider->stack->ml;
if (obj->timer_200Ok){
belle_sip_main_loop_remove_source(ml,obj->timer_200Ok);
belle_sip_object_unref(obj->timer_200Ok);
obj->timer_200Ok=NULL;
}
if (obj->timer_200Ok_end){
belle_sip_main_loop_remove_source(ml,obj->timer_200Ok_end);
belle_sip_object_unref(obj->timer_200Ok_end);
obj->timer_200Ok_end=NULL;
}
if (obj->last_200Ok){
belle_sip_object_unref(obj->last_200Ok);
obj->last_200Ok=NULL;
}
}
/* returns true if the dialog is terminated by the NOTIFY request or response*/
static int belle_sip_dialog_should_terminate_by_notify(belle_sip_dialog_t *obj, belle_sip_transaction_t* transaction, int as_uas){
int should_terminate = FALSE;
if (obj->type == BELLE_SIP_DIALOG_SUBSCRIBE_NOTIFY) {
belle_sip_request_t *req=belle_sip_transaction_get_request(transaction);
belle_sip_response_t *resp=belle_sip_transaction_get_response(transaction);
belle_sip_header_subscription_state_t* subscription_state_header=belle_sip_message_get_header_by_type(req,belle_sip_header_subscription_state_t);
int code = resp ? belle_sip_response_get_status_code(resp) : 0;
if (!subscription_state_header || strcasecmp(BELLE_SIP_SUBSCRIPTION_STATE_TERMINATED,belle_sip_header_subscription_state_get_state(subscription_state_header)) ==0) {
if (as_uas){
/*terminate the dialog when the application replies the 200 Ok*/
if (code == 200){
should_terminate = TRUE;
}
}else{
/*terminate the dialog when we receive the 200OK or the transaction terminates by timeout*/
if (code == 200 || belle_sip_transaction_get_state(transaction) == BELLE_SIP_TRANSACTION_TERMINATED){
should_terminate = TRUE;
}
}
}
}
return should_terminate;
}
static void belle_sip_dialog_update_remote_target(belle_sip_dialog_t *obj, belle_sip_header_contact_t *ct) {
int remote_target_changed = FALSE;
if (obj->remote_target) {
belle_sip_uri_t *remote_target_uri = belle_sip_header_address_get_uri(obj->remote_target);
belle_sip_uri_t *ct_uri = belle_sip_header_address_get_uri((belle_sip_header_address_t *)ct);
remote_target_changed = !belle_sip_uri_equals(remote_target_uri, ct_uri);
belle_sip_object_unref(obj->remote_target);
}
obj->remote_target=(belle_sip_header_address_t*)belle_sip_object_ref(ct);
if (remote_target_changed) {
belle_sip_message("Dialog [%p]: remote target changed", obj);
if (obj->last_out_ack) {
belle_sip_request_set_uri(BELLE_SIP_REQUEST(obj->last_out_ack), belle_sip_header_address_get_uri(obj->remote_target));
}
}
}
static void belle_sip_dialog_update_local_cseq(belle_sip_dialog_t *obj, const char *method){
if (obj->local_cseq==0) obj->local_cseq=110;
if (strcmp(method,"ACK")!=0) obj->local_cseq++;
}
static belle_sip_request_t *belle_sip_dialog_create_prack(belle_sip_dialog_t *dialog, unsigned int rseq, unsigned int cseq, const char* method){
belle_sip_request_t *prack;
belle_sip_request_t *invite = dialog->last_out_invite;
if (!invite){
belle_sip_error("No INVITE to PACK.");
return NULL;
}
prack = belle_sip_dialog_create_request(dialog, "PRACK");
if (prack){
//RAck
char header[50];
snprintf(header,sizeof(header),"%d %d %s", rseq, cseq, method);
belle_sip_header_t *rack = belle_sip_header_create("RAck", header);
belle_sip_message_add_header(BELLE_SIP_MESSAGE(prack), rack);
//Contact
belle_sip_header_from_t* from_header = belle_sip_message_get_header_by_type(prack, belle_sip_header_from_t);
belle_sip_uri_t* req_uri = belle_sip_header_address_get_uri((belle_sip_header_address_t*)from_header);
belle_sip_header_contact_t* contact_header = belle_sip_header_contact_new();
belle_sip_header_address_set_uri((belle_sip_header_address_t*)contact_header, belle_sip_uri_new());
belle_sip_uri_set_user(belle_sip_header_address_get_uri((belle_sip_header_address_t*)contact_header),belle_sip_uri_get_user(req_uri));
belle_sip_message_add_header(BELLE_SIP_MESSAGE(prack),BELLE_SIP_HEADER(contact_header));
}
return prack;
}
static void belle_sip_dialog_send_prack(belle_sip_dialog_t *dialog, belle_sip_request_t *request){
belle_sip_provider_send_request(dialog->provider, request);
}
/*return 0 if message should be delivered to the next listener, otherwise, its a retransmision, just keep it*/
static int belle_sip_dialog_process_response_100rel(belle_sip_dialog_t *obj, belle_sip_transaction_t* transaction){
belle_sip_response_t *resp = belle_sip_transaction_get_response(transaction);
belle_sip_message_t* msg = (belle_sip_message_t*)resp;
belle_sip_header_cseq_t *header_cseq_resp = belle_sip_message_get_header_by_type(msg, belle_sip_header_cseq_t);
int ret = 0;
if (header_cseq_resp == NULL){
belle_sip_message("Message [%p] does not contain CSeq header!", msg);
}
belle_sip_header_require_t* header_require = belle_sip_message_get_header_by_type(msg, belle_sip_header_require_t);
if (header_require){
belle_sip_list_t* list = belle_sip_header_require_get_require(header_require);
int require_100rel = 0;
while (list){
if (strcmp(list->data, "100rel") == 0){
require_100rel = 1;
break;
}
list=list->next;
}
if (require_100rel){
belle_sip_message("Found header Require with value 100rel in message [%p].", msg);
belle_sip_header_t *header_rseq = belle_sip_message_get_header(msg, "RSeq");
if (header_rseq){
const char* header_rseq_value = belle_sip_header_get_unparsed_value(header_rseq);
long rseq = strtol(header_rseq_value, NULL, 10);
unsigned int cseq_resp = belle_sip_header_cseq_get_seq_number(header_cseq_resp);
const char* method_resp = belle_sip_header_cseq_get_method(header_cseq_resp);
/*"A response is a retransmission when
its dialog ID, CSeq, and RSeq match the original response". Currently we only store last acknoledged Rseq. This data is used to detect retransmitions*/
belle_sip_ict_t * ict = BELLE_SIP_CAST(transaction,belle_sip_ict_t);
if (ict->r_cseq > 0 && ict->r_cseq >= (unsigned int)rseq) {
belle_sip_warning("provisionnal response with sequence number [%ld] already acknoledged, dropping",rseq);
ret = -1;
} else {
/*send PRACK from callee */
belle_sip_request_t *prack = belle_sip_dialog_create_prack(obj, rseq, cseq_resp, method_resp);
if (prack){
/*put auth header*/
belle_sip_provider_add_authorization(transaction->provider,prack,transaction->last_response,NULL,NULL,NULL);
belle_sip_dialog_send_prack(obj, prack);
ict->r_cseq = rseq;
} else {
belle_sip_message("Failed to create PRACK message!");
}
}
}
else {
belle_sip_message("Message [%p] does not contain RSeq header! (required be with 100rel)", msg);
}
}
}
return ret;
}
/*
* return 0 if message should be delivered to the next listener, otherwise, its a retransmision, just keep it
* */
int belle_sip_dialog_update(belle_sip_dialog_t *obj, belle_sip_transaction_t* transaction, int as_uas){
int is_retransmition=FALSE;
int delete_dialog=FALSE;
belle_sip_request_t *req=belle_sip_transaction_get_request(transaction);
belle_sip_header_cseq_t* current_cseq=belle_sip_message_get_header_by_type(BELLE_SIP_MESSAGE(req),belle_sip_header_cseq_t);
unsigned int current_transaction_cseq = belle_sip_header_cseq_get_seq_number(current_cseq);
belle_sip_response_t *resp=belle_sip_transaction_get_response(transaction);
int code=0;
int ret = 0;
int is_invite = strcmp(belle_sip_request_get_method(req),"INVITE")==0;
int is_subscribe = strcmp(belle_sip_request_get_method(req),"SUBSCRIBE")==0;
int is_notify = strcmp(belle_sip_request_get_method(req),"NOTIFY")==0;
belle_sip_transaction_t *previous_transaction = NULL;
belle_sip_message("Dialog [%p]: now updated by transaction [%p].",obj, transaction);
if (resp)
code=belle_sip_response_get_status_code(resp);
bool_t do_not_update_last_transaction = (as_uas && (code == 491));
if (do_not_update_last_transaction) { /**/
belle_sip_message("Dialog [%p]: don't update last transaction by transaction [%p].",obj, transaction);
} else {
belle_sip_object_ref(transaction);
if (obj->last_transaction) {
previous_transaction = obj->last_transaction;
}
obj->last_transaction=transaction;
}
if (!as_uas){
belle_sip_header_privacy_t *privacy_header=belle_sip_message_get_header_by_type(req,belle_sip_header_privacy_t);
SET_OBJECT_PROPERTY(obj,privacy,privacy_header);
}
/*
first update local/remote cseq
Do not update remote and remote invite CSeq if it is lower than the current one as it may be a retransmission and the next transaction may already be executing
*/
if (as_uas) {
bool_t update_remote_invite_cseq = (obj->remote_invite_cseq < current_transaction_cseq);
bool_t update_cseq = (obj->remote_cseq < current_transaction_cseq);
if ((is_invite && (code>=200) && (code<300) && !update_remote_invite_cseq) || (!update_cseq && !do_not_update_last_transaction)) {
obj->last_transaction=previous_transaction;
}
if (update_cseq) {
obj->remote_cseq=current_transaction_cseq;
}
if (is_invite && (code>=200) && (code<300) && update_remote_invite_cseq) {
obj->remote_invite_cseq = current_transaction_cseq;
} /*else ACK is handled by transaction, not dialog*/
}
switch (obj->state){
case BELLE_SIP_DIALOG_NULL:
/*always establish a dialog*/
if (code>100 && code<300 && (is_invite || is_subscribe)) {
belle_sip_dialog_establish(obj,req,resp);
if (code<200){
set_state(obj,BELLE_SIP_DIALOG_EARLY);
if (!as_uas) {
belle_sip_dialog_process_response_100rel(obj, transaction);
}
break;
}/* no break for code >200 because need to call belle_sip_dialog_establish_full*/
}
BCTBX_NO_BREAK; /*intentionally no break*/
case BELLE_SIP_DIALOG_EARLY:
/*don't terminate dialog for UPDATE*/
if (code>=300 && ((is_invite && code!=407) || is_subscribe)) {
/*12.3 Termination of a Dialog
Independent of the method, if a request outside of a dialog generates
a non-2xx final response, any early dialogs created through
provisional responses to that request are terminated. The mechanism
for terminating confirmed dialogs is method specific.*/
delete_dialog=TRUE;
break;
}
if (code>=200 && code<300 && (is_invite || is_subscribe)){
if (belle_sip_dialog_establish_full(obj,req,resp) != 0){
/*the dialog found this response invalid so notify the transaction layer by returning -1*/
ret = -1;
goto end;
}
}
if (is_subscribe){
if (belle_sip_dialog_schedule_expiration(obj, (belle_sip_message_t*)req) == BELLE_SIP_STOP
&& (code>=200 || (code==0 && belle_sip_transaction_get_state(transaction)==BELLE_SIP_TRANSACTION_TERMINATED))){
/*delete the dialog when the 200Ok for a SUBSCRIBE with expires=0 is received or when
* no response is received at all*/
delete_dialog = TRUE;
}
}
if (code < 200 && belle_sip_transaction_get_state(transaction)==BELLE_SIP_TRANSACTION_TERMINATED){
/*no response establishing the dialog, and transaction terminated (transport errors)*/
delete_dialog=TRUE;
}
if ((code > 100 && code < 200) && !as_uas) {
if (belle_sip_dialog_process_response_100rel(obj, transaction)) {
/*retransmition detected, dropping*/
ret = -1;
goto end;
}
}
break;
case BELLE_SIP_DIALOG_CONFIRMED:
if (code==481 && (is_invite || is_subscribe)) {
/*Dialog is terminated in such case*/
delete_dialog=TRUE;
break;
}
/*refreshing target is also true in case of subscribe*/
if ((is_invite || is_subscribe) && (code>=200 && code<300)) {
/*refresh the remote_target*/
belle_sip_header_contact_t *ct;
if (as_uas){
ct=belle_sip_message_get_header_by_type(req,belle_sip_header_contact_t);
}else{
if (is_invite)
set_last_out_invite(obj,req);
ct=belle_sip_message_get_header_by_type(resp,belle_sip_header_contact_t);
}
if (ct){
belle_sip_dialog_update_remote_target(obj, ct);
}
}
if (is_invite){
if (code>=200 && code<300){
/*handle possible retransmission of 200Ok */
if (!as_uas && (is_retransmition=(belle_sip_dialog_handle_200Ok(obj,resp)==0))) {
obj->last_transaction=previous_transaction;
ret = 1;
goto end;
} else {
if (as_uas)
belle_sip_dialog_init_200Ok_retrans(obj,resp);
obj->needs_ack=TRUE; /*REINVITE case, ack needed by both uas and uac*/
}
}else if (code>=300){
/*final response, ack will be automatically sent by transaction layer*/
/* do not need to do anything because not set yet or set by previous invite transaction obj->needs_ack=FALSE;*/
}
} else if (strcmp(belle_sip_request_get_method(req),"BYE")==0){
/*15.1.1 UAC Behavior
A BYE request is constructed as would any other request within a
dialog, as described in Section 12.
Once the BYE is constructed, the UAC core creates a new non-INVITE
client transaction, and passes it the BYE request. The UAC MUST
consider the session terminated (and therefore stop sending or
listening for media) as soon as the BYE request is passed to the
client transaction. If the response for the BYE is a 481
(Call/Transaction Does Not Exist) or a 408 (Request Timeout) or no
response at all is received for the BYE (that is, a timeout is
returned by the client transaction), the UAC MUST consider the
session and the dialog terminated. */
/*what should we do with other reponse >300 ?? */
if (code>=200 || (code==0 && belle_sip_transaction_get_state(transaction)==BELLE_SIP_TRANSACTION_TERMINATED)){
obj->needs_ack=FALSE; /*no longuer need ACK*/
if (obj->terminate_on_bye) delete_dialog=TRUE;
}else if (!as_uas && code == 0){
/* A client BYE transaction is being started */
if (previous_transaction && belle_sip_transaction_get_state(previous_transaction) != BELLE_SIP_TRANSACTION_TERMINATED){
belle_sip_warning("Forcibly terminating previous transaction as BYE is being sent.");
/* Detach the dialog from the transaction, so that the dialog does not get updated for nothing
* by the killed transaction. */
belle_sip_transaction_set_dialog(previous_transaction, NULL);
belle_sip_transaction_terminate(previous_transaction);
}
}
}else if (is_subscribe){
if (belle_sip_dialog_schedule_expiration(obj, (belle_sip_message_t*)req) == BELLE_SIP_STOP
&& (code>=200 || (code==0 && belle_sip_transaction_get_state(transaction)==BELLE_SIP_TRANSACTION_TERMINATED))){
delete_dialog = TRUE;
}else if (!as_uas){
if (code >= 300 || (code==0 && belle_sip_transaction_get_state(transaction)==BELLE_SIP_TRANSACTION_TERMINATED)){
/*case of a SUBSCRIBE refresh that is rejected or unanswered*/
if (code != 491){
/*request pending is not fatal for the dialog*/
delete_dialog = TRUE;
}
}
}
}else if (is_notify){
delete_dialog = belle_sip_dialog_should_terminate_by_notify(obj, transaction, as_uas);
}
break;
case BELLE_SIP_DIALOG_TERMINATED:
/*ignore*/
break;
}
end:
if (!do_not_update_last_transaction) {
if (obj->last_transaction && (obj->last_transaction == transaction)) {
if (previous_transaction) belle_sip_object_unref(previous_transaction);
} else {
if (transaction) belle_sip_object_unref(transaction);
}
}
if (delete_dialog) belle_sip_dialog_delete(obj);
else {
belle_sip_dialog_process_queue(obj);
}
return ret;
}
belle_sip_dialog_t *belle_sip_dialog_new(belle_sip_transaction_t *t){
belle_sip_dialog_t *obj;
belle_sip_header_from_t *from;
const char *from_tag;
belle_sip_header_to_t *to;
const char *to_tag=NULL;
belle_sip_header_call_id_t *call_id=belle_sip_message_get_header_by_type(t->request,belle_sip_header_call_id_t);
belle_sip_dialog_type_t type;
from=belle_sip_message_get_header_by_type(t->request,belle_sip_header_from_t);
if (from==NULL){
belle_sip_error("belle_sip_dialog_new(): no from!");
return NULL;
}
from_tag=belle_sip_header_from_get_tag(from);
if (from_tag==NULL){
belle_sip_error("belle_sip_dialog_new(): no from tag!");
return NULL;
}
to = belle_sip_message_get_header_by_type(t->request,belle_sip_header_to_t);
if (to == NULL){
belle_sip_error("belle_sip_dialog_new(): no to in request!");
return NULL;
}
to_tag = belle_sip_header_to_get_tag(to);
if (to_tag){
belle_sip_error("belle_sip_dialog_new(): there is a to tag in the request. This is not allowed"
" to create a dialog on such a transaction.");
return NULL;
}
if (!call_id){
belle_sip_error("No call-id in response.");
return NULL;
}
if (t->last_response) {
to=belle_sip_message_get_header_by_type(t->last_response,belle_sip_header_to_t);
if (to==NULL){
belle_sip_error("belle_sip_dialog_new(): no to!");
return NULL;
}
to_tag = belle_sip_header_to_get_tag(to);
}
if (strcmp(belle_sip_request_get_method(t->request),"INVITE") == 0){
type = BELLE_SIP_DIALOG_INVITE;
}else if (strcmp(belle_sip_request_get_method(t->request),"SUBSCRIBE") == 0){
type = BELLE_SIP_DIALOG_SUBSCRIBE_NOTIFY;
}else{
belle_sip_error("belle_sip_dialog_new(): unsupported request [%s] for creating a dialog.", belle_sip_request_get_method(t->request));
return NULL;
}
if (type == BELLE_SIP_DIALOG_SUBSCRIBE_NOTIFY) {
belle_sip_header_expires_t *expires = belle_sip_message_get_header_by_type(t->request,belle_sip_header_expires_t);
if (expires && belle_sip_header_expires_get_expires(expires) < 1) {
belle_sip_error("belle_sip_dialog_new(): cannot create SUBSCRIBE/NOTIFY dialog with expiration <1 for transaction [%p]",t);
return NULL;
}
}
obj=belle_sip_object_new(belle_sip_dialog_t);
obj->terminate_on_bye=1;
obj->provider=t->provider;
obj->pending_trans_checking_enabled=1;
obj->call_id=(belle_sip_header_call_id_t*)belle_sip_object_ref(call_id);
obj->type=type;
obj->termination_cause=BELLE_SIP_DIALOG_TERMINATION_CAUSE_NORMAL;
belle_sip_object_ref(t);
obj->last_transaction=t;
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(t,belle_sip_server_transaction_t)){
obj->remote_tag=belle_sip_strdup(from_tag);
obj->local_tag=belle_sip_strdup(BELLE_SIP_SERVER_TRANSACTION(t)->to_tag);
obj->remote_party=(belle_sip_header_address_t*)belle_sip_object_ref(from);
obj->is_server=TRUE;
belle_sip_dialog_init_as_uas(obj,belle_sip_transaction_get_request(t));
}else{
const belle_sip_list_t *predefined_routes=NULL;
obj->local_tag=belle_sip_strdup(from_tag);
obj->remote_tag=to_tag?belle_sip_strdup(to_tag):NULL; /*might be null at dialog creation*/
obj->local_party=(belle_sip_header_address_t*)belle_sip_object_ref(from);
obj->is_server=FALSE;
for(predefined_routes=belle_sip_message_get_headers((belle_sip_message_t*)t->request,BELLE_SIP_ROUTE);
predefined_routes!=NULL;predefined_routes=predefined_routes->next){
obj->route_set=belle_sip_list_append(obj->route_set,belle_sip_object_ref(predefined_routes->data));
}
belle_sip_dialog_init_as_uac(obj,belle_sip_transaction_get_request(t));
}
belle_sip_message("New %s dialog [%p] , local tag [%s], remote tag [%s]"
,obj->is_server?"server":"client"
,obj
,obj->local_tag?obj->local_tag:""
,obj->remote_tag?obj->remote_tag:"");
set_state(obj,BELLE_SIP_DIALOG_NULL);
return obj;
}
belle_sip_request_t *belle_sip_dialog_create_ack(belle_sip_dialog_t *obj, unsigned int cseq){
belle_sip_request_t *invite=obj->last_out_invite;
belle_sip_request_t *ack;
belle_sip_header_cseq_t* cseqh;
if (!invite){
belle_sip_error("No INVITE to ACK.");
return NULL;
}
cseqh=belle_sip_message_get_header_by_type(invite,belle_sip_header_cseq_t);
if (belle_sip_header_cseq_get_seq_number(cseqh)!=cseq){
belle_sip_error("No INVITE with cseq %i to create ack for.",cseq);
return NULL;
}
ack=create_request(obj,"ACK",TRUE);
belle_sip_message_set_header(BELLE_SIP_MESSAGE(ack), BELLE_SIP_HEADER(belle_sip_header_cseq_create(cseq, "ACK")));
/*
22 Usage of HTTP Authentication
22.1 Framework
While a server can legitimately challenge most SIP requests, there
are two requests defined by this document that require special
handling for authentication: ACK and CANCEL.
Under an authentication scheme that uses responses to carry values
used to compute nonces (such as Digest), some problems come up for
any requests that take no response, including ACK. For this reason,
any credentials in the INVITE that were accepted by a server MUST be
accepted by that server for the ACK. UACs creating an ACK message
will duplicate all of the Authorization and Proxy-Authorization
header field values that appeared in the INVITE to which the ACK
corresponds. Servers MUST NOT attempt to challenge an ACK.
*/
if (ack){
const belle_sip_list_t *aut=belle_sip_message_get_headers((belle_sip_message_t*)obj->last_out_invite,"Authorization");
const belle_sip_list_t *prx_aut=belle_sip_message_get_headers((belle_sip_message_t*)obj->last_out_invite,"Proxy-Authorization");
if (aut)
belle_sip_message_add_headers((belle_sip_message_t*)ack,aut);
if (prx_aut)
belle_sip_message_add_headers((belle_sip_message_t*)ack,prx_aut);
/*the ack is sent statelessly, the transaction layer doesn't need the dialog information*/
belle_sip_request_set_dialog(ack,NULL);
}
return ack;
}
static belle_sip_request_t *create_request(belle_sip_dialog_t *obj, const char *method, int full){
belle_sip_request_t *req;
char* from_tag=NULL, *to_tag=NULL;
if (!obj->remote_target){
belle_sip_error("dialog [%p]: no remote_target set, unable to create request.", obj);
return NULL;
}
if (!belle_sip_parameters_has_parameter(BELLE_SIP_PARAMETERS(obj->local_party), "tag")) {
/*special case for dialog created by server transaction*/
from_tag = obj->local_tag;
}
if (!belle_sip_parameters_has_parameter(BELLE_SIP_PARAMETERS(obj->remote_party), "tag")) {
/*special case for dialog created by server transaction*/
to_tag = obj->remote_tag;
}
req=belle_sip_request_create(belle_sip_header_address_get_uri(obj->remote_target),
method,
obj->call_id,
belle_sip_header_cseq_create(obj->local_cseq,method),
belle_sip_header_from_create(obj->local_party,from_tag),
belle_sip_header_to_create(obj->remote_party,to_tag),
belle_sip_header_via_new(),
0);
if (full && obj->route_set) {
belle_sip_message_add_headers((belle_sip_message_t*)req,obj->route_set);
}
if (obj->privacy) {
/*repeat the last privacy set in new request. I could not find any requirement for this, but this might be safer
* as proxies don't store information about dialogs*/
belle_sip_message_add_header((belle_sip_message_t*)req,BELLE_SIP_HEADER(obj->privacy));
}
belle_sip_request_set_dialog(req,obj);
return req;
}
static int dialog_can_create_request(belle_sip_dialog_t *obj, const char *method){
if (obj->state != BELLE_SIP_DIALOG_CONFIRMED && obj->state != BELLE_SIP_DIALOG_EARLY
&& (strcmp("NOTIFY", method) != 0
|| !obj->is_server
|| !obj->last_transaction
|| strcmp("SUBSCRIBE", belle_sip_transaction_get_method(obj->last_transaction)) !=0)) {
belle_sip_error("belle_sip_dialog_create_request(): cannot create [%s] request from dialog [%p] in state [%s]",method,obj,belle_sip_dialog_state_to_string(obj->state));
return FALSE;
}
return TRUE;
}
bool_t belle_sip_dialog_can_create_asynchronous_request(belle_sip_dialog_t *obj, const char *method){
if (!dialog_can_create_request(obj, method)) return FALSE;
if (strcmp(method,"INVITE")==0 || strcmp(method,"SUBSCRIBE")==0){
/*we don't allow requests that can update the dialog's state to be sent asynchronously*/
belle_sip_error("%s([%p]): [%s] requests are forbidden using this method.",__func__,obj,method);
return FALSE;
}
return TRUE;
}
belle_sip_request_t * belle_sip_dialog_create_queued_request(belle_sip_dialog_t *obj, const char *method){
belle_sip_request_t *req;
if (!belle_sip_dialog_can_create_asynchronous_request(obj, method)) return NULL;
req=create_request(obj,method,FALSE);
if (req){
req->dialog_queued=TRUE;
}
return req;
}
bool_t belle_sip_dialog_can_create_synchronous_request(belle_sip_dialog_t *obj, const char *method){
if (!dialog_can_create_request(obj, method)) return FALSE;
/*don't prevent to send a BYE in any case */
if (obj->pending_trans_checking_enabled
&& strcmp(method,"BYE")!=0
&& obj->last_transaction
&& belle_sip_transaction_state_is_transient(belle_sip_transaction_get_state(obj->last_transaction))){
if (obj->state != BELLE_SIP_DIALOG_EARLY && strcmp(method,"UPDATE")!=0 && strcmp(method,"NOTIFY")!=0) {
belle_sip_error("%s(): cannot create [%s] request from dialog [%p] while pending [%s] transaction in state [%s]",__func__,method,obj,belle_sip_transaction_get_method(obj->last_transaction), belle_sip_transaction_state_to_string(belle_sip_transaction_get_state(obj->last_transaction)));
return FALSE;
} /*else UPDATE transaction can be sent in // */
}
return TRUE;
}
belle_sip_request_t *belle_sip_dialog_create_request(belle_sip_dialog_t *obj, const char *method){
belle_sip_request_t *req;
if (!belle_sip_dialog_can_create_synchronous_request(obj, method)) return NULL;
belle_sip_dialog_update_local_cseq(obj,method);
req=create_request(obj,method,TRUE);
return req;
}
static unsigned int is_system_header(belle_sip_header_t* header) {
const char* name=belle_sip_header_get_name(header);
return strcasecmp(BELLE_SIP_VIA,name) ==0
|| strcasecmp(BELLE_SIP_FROM,name) ==0
|| strcasecmp(BELLE_SIP_TO,name) ==0
|| strcasecmp(BELLE_SIP_CSEQ,name) ==0
|| strcasecmp(BELLE_SIP_CALL_ID,name) ==0
|| strcasecmp(BELLE_SIP_PROXY_AUTHORIZATION,name) == 0
|| strcasecmp(BELLE_SIP_AUTHORIZATION,name) == 0
|| strcasecmp(BELLE_SIP_MAX_FORWARDS,name) == 0
|| strcasecmp(BELLE_SIP_ALLOW,name) ==0
|| strcasecmp(BELLE_SIP_ROUTE,name) ==0;
}
static void copy_non_system_headers(belle_sip_header_t* header,belle_sip_request_t* req ) {
if (!is_system_header(header)) {
belle_sip_message_add_header(BELLE_SIP_MESSAGE(req),header);
}
}
static belle_sip_request_t *_belle_sip_dialog_create_request_from(belle_sip_dialog_t *obj, const belle_sip_request_t *initial_req, int queued){
belle_sip_request_t* req;
const char *method=belle_sip_request_get_method(initial_req);
belle_sip_list_t* headers;
if (queued) req=belle_sip_dialog_create_queued_request(obj,method);
else req=belle_sip_dialog_create_request(obj,method);
if (req==NULL) return NULL;
/*first copy non system headers*/
headers = belle_sip_message_get_all_headers(BELLE_SIP_MESSAGE(initial_req));
belle_sip_list_for_each2(headers,(void (*)(void *, void *))copy_non_system_headers,req);
belle_sip_list_free(headers);
/*replicate via user parameters, if any, useful for 'alias' parameter in SUBSCRIBE requests*/
{
belle_sip_header_via_t *orig_via=belle_sip_message_get_header_by_type(BELLE_SIP_MESSAGE(initial_req),belle_sip_header_via_t);
belle_sip_header_via_t *new_via=belle_sip_message_get_header_by_type(BELLE_SIP_MESSAGE(req),belle_sip_header_via_t);
belle_sip_parameters_copy_parameters_from(BELLE_SIP_PARAMETERS(new_via),BELLE_SIP_PARAMETERS(orig_via));
}
/*copy body handler to save content enconding processing (I.E deflat)*/
if (belle_sip_message_get_body_handler(BELLE_SIP_MESSAGE(initial_req))) {
belle_sip_message_set_body_handler(BELLE_SIP_MESSAGE(req),belle_sip_message_get_body_handler(BELLE_SIP_MESSAGE(initial_req)));
}
return req;
}
belle_sip_request_t *belle_sip_dialog_create_request_from(belle_sip_dialog_t *obj, const belle_sip_request_t *initial_req){
return _belle_sip_dialog_create_request_from(obj,initial_req,FALSE);
}
belle_sip_request_t *belle_sip_dialog_create_queued_request_from(belle_sip_dialog_t *obj, const belle_sip_request_t *initial_req){
return _belle_sip_dialog_create_request_from(obj,initial_req,TRUE);
}
void belle_sip_dialog_delete(belle_sip_dialog_t *obj){
size_t dropped_transactions;
if (obj->expiration_timer){
belle_sip_main_loop_remove_source(obj->provider->stack->ml, obj->expiration_timer);
belle_sip_object_unref(obj->expiration_timer);
obj->expiration_timer = NULL;
}
belle_sip_message("Dialog [%p] deleted (is_expired=%i)",obj, obj->is_expired);
belle_sip_dialog_stop_200Ok_retrans(obj); /*if any*/
set_state(obj,BELLE_SIP_DIALOG_TERMINATED);
dropped_transactions=belle_sip_list_size(obj->queued_ct);
if (dropped_transactions>0) belle_sip_warning("dialog [%p]: leaves %u queued transaction aborted.",obj,(unsigned int)dropped_transactions);
belle_sip_list_for_each(obj->queued_ct,(void(*)(void*))belle_sip_transaction_terminate);
obj->queued_ct=belle_sip_list_free_with_data(obj->queued_ct,belle_sip_object_unref);
belle_sip_provider_remove_dialog(obj->provider,obj);
}
void *belle_sip_dialog_get_application_data(const belle_sip_dialog_t *dialog){
return dialog->appdata;
}
void belle_sip_dialog_set_application_data(belle_sip_dialog_t *dialog, void *data){
dialog->appdata=data;
}
const belle_sip_header_call_id_t *belle_sip_dialog_get_call_id(const belle_sip_dialog_t *dialog){
return dialog->call_id;
}
const belle_sip_header_address_t *belle_sip_dialog_get_local_party(const belle_sip_dialog_t *dialog){
return dialog->local_party;
}
const belle_sip_header_address_t *belle_sip_dialog_get_remote_party(const belle_sip_dialog_t *dialog){
return dialog->remote_party;
}
unsigned int belle_sip_dialog_get_local_seq_number(const belle_sip_dialog_t *dialog){
return dialog->local_cseq;
}
unsigned int belle_sip_dialog_get_remote_seq_number(const belle_sip_dialog_t *dialog){
return dialog->remote_cseq;
}
const char *belle_sip_dialog_get_local_tag(const belle_sip_dialog_t *dialog){
return dialog->local_tag;
}
const char *belle_sip_dialog_get_remote_tag(const belle_sip_dialog_t *dialog){
return dialog->remote_tag;
}
const belle_sip_header_address_t *belle_sip_dialog_get_remote_target(belle_sip_dialog_t *dialog){
return dialog->remote_target;
}
const belle_sip_list_t* belle_sip_dialog_get_route_set(belle_sip_dialog_t *dialog){
return dialog->route_set;
}
belle_sip_dialog_state_t belle_sip_dialog_get_state(const belle_sip_dialog_t *dialog){
return dialog->state;
}
belle_sip_dialog_state_t belle_sip_dialog_get_previous_state(const belle_sip_dialog_t *dialog) {
return dialog->previous_state;
}
int belle_sip_dialog_is_server(const belle_sip_dialog_t *dialog){
return dialog->is_server;
}
int belle_sip_dialog_is_secure(const belle_sip_dialog_t *dialog){
return dialog->is_secure;
}
void belle_sip_dialog_send_ack(belle_sip_dialog_t *obj, belle_sip_request_t *request){
if (obj->needs_ack){
obj->needs_ack=FALSE;
if (obj->last_out_ack)
belle_sip_object_unref(obj->last_out_ack);
obj->last_out_ack=(belle_sip_request_t*)belle_sip_object_ref(request);
belle_sip_provider_send_request(obj->provider,request);
belle_sip_dialog_process_queue(obj);
}else{
belle_sip_error("Why do you want to send an ACK ?");
}
}
void belle_sip_dialog_terminate_on_bye(belle_sip_dialog_t *obj, int val){
obj->terminate_on_bye=val;
}
/*returns 1 if message belongs to the dialog, 0 otherwise */
int belle_sip_dialog_match(belle_sip_dialog_t *obj, belle_sip_message_t *msg, int as_uas){
belle_sip_header_call_id_t *call_id=belle_sip_message_get_header_by_type(msg,belle_sip_header_call_id_t);
belle_sip_header_from_t *from=belle_sip_message_get_header_by_type(msg,belle_sip_header_from_t);
belle_sip_header_to_t *to=belle_sip_message_get_header_by_type(msg,belle_sip_header_to_t);
const char *from_tag;
const char *to_tag;
const char *call_id_value;
if (call_id==NULL || from==NULL || to==NULL) return 0;
call_id_value=belle_sip_header_call_id_get_call_id(call_id);
from_tag=belle_sip_header_from_get_tag(from);
to_tag=belle_sip_header_to_get_tag(to);
return _belle_sip_dialog_match(obj,call_id_value,as_uas ? to_tag : from_tag, as_uas ? from_tag : to_tag);
}
int _belle_sip_dialog_match(belle_sip_dialog_t *obj, const char *call_id, const char *local_tag, const char *remote_tag){
const char *dcid;
/*Dialog created by notify matching subscription are still in NULL state if (obj->state==BELLE_SIP_DIALOG_NULL) belle_sip_fatal("_belle_sip_dialog_match() must not be used for dialog in null state.");*/
dcid=belle_sip_header_call_id_get_call_id(obj->call_id);
return strcmp(dcid,call_id)==0
&& (!local_tag || strcmp(obj->local_tag,local_tag)==0) //local tag is not checked if not provided
&& obj->remote_tag /* handle 180 without to tag */ && remote_tag && strcmp(obj->remote_tag,remote_tag)==0;
}
void belle_sip_dialog_check_ack_sent(belle_sip_dialog_t*obj){
belle_sip_client_transaction_t* client_trans;
if (obj->needs_ack){
belle_sip_request_t *req;
belle_sip_error("Your listener did not ACK'd the 200Ok for your INVITE request. The dialog will be terminated.");
req=belle_sip_dialog_create_request(obj,"BYE");
if (req){
belle_sip_header_reason_t *reason=belle_sip_header_reason_new();
belle_sip_header_reason_set_protocol(reason,"SIP");
belle_sip_header_reason_set_cause(reason,500);
belle_sip_header_reason_set_text(reason,"Internal Error");
belle_sip_message_add_header(BELLE_SIP_MESSAGE(req), BELLE_SIP_HEADER(reason));
client_trans=belle_sip_provider_create_client_transaction(obj->provider,req);
BELLE_SIP_TRANSACTION(client_trans)->is_internal=TRUE; /*internal transaction, don't bother user with 200ok*/
belle_sip_client_transaction_send_request(client_trans);
/*call dialog terminated*/
}else{
/*If there is no way to signal the failure to the other party, then force immediate dialog deletion*/
belle_sip_dialog_delete(obj);
}
}
}
/*
* return 0 if dialog handle the 200ok
* */
static int belle_sip_dialog_handle_200Ok(belle_sip_dialog_t *obj, belle_sip_response_t *msg){
if (obj->last_out_ack){
belle_sip_header_cseq_t *cseq=belle_sip_message_get_header_by_type(msg,belle_sip_header_cseq_t);
if (cseq){
belle_sip_header_cseq_t *ack_cseq=belle_sip_message_get_header_by_type(obj->last_out_ack,belle_sip_header_cseq_t);
if (belle_sip_header_cseq_get_seq_number(cseq)==belle_sip_header_cseq_get_seq_number(ack_cseq)){
/*pass for retransmission*/
belle_sip_message("Dialog retransmitting last ack automatically");
belle_sip_provider_send_request(obj->provider,obj->last_out_ack);
return 0;
}else belle_sip_message("No already created ACK matching 200Ok for dialog [%p]",obj);
}
}
return -1;
}
int belle_sip_dialog_handle_ack(belle_sip_dialog_t *obj, belle_sip_request_t *ack){
if (obj->simulate_lost_ack) {
belle_sip_message("Simulating lost ACK for dialog %p", obj);
return -1;
}
belle_sip_header_cseq_t *cseq=belle_sip_message_get_header_by_type(ack,belle_sip_header_cseq_t);
if (obj->needs_ack && belle_sip_header_cseq_get_seq_number(cseq)==obj->remote_invite_cseq){
belle_sip_message("Incoming INVITE has ACK, dialog is happy");
obj->needs_ack=FALSE;
belle_sip_dialog_stop_200Ok_retrans(obj);
belle_sip_dialog_process_queue(obj);
return 0;
}
belle_sip_message("Dialog ignoring incoming ACK (surely a retransmission) to dialog %p with CSeq %0d", obj, belle_sip_header_cseq_get_seq_number(cseq));
return -1;
}
belle_sip_transaction_t* belle_sip_dialog_get_last_transaction(const belle_sip_dialog_t *dialog) {
return dialog->last_transaction;
}
int belle_sip_dialog_request_pending(const belle_sip_dialog_t *dialog){
return dialog->needs_ack || (dialog->last_transaction ? belle_sip_transaction_state_is_transient(belle_sip_transaction_get_state(dialog->last_transaction)) : FALSE);
}
int belle_sip_dialog_get_request_retry_timeout(const belle_sip_dialog_t *dialog){
/* According to RFC3261 - 14.1 */
if (!dialog->is_server){
return 2100 + 10 * (((belle_sip_random() % (4000 - 2100))) / 10 );
}else{
return 10 * ((belle_sip_random() % 2000) / 10 );
}
}
/* for notify exception
As per RFC 3265;
3.3.4. Dialog creation and termination
If an initial SUBSCRIBE request is not sent on a pre-existing dialog,
the subscriber will wait for a response to the SUBSCRIBE request or a
matching NOTIFY.
...
...
If an initial SUBSCRIBE is sent on a pre-existing dialog, a matching
200-class response or successful NOTIFY request merely creates a new
subscription associated with that dialog.
*/
int belle_sip_dialog_can_accept_request(const belle_sip_dialog_t *dialog, belle_sip_request_t *req) {
const char *method = belle_sip_request_get_method(req);
if (belle_sip_dialog_request_pending(dialog)){
const char* last_transaction_request;
if (strcasecmp(method,"BYE")==0)
return TRUE; /*don't reject a BYE*/
last_transaction_request = belle_sip_request_get_method(belle_sip_transaction_get_request(dialog->last_transaction));
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(dialog->last_transaction,belle_sip_client_transaction_t)){
if (strcmp(last_transaction_request,"SUBSCRIBE")==0 && strcmp(method,"NOTIFY")==0){
/*stupid as it may sound, you have to accept a NOTIFY for a SUBSCRIBE for which no answer is received yet.*/
return TRUE;
}else if (strcmp(last_transaction_request, "NOTIFY") == 0 && strcmp(method, "SUBSCRIBE") == 0){
belle_sip_header_expires_t *expire = belle_sip_message_get_header_by_type((belle_sip_message_t*)req, belle_sip_header_expires_t);
if (expire && belle_sip_header_expires_get_expires(expire) == 0){
/* Accept to receive an unSUBSCRIBE even if we have an outgoing pending NOTIFY */
return TRUE;
}
}
}
if (strcmp(last_transaction_request,"INVITE")==0 && (strcmp(method,"PRACK")==0 || strcmp(method,"UPDATE")==0)){
/*PRACK /UPDATE needs to be sent or received during reINVITEs.*/
return TRUE;
}
return FALSE;
} else {
return TRUE;
}
}
void belle_sip_dialog_queue_client_transaction(belle_sip_dialog_t *dialog, belle_sip_client_transaction_t *tr){
dialog->queued_ct=belle_sip_list_append(dialog->queued_ct, belle_sip_object_ref(tr));
}
static void _belle_sip_dialog_process_queue(belle_sip_dialog_t* dialog){
belle_sip_client_transaction_t *tr=NULL;
if (dialog->state==BELLE_SIP_DIALOG_TERMINATED || belle_sip_dialog_request_pending(dialog)) goto end;
dialog->queued_ct=belle_sip_list_pop_front(dialog->queued_ct,(void**)&tr);
if (tr){
belle_sip_message("Dialog [%p]: sending queued request [%p].",dialog,tr);
tr->base.sent_by_dialog_queue=TRUE;
belle_sip_client_transaction_send_request(tr);
belle_sip_object_unref(tr);
}
end:
belle_sip_object_unref(dialog);
}
void belle_sip_dialog_process_queue(belle_sip_dialog_t* dialog){
/*process queue does not process synchronously.
* This is to let the application handle responses and eventually submit new requests without being blocked.
* Typically when a reINVITE is challenged, we want a chance to re-submit an authenticated request before processing
* queued requests*/
if (dialog->queued_ct){
belle_sip_main_loop_do_later(dialog->provider->stack->ml,(belle_sip_callback_t)_belle_sip_dialog_process_queue,belle_sip_object_ref(dialog));
}
}
void belle_sip_dialog_update_request(belle_sip_dialog_t *dialog, belle_sip_request_t *req){
belle_sip_header_cseq_t *cseq=belle_sip_message_get_header_by_type(req,belle_sip_header_cseq_t);
belle_sip_dialog_update_local_cseq(dialog,belle_sip_request_get_method(req));
if (dialog->route_set)
belle_sip_message_add_headers((belle_sip_message_t*)req,dialog->route_set);
belle_sip_request_set_uri(req,belle_sip_header_address_get_uri(dialog->remote_target));
belle_sip_header_cseq_set_seq_number(cseq,dialog->local_cseq);
}
int belle_sip_dialog_pending_trans_checking_enabled( const belle_sip_dialog_t *dialog) {
return dialog->pending_trans_checking_enabled;
}
int belle_sip_dialog_enable_pending_trans_checking(belle_sip_dialog_t *dialog, int value) {
dialog->pending_trans_checking_enabled = value;
return 0;
}
belle_sip_dialog_termination_cause_t belle_sip_dialog_get_termination_cause(const belle_sip_dialog_t *dialog) {
return dialog->termination_cause;
}
void belle_sip_dialog_set_simulate_lost_ack_enabled(belle_sip_dialog_t *dialog, int enable) {
dialog->simulate_lost_ack = (unsigned char) enable;
}
belle-sip-5.2.0+dfsg/src/dns/ 0000775 0000000 0000000 00000000000 14346131365 0015672 5 ustar 00root root 0000000 0000000 belle-sip-5.2.0+dfsg/src/dns/dns.c 0000664 0000000 0000000 00000707231 14346131365 0016634 0 ustar 00root root 0000000 0000000 /* ==========================================================================
* dns.c - Recursive, Reentrant DNS Resolver.
* --------------------------------------------------------------------------
* Copyright (c) 2008, 2009, 2010, 2012-2016 William Ahern
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to permit
* persons to whom the Software is furnished to do so, subject to the
* following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
* NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
* ==========================================================================
*/
#if !defined(__FreeBSD__) && !defined(__sun)
#ifndef _XOPEN_SOURCE
#define _XOPEN_SOURCE 600
#endif
#undef _DEFAULT_SOURCE
#define _DEFAULT_SOURCE
#undef _BSD_SOURCE
#define _BSD_SOURCE
#undef _DARWIN_C_SOURCE
#define _DARWIN_C_SOURCE
#undef _NETBSD_SOURCE
#define _NETBSD_SOURCE
#endif
#ifdef _MSC_VER
#define DNS_INLINE __inline
#else
#define DNS_INLINE inline
#endif
#include /* INT_MAX */
#include /* offsetof() */
/*#ifdef _WIN32
#define uint16_t unsigned short
#define uint32_t unsigned int
#else*/
#include /* uint32_t */
//#endif
#include /* malloc(3) realloc(3) free(3) rand(3) random(3) arc4random(3) */
#include /* FILE fopen(3) fclose(3) getc(3) rewind(3) */
#include /* memcpy(3) strlen(3) memmove(3) memchr(3) memcmp(3) strchr(3) strsep(3) strcspn(3) */
#ifndef _WIN32
#include /* strcasecmp(3) strncasecmp(3) */
#endif
#include /* isspace(3) isdigit(3) */
#include /* time_t time(2) difftime(3) */
#include /* SIGPIPE sigemptyset(3) sigaddset(3) sigpending(2) sigprocmask(2) pthread_sigmask(3) sigtimedwait(2) */
#include /* errno EINVAL ENOENT */
#undef NDEBUG
#include /* assert(3) */
#if _WIN32
#ifndef FD_SETSIZE
#define FD_SETSIZE 2048
#endif
#include
#include
#ifndef USE_FIXED_NAMESERVERS
#include
#pragma comment(lib, "IPHLPAPI.lib")
#endif
#if defined(__MINGW32__) || !defined(WINAPI_FAMILY_PARTITION) || !defined(WINAPI_PARTITION_DESKTOP)
#define BELLE_SIP_WINDOWS_DESKTOP 1
#elif defined(WINAPI_FAMILY_PARTITION)
#if defined(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
#define BELLE_SIP_WINDOWS_DESKTOP 1
#elif defined(WINAPI_PARTITION_PHONE_APP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
#define BELLE_SIP_WINDOWS_PHONE 1
#elif defined(WINAPI_PARTITION_APP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
#define BELLE_SIP_WINDOWS_UNIVERSAL 1
#endif
#endif
#else
#include /* FD_SETSIZE socklen_t */
#include /* FD_ZERO FD_SET fd_set select(2) */
#include /* AF_INET AF_INET6 AF_UNIX struct sockaddr struct sockaddr_in struct sockaddr_in6 socket(2) */
#if defined(AF_UNIX)
#include /* struct sockaddr_un */
#endif
#include /* F_SETFD F_GETFL F_SETFL O_NONBLOCK fcntl(2) */
#include /* _POSIX_THREADS gethostname(3) close(2) */
#include /* POLLIN POLLOUT */
#include /* struct sockaddr_in struct sockaddr_in6 */
#include /* inet_pton(3) inet_ntop(3) htons(3) ntohs(3) */
#include /* struct addrinfo */
#endif
#include "dns.h"
#if defined(HAVE_RESINIT) || defined(USE_STRUCT_RES_STATE_NAMESERVERS)
#include
#endif
#if defined(HAVE_RESINIT)
#include
#include
#endif
#ifdef __ANDROID__
#include
#endif
#include
#include
#include
/*
* C O M P I L E R V E R S I O N & F E A T U R E D E T E C T I O N
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define DNS_GNUC_2VER(M, m, p) (((M) * 10000) + ((m) * 100) + (p))
#define DNS_GNUC_PREREQ(M, m, p) (__GNUC__ > 0 && DNS_GNUC_2VER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) >= DNS_GNUC_2VER((M), (m), (p)))
#define DNS_MSC_2VER(M, m, p) ((((M) + 6) * 10000000) + ((m) * 1000000) + (p))
#define DNS_MSC_PREREQ(M, m, p) (_MSC_VER_FULL > 0 && _MSC_VER_FULL >= DNS_MSC_2VER((M), (m), (p)))
#define DNS_SUNPRO_PREREQ(M, m, p) (__SUNPRO_C > 0 && __SUNPRO_C >= 0x ## M ## m ## p)
#if defined __has_builtin
#define dns_has_builtin(x) __has_builtin(x)
#else
#define dns_has_builtin(x) 0
#endif
#if defined __has_extension
#define dns_has_extension(x) __has_extension(x)
#else
#define dns_has_extension(x) 0
#endif
#ifndef HAVE___ASSUME
#define HAVE___ASSUME DNS_MSC_PREREQ(8,0,0)
#endif
#ifndef HAVE___BUILTIN_TYPES_COMPATIBLE_P
#define HAVE___BUILTIN_TYPES_COMPATIBLE_P (DNS_GNUC_PREREQ(3,1,1) || __clang__)
#endif
#ifndef HAVE___BUILTIN_UNREACHABLE
#define HAVE___BUILTIN_UNREACHABLE (DNS_GNUC_PREREQ(4,5,0) || dns_has_builtin(__builtin_unreachable))
#endif
#ifndef HAVE_PRAGMA_MESSAGE
#define HAVE_PRAGMA_MESSAGE (DNS_GNUC_PREREQ(4,4,0) || __clang__ || _MSC_VER)
#endif
/*
* C O M P I L E R A N N O T A T I O N S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#if __GNUC__
#define DNS_NOTUSED __attribute__((unused))
#define DNS_NORETURN __attribute__((noreturn))
#else
#define DNS_NOTUSED
#define DNS_NORETURN
#endif
#if __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
#elif DNS_GNUC_PREREQ(4,6,0)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#endif
/*
* S T A N D A R D M A C R O S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#if HAVE___BUILTIN_TYPES_COMPATIBLE_P
#define dns_same_type(a, b, def) __builtin_types_compatible_p(typeof (a), typeof (b))
#else
#define dns_same_type(a, b, def) (def)
#endif
#define dns_isarray(a) (!dns_same_type((a), (&(a)[0]), 0))
#define dns_inline_assert(cond) ((void)(sizeof (struct { int:-!(cond); })))
#if HAVE___ASSUME
#define dns_assume(cond) __assume(cond)
#elif HAVE___BUILTIN_UNREACHABLE
#define dns_assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)
#else
#define dns_assume(cond) do { (void)(cond); } while (0)
#endif
#ifndef lengthof
#define lengthof(a) (dns_inline_assert(dns_isarray(a)), (sizeof (a) / sizeof (a)[0]))
#endif
#ifndef endof
#define endof(a) (dns_inline_assert(dns_isarray(a)), &(a)[lengthof((a))])
#endif
/*
* M I S C E L L A N E O U S C O M P A T
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#if _WIN32 || _WIN64
#define PRIuZ "Iu"
#else
#define PRIuZ "zu"
#endif
#ifndef DNS_THREAD_SAFE
#if (defined _REENTRANT || defined _THREAD_SAFE) && _POSIX_THREADS > 0
#define DNS_THREAD_SAFE 1
#else
#define DNS_THREAD_SAFE 0
#endif
#endif
#ifndef HAVE__STATIC_ASSERT
#define HAVE__STATIC_ASSERT \
(dns_has_extension(c_static_assert) || DNS_GNUC_PREREQ(4,6,0) || \
__C11FEATURES__ || __STDC_VERSION__ >= 201112L)
#endif
#ifndef HAVE_STATIC_ASSERT
#if DNS_GNUC_PREREQ(0,0,0) && !DNS_GNUC_PREREQ(4,6,0)
#define HAVE_STATIC_ASSERT 0 /* glibc doesn't check GCC version */
#else
#if (defined static_assert)
#define HAVE_STATIC_ASSERT 1
#endif
#endif
#endif
#if HAVE_STATIC_ASSERT
#define dns_static_assert(cond, msg) static_assert(cond, msg)
#elif HAVE__STATIC_ASSERT
#define dns_static_assert(cond, msg) _Static_assert(cond, msg)
#else
#define dns_static_assert(cond, msg) extern char DNS_PP_XPASTE(dns_assert_, __LINE__)[sizeof (int[1 - 2*!(cond)])]
#endif
/*
* D E B U G M A C R O S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int *dns_debug_p(void) {
static int debug;
return &debug;
} /* dns_debug_p() */
#if DNS_DEBUG
#define DNS_SAY_(fmt, ...) \
do { if (DNS_DEBUG > 0) fprintf(stderr, fmt "%.1s", __func__, __LINE__, __VA_ARGS__); } while (0)
#define DNS_SAY(...) DNS_SAY_("@@ (%s:%d) " __VA_ARGS__, "\n")
#define DNS_HAI DNS_SAY("HAI")
#define DNS_SHOW_(P, fmt, ...) do { \
if (DNS_DEBUG >= 1) { \
fprintf(stderr, "@@ BEGIN * * * * * * * * * * * *\n"); \
fprintf(stderr, "@@ " fmt "%.0s\n", __VA_ARGS__); \
dns_p_dump((P), stderr); \
fprintf(stderr, "@@ END * * * * * * * * * * * * *\n\n"); \
} \
} while (0)
#define DNS_SHOW(...) DNS_SHOW_(__VA_ARGS__, "")
#else /* !DNS_DEBUG */
#undef DNS_DEBUG
#define DNS_DEBUG 0
#define DNS_SAY(...)
#define DNS_HAI
#define DNS_SHOW(...)
#endif /* DNS_DEBUG */
#define DNS_CARP(...) DNS_SAY(__VA_ARGS__)
/*
* V E R S I O N R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
const char *dns_vendor(void) {
return DNS_VENDOR;
} /* dns_vendor() */
int dns_v_rel(void) {
return DNS_V_REL;
} /* dns_v_rel() */
int dns_v_abi(void) {
return DNS_V_ABI;
} /* dns_v_abi() */
int dns_v_api(void) {
return DNS_V_API;
} /* dns_v_api() */
/*
* E R R O R R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#if _WIN32
#define DNS_EINTR WSAEINTR
#define DNS_EINPROGRESS WSAEINPROGRESS
#define DNS_EISCONN WSAEISCONN
#define DNS_EWOULDBLOCK WSAEWOULDBLOCK
#define DNS_EALREADY WSAEALREADY
#define DNS_EAGAIN EAGAIN
#define DNS_ETIMEDOUT WSAETIMEDOUT
#define DNS_ECONNREFUSED WSAECONNREFUSED
#define DNS_ECONNRESET WSAECONNRESET
#define DNS_ENETUNREACH WSAENETUNREACH
#define DNS_EHOSTUNREACH WSAEHOSTUNREACH
#define dns_syerr() ((int)GetLastError())
#define dns_soerr() ((int)WSAGetLastError())
#else
#define DNS_EINTR EINTR
#define DNS_EINPROGRESS EINPROGRESS
#define DNS_EISCONN EISCONN
#define DNS_EWOULDBLOCK EWOULDBLOCK
#define DNS_EALREADY EALREADY
#define DNS_EAGAIN EAGAIN
#define DNS_ETIMEDOUT ETIMEDOUT
#define DNS_ECONNREFUSED ECONNREFUSED
#define DNS_ECONNRESET ECONNRESET
#define DNS_ENETUNREACH ENETUNREACH
#define DNS_EHOSTUNREACH EHOSTUNREACH
#define dns_syerr() errno
#define dns_soerr() errno
#endif
const char *dns_strerror(int error) {
switch (error) {
case DNS_ENOBUFS:
return "DNS packet buffer too small";
case DNS_EILLEGAL:
return "Illegal DNS RR name or data";
case DNS_EORDER:
return "Attempt to push RR out of section order";
case DNS_ESECTION:
return "Invalid section specified";
case DNS_EUNKNOWN:
return "Unknown DNS error";
case DNS_EADDRESS:
return "Invalid textual address form";
case DNS_ENOQUERY:
return "Bad execution state (missing query packet)";
case DNS_ENOANSWER:
return "Bad execution state (missing answer packet)";
case DNS_EFETCHED:
return "Answer already fetched";
case DNS_ESERVICE:
return "The service passed was not recognized for the specified socket type";
case DNS_ENONAME:
return "The name does not resolve for the supplied parameters";
case DNS_EFAIL:
return "A non-recoverable error occurred when attempting to resolve the name";
default:
return strerror(error);
} /* switch() */
} /* dns_strerror() */
/*
* A T O M I C R O U T I N E S
*
* Use GCC's __atomic built-ins if possible. Unlike the __sync built-ins, we
* can use the preprocessor to detect API and, more importantly, ISA
* support. We want to avoid linking headaches where the API depends on an
* external library if the ISA (e.g. i386) doesn't support lockless
* operation.
*
* TODO: Support C11's atomic API. Although that may require some finesse
* with how we define some public types, such as dns_atomic_t and struct
* dns_resolv_conf.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef HAVE___ATOMIC_FETCH_ADD
#if (defined __ATOMIC_RELAXED)
#define HAVE___ATOMIC_FETCH_ADD 1
#endif
#endif
#ifndef HAVE___ATOMIC_FETCH_SUB
#if (defined __ATOMIC_RELAXED)
#define HAVE___ATOMIC_FETCH_SUB 1
#endif
#endif
#ifndef DNS_ATOMIC_FETCH_ADD
#if HAVE___ATOMIC_FETCH_ADD && __GCC_ATOMIC_LONG_LOCK_FREE == 2
#define DNS_ATOMIC_FETCH_ADD(i) __atomic_fetch_add((i), 1, __ATOMIC_RELAXED)
#else
#pragma message("no atomic_fetch_add available")
#define DNS_ATOMIC_FETCH_ADD(i) ((*(i))++)
#endif
#endif
#ifndef DNS_ATOMIC_FETCH_SUB
#if HAVE___ATOMIC_FETCH_SUB && __GCC_ATOMIC_LONG_LOCK_FREE == 2
#define DNS_ATOMIC_FETCH_SUB(i) __atomic_fetch_sub((i), 1, __ATOMIC_RELAXED)
#else
#pragma message("no atomic_fetch_sub available")
#define DNS_ATOMIC_FETCH_SUB(i) ((*(i))--)
#endif
#endif
static DNS_INLINE unsigned dns_atomic_fetch_add(dns_atomic_t *i) {
return DNS_ATOMIC_FETCH_ADD(i);
} /* dns_atomic_fetch_add() */
static DNS_INLINE unsigned dns_atomic_fetch_sub(dns_atomic_t *i) {
return DNS_ATOMIC_FETCH_SUB(i);
} /* dns_atomic_fetch_sub() */
/*
* C R Y P T O R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*
* P R N G
*/
#ifndef DNS_RANDOM
#if defined(HAVE_ARC4RANDOM) \
|| defined(__OpenBSD__) \
|| defined(__FreeBSD__) \
|| defined(__NetBSD__) \
|| defined(__APPLE__)
#define DNS_RANDOM arc4random
#elif __linux__
#define DNS_RANDOM random
#else
#define DNS_RANDOM rand
#endif
#endif
#define DNS_RANDOM_arc4random 1
#define DNS_RANDOM_random 2
#define DNS_RANDOM_rand 3
#define DNS_RANDOM_RAND_bytes 4
#define DNS_RANDOM_OPENSSL (DNS_RANDOM_RAND_bytes == DNS_PP_XPASTE(DNS_RANDOM_, DNS_RANDOM))
#if DNS_RANDOM_OPENSSL
#include
#endif
static unsigned dns_random_(void) {
#if DNS_RANDOM_OPENSSL
unsigned r;
_Bool ok;
ok = (1 == RAND_bytes((unsigned char *)&r, sizeof r));
assert(ok && "1 == RAND_bytes()");
return r;
#else
return DNS_RANDOM();
#endif
} /* dns_random_() */
dns_random_f **dns_random_p(void) {
static dns_random_f *random_f = &dns_random_;
return &random_f;
} /* dns_random_p() */
/*
* P E R M U T A T I O N G E N E R A T O R
*/
#define DNS_K_TEA_KEY_SIZE 16
#define DNS_K_TEA_BLOCK_SIZE 8
#define DNS_K_TEA_CYCLES 32
#define DNS_K_TEA_MAGIC 0x9E3779B9U
struct dns_k_tea {
uint32_t key[DNS_K_TEA_KEY_SIZE / sizeof (uint32_t)];
unsigned cycles;
}; /* struct dns_k_tea */
static void dns_k_tea_init(struct dns_k_tea *tea, uint32_t key[], unsigned cycles) {
memcpy(tea->key, key, sizeof tea->key);
tea->cycles = (cycles)? cycles : DNS_K_TEA_CYCLES;
} /* dns_k_tea_init() */
static void dns_k_tea_encrypt(struct dns_k_tea *tea, uint32_t v[], uint32_t *w) {
uint32_t y, z, sum, n;
y = v[0];
z = v[1];
sum = 0;
for (n = 0; n < tea->cycles; n++) {
sum += DNS_K_TEA_MAGIC;
y += ((z << 4) + tea->key[0]) ^ (z + sum) ^ ((z >> 5) + tea->key[1]);
z += ((y << 4) + tea->key[2]) ^ (y + sum) ^ ((y >> 5) + tea->key[3]);
}
w[0] = y;
w[1] = z;
return /* void */;
} /* dns_k_tea_encrypt() */
/*
* Permutation generator, based on a Luby-Rackoff Feistel construction.
*
* Specifically, this is a generic balanced Feistel block cipher using TEA
* (another block cipher) as the pseudo-random function, F. At best it's as
* strong as F (TEA), notwithstanding the seeding. F could be AES, SHA-1, or
* perhaps Bernstein's Salsa20 core; I am naively trying to keep things
* simple.
*
* The generator can create a permutation of any set of numbers, as long as
* the size of the set is an even power of 2. This limitation arises either
* out of an inherent property of balanced Feistel constructions, or by my
* own ignorance. I'll tackle an unbalanced construction after I wrap my
* head around Schneier and Kelsey's paper.
*
* CAVEAT EMPTOR. IANAC.
*/
#define DNS_K_PERMUTOR_ROUNDS 8
struct dns_k_permutor {
unsigned stepi, length, limit;
unsigned shift, mask, rounds;
struct dns_k_tea tea;
}; /* struct dns_k_permutor */
static DNS_INLINE unsigned dns_k_permutor_powof(unsigned n) {
unsigned m, i = 0;
for (m = 1; m < n; m <<= 1, i++)
;;
return i;
} /* dns_k_permutor_powof() */
static void dns_k_permutor_init(struct dns_k_permutor *p, unsigned low, unsigned high) {
uint32_t key[DNS_K_TEA_KEY_SIZE / sizeof (uint32_t)];
unsigned width, i;
p->stepi = 0;
p->length = (high - low) + 1;
p->limit = high;
width = dns_k_permutor_powof(p->length);
width += width % 2;
p->shift = width / 2;
p->mask = (1U << p->shift) - 1;
p->rounds = DNS_K_PERMUTOR_ROUNDS;
for (i = 0; i < lengthof(key); i++)
key[i] = dns_random();
dns_k_tea_init(&p->tea, key, 0);
return /* void */;
} /* dns_k_permutor_init() */
static unsigned dns_k_permutor_F(struct dns_k_permutor *p, unsigned k, unsigned x) {
uint32_t in[DNS_K_TEA_BLOCK_SIZE / sizeof (uint32_t)], out[DNS_K_TEA_BLOCK_SIZE / sizeof (uint32_t)];
memset(in, '\0', sizeof in);
in[0] = k;
in[1] = x;
dns_k_tea_encrypt(&p->tea, in, out);
return p->mask & out[0];
} /* dns_k_permutor_F() */
static unsigned dns_k_permutor_E(struct dns_k_permutor *p, unsigned n) {
unsigned l[2], r[2];
unsigned i;
i = 0;
l[i] = p->mask & (n >> p->shift);
r[i] = p->mask & (n >> 0);
do {
l[(i + 1) % 2] = r[i % 2];
r[(i + 1) % 2] = l[i % 2] ^ dns_k_permutor_F(p, i, r[i % 2]);
i++;
} while (i < p->rounds - 1);
return ((l[i % 2] & p->mask) << p->shift) | ((r[i % 2] & p->mask) << 0);
} /* dns_k_permutor_E() */
DNS_NOTUSED static unsigned dns_k_permutor_D(struct dns_k_permutor *p, unsigned n) {
unsigned l[2], r[2];
unsigned i;
i = p->rounds - 1;
l[i % 2] = p->mask & (n >> p->shift);
r[i % 2] = p->mask & (n >> 0);
do {
i--;
r[i % 2] = l[(i + 1) % 2];
l[i % 2] = r[(i + 1) % 2] ^ dns_k_permutor_F(p, i, l[(i + 1) % 2]);
} while (i > 0);
return ((l[i % 2] & p->mask) << p->shift) | ((r[i % 2] & p->mask) << 0);
} /* dns_k_permutor_D() */
static unsigned dns_k_permutor_step(struct dns_k_permutor *p) {
unsigned n;
do {
n = dns_k_permutor_E(p, p->stepi++);
} while (n >= p->length);
return n + (p->limit + 1 - p->length);
} /* dns_k_permutor_step() */
/*
* Simple permutation box. Useful for shuffling rrsets from an iterator.
* Uses AES s-box to provide good diffusion.
*
* Seems to pass muster under runs test.
*
* $ for i in 0 1 2 3 4 5 6 7 8 9; do ./dns shuffle-16 > /tmp/out; done
* $ R -q -f /dev/stdin 2>/dev/null <<-EOF | awk '/p-value/{ print $8 }'
* library(lawstat)
* runs.test(scan(file="/tmp/out"))
* EOF
*/
static unsigned short dns_k_shuffle16(unsigned short n, unsigned s) {
static const unsigned char sbox[256] =
{ 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc,
0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a,
0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b,
0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85,
0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17,
0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88,
0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9,
0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6,
0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94,
0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };
unsigned char a, b;
unsigned i;
a = 0xff & (n >> 0);
b = 0xff & (n >> 8);
for (i = 0; i < 4; i++) {
a ^= 0xff & s;
a = sbox[a] ^ b;
b = sbox[b] ^ a;
s >>= 8;
}
return ((0xff00 & (a << 8)) | (0x00ff & (b << 0)));
} /* dns_k_shuffle16() */
/*
* U T I L I T Y R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define DNS_MAXINTERVAL 300
struct dns_clock {
time_t sample, elapsed;
}; /* struct dns_clock */
static void dns_begin(struct dns_clock *clk) {
clk->sample = time(0);
clk->elapsed = 0;
} /* dns_begin() */
static time_t dns_elapsed(struct dns_clock *clk) {
time_t curtime;
if ((time_t)-1 == time(&curtime))
return clk->elapsed;
if (curtime > clk->sample)
clk->elapsed += (time_t)DNS_PP_MIN(difftime(curtime, clk->sample), DNS_MAXINTERVAL);
clk->sample = curtime;
return clk->elapsed;
} /* dns_elapsed() */
DNS_NOTUSED static size_t dns_strnlen(const char *src, size_t m) {
size_t n = 0;
while (*src++ && n < m)
++n;
return n;
} /* dns_strnlen() */
DNS_NOTUSED static size_t dns_strnlcpy(char *dst, size_t lim, const char *src, size_t max) {
size_t len = dns_strnlen(src, max), n;
if (lim > 0) {
n = DNS_PP_MIN(lim - 1, len);
memcpy(dst, src, n);
dst[n] = '\0';
}
return len;
} /* dns_strnlcpy() */
#if (defined AF_UNIX && !defined _WIN32)
#define DNS_HAVE_SOCKADDR_UN 1
#endif
static size_t dns_af_len(int af) {
static const size_t table[AF_MAX] = {
[AF_INET6] = sizeof (struct sockaddr_in6),
[AF_INET] = sizeof (struct sockaddr_in),
#if DNS_HAVE_SOCKADDR_UN
[AF_UNIX] = sizeof (struct sockaddr_un),
#endif
};
return table[af];
} /* dns_af_len() */
#define dns_sa_family(sa) (((struct sockaddr_storage *)(sa))->ss_family)
#define dns_sa_len(sa) dns_af_len(dns_sa_family(sa))
#define DNS_SA_NOPORT &dns_sa_noport
static unsigned short dns_sa_noport;
static unsigned short *dns_sa_port(int af, void *sa) {
switch (af) {
case AF_INET6:
return &((struct sockaddr_in6 *)sa)->sin6_port;
case AF_INET:
return &((struct sockaddr_in *)sa)->sin_port;
default:
return DNS_SA_NOPORT;
}
} /* dns_sa_port() */
static void *dns_sa_addr(int af, const void *sa, socklen_t *size) {
switch (af) {
case AF_INET6: {
struct in6_addr *in6 = &((struct sockaddr_in6 *)sa)->sin6_addr;
if (size)
*size = sizeof *in6;
return in6;
}
case AF_INET: {
struct in_addr *in = &((struct sockaddr_in *)sa)->sin_addr;
if (size)
*size = sizeof *in;
return in;
}
default:
if (size)
*size = 0;
return 0;
}
} /* dns_sa_addr() */
#if DNS_HAVE_SOCKADDR_UN
#define DNS_SUNPATHMAX (sizeof ((struct sockaddr_un *)0)->sun_path)
#endif
DNS_NOTUSED static void *dns_sa_path(void *sa, socklen_t *size) {
switch (dns_sa_family(sa)) {
#if DNS_HAVE_SOCKADDR_UN
case AF_UNIX: {
char *path = ((struct sockaddr_un *)sa)->sun_path;
if (size)
*size = dns_strnlen(path, DNS_SUNPATHMAX);
return path;
}
#endif
default:
if (size)
*size = 0;
return NULL;
}
} /* dns_sa_path() */
static int dns_sa_cmp(void *a, void *b) {
int cmp, af;
if ((cmp = dns_sa_family(a) - dns_sa_family(b)))
return cmp;
switch ((af = dns_sa_family(a))) {
case AF_INET: {
struct in_addr *a4, *b4;
if ((cmp = htons(*dns_sa_port(af, a)) - htons(*dns_sa_port(af, b))))
return cmp;
a4 = dns_sa_addr(af, a, NULL);
b4 = dns_sa_addr(af, b, NULL);
if (ntohl(a4->s_addr) < ntohl(b4->s_addr))
return -1;
if (ntohl(a4->s_addr) > ntohl(b4->s_addr))
return 1;
return 0;
}
case AF_INET6: {
struct in6_addr *a6, *b6;
size_t i;
if ((cmp = htons(*dns_sa_port(af, a)) - htons(*dns_sa_port(af, b))))
return cmp;
a6 = dns_sa_addr(af, a, NULL);
b6 = dns_sa_addr(af, b, NULL);
/* XXX: do we need to use in6_clearscope()? */
for (i = 0; i < sizeof a6->s6_addr; i++) {
if ((cmp = a6->s6_addr[i] - b6->s6_addr[i]))
return cmp;
}
return 0;
}
#if DNS_HAVE_SOCKADDR_UN
case AF_UNIX: {
char a_path[DNS_SUNPATHMAX + 1], b_path[sizeof a_path];
dns_strnlcpy(a_path, sizeof a_path, dns_sa_path(a, NULL), DNS_SUNPATHMAX);
dns_strnlcpy(b_path, sizeof b_path, dns_sa_path(b, NULL), DNS_SUNPATHMAX);
return strcmp(a_path, b_path);
}
#endif
default:
return -1;
}
} /* dns_sa_cmp() */
#if _WIN32
static int dns_inet_pton(int af, const void *src, void *dst) {
union { struct sockaddr_in sin; struct sockaddr_in6 sin6; } u;
u.sin.sin_family = af;
if (0 != WSAStringToAddressA((void *)src, af, (void *)0, (struct sockaddr *)&u, &(int){ sizeof u }))
return -1;
switch (af) {
case AF_INET6:
*(struct in6_addr *)dst = u.sin6.sin6_addr;
return 1;
case AF_INET:
*(struct in_addr *)dst = u.sin.sin_addr;
return 1;
default:
return 0;
}
} /* dns_inet_pton() */
static const char *dns_inet_ntop(int af, const void *src, void *dst, unsigned long lim) {
union { struct sockaddr_in sin; struct sockaddr_in6 sin6; } u;
/* NOTE: WSAAddressToString will print .sin_port unless zeroed. */
memset(&u, 0, sizeof u);
u.sin.sin_family = af;
switch (af) {
case AF_INET6:
u.sin6.sin6_addr = *(struct in6_addr *)src;
break;
case AF_INET:
u.sin.sin_addr = *(struct in_addr *)src;
break;
default:
return 0;
}
if (0 != WSAAddressToStringA((struct sockaddr *)&u, dns_sa_len(&u), (void *)0, dst, &lim))
return 0;
return dst;
} /* dns_inet_ntop() */
#else
#define dns_inet_pton(...) inet_pton(__VA_ARGS__)
#define dns_inet_ntop(...) inet_ntop(__VA_ARGS__)
#endif
static dns_error_t dns_pton(int af, const void *src, void *dst) {
switch (dns_inet_pton(af, src, dst)) {
case 1:
return 0;
case -1:
return dns_soerr();
default:
return DNS_EADDRESS;
}
} /* dns_pton() */
static dns_error_t dns_ntop(int af, const void *src, void *dst, unsigned long lim) {
return (dns_inet_ntop(af, src, dst, lim))? 0 : dns_soerr();
} /* dns_ntop() */
size_t dns_strlcpy(char *dst, const char *src, size_t lim) {
char *d = dst;
char *e = &dst[lim];
const char *s = src;
if (d < e) {
do {
if ('\0' == (*d++ = *s++))
return s - src - 1;
} while (d < e);
d[-1] = '\0';
}
while (*s++ != '\0')
;;
return s - src - 1;
} /* dns_strlcpy() */
size_t dns_strlcat(char *dst, const char *src, size_t lim) {
char *d = memchr(dst, '\0', lim);
char *e = &dst[lim];
const char *s = src;
const char *p;
if (d && d < e) {
do {
if ('\0' == (*d++ = *s++))
return d - dst - 1;
} while (d < e);
d[-1] = '\0';
}
p = s;
while (*s++ != '\0')
;;
return lim + (s - p - 1);
} /* dns_strlcat() */
#if _WIN32
static char *dns_strsep(char **sp, const char *delim) {
char *p;
if (!(p = *sp))
return 0;
*sp += strcspn(p, delim);
if (**sp != '\0') {
**sp = '\0';
++*sp;
} else
*sp = NULL;
return p;
} /* dns_strsep() */
#else
#define dns_strsep(...) strsep(__VA_ARGS__)
#endif
#if _WIN32
#ifndef strcasecmp
#define strcasecmp(...) _stricmp(__VA_ARGS__)
#endif
#ifndef strncasecmp
#define strncasecmp(...) _strnicmp(__VA_ARGS__)
#endif
#endif
static DNS_INLINE _Bool dns_isalpha(unsigned char c) {
return isalpha(c);
} /* dns_isalpha() */
static DNS_INLINE _Bool dns_isdigit(unsigned char c) {
return isdigit(c);
} /* dns_isdigit() */
static DNS_INLINE _Bool dns_isalnum(unsigned char c) {
return isalnum(c);
} /* dns_isalnum() */
static DNS_INLINE _Bool dns_isspace(unsigned char c) {
return isspace(c);
} /* dns_isspace() */
static int dns_poll(int fd, short events, int timeout) {
/* For our usage in belle sip, we are called by the main loop when something is to read on the dns socket.
* As a result there is no need to perform a blocking select.
**/
#if 0
fd_set rset, wset;
if (!events)
return 0;
assert(fd >= 0 && (unsigned)fd < FD_SETSIZE);
FD_ZERO(&rset);
FD_ZERO(&wset);
if (events & DNS_POLLIN)
FD_SET(fd, &rset);
if (events & DNS_POLLOUT)
FD_SET(fd, &wset);
select(fd + 1, &rset, &wset, 0, (timeout >= 0)? &(struct timeval){ timeout, 0 } : NULL);
#endif
return 0;
} /* dns_poll() */
#if !_WIN32
DNS_NOTUSED static int dns_sigmask(int how, const sigset_t *set, sigset_t *oset) {
#if DNS_THREAD_SAFE
return pthread_sigmask(how, set, oset);
#else
return (0 == sigprocmask(how, set, oset))? 0 : errno;
#endif
} /* dns_sigmask() */
#endif
static long dns_send(int fd, const void *src, size_t lim, int flags) {
#if _WIN32 || !defined SIGPIPE || defined SO_NOSIGPIPE
return send(fd, src, lim, flags);
#elif defined MSG_NOSIGNAL
return send(fd, src, lim, flags|MSG_NOSIGNAL);
#elif _POSIX_REALTIME_SIGNALS > 0 /* require sigtimedwait */
/*
* SIGPIPE handling similar to the approach described in
* http://krokisplace.blogspot.com/2010/02/suppressing-sigpipe-in-library.html
*/
sigset_t pending, blocked, piped;
long count;
int saved, error;
sigemptyset(&pending);
sigpending(&pending);
if (!sigismember(&pending, SIGPIPE)) {
sigemptyset(&piped);
sigaddset(&piped, SIGPIPE);
sigemptyset(&blocked);
if ((error = dns_sigmask(SIG_BLOCK, &piped, &blocked)))
goto error;
}
count = send(fd, src, lim, flags);
if (!sigismember(&pending, SIGPIPE)) {
saved = errno;
if (count == -1 && errno == EPIPE) {
while (-1 == sigtimedwait(&piped, NULL, &(struct timespec){ 0, 0 }) && errno == EINTR)
;;
}
if ((error = dns_sigmask(SIG_SETMASK, &blocked, NULL)))
goto error;
errno = saved;
}
return count;
error:
errno = error;
return -1;
#else
#error "unable to suppress SIGPIPE"
return send(fd, src, lim, flags);
#endif
} /* dns_send() */
#define DNS_FOPEN_STDFLAGS "rwabt+"
static dns_error_t dns_fopen_addflag(char *dst, const char *src, size_t lim, int fc) {
char *p = dst, *pe = dst + lim;
/* copy standard flags */
while (*src && strchr(DNS_FOPEN_STDFLAGS, *src)) {
if (!(p < pe))
return ENOMEM;
*p++ = *src++;
}
/* append flag to standard flags */
if (!(p < pe))
return ENOMEM;
*p++ = fc;
/* copy remaining mode string, including '\0' */
do {
if (!(p < pe))
return ENOMEM;
} while ((*p++ = *src++));
return 0;
} /* dns_fopen_addflag() */
static FILE *dns_fopen(const char *path, const char *mode, dns_error_t *_error) {
FILE *fp;
char mode_cloexec[32];
int error;
assert(path && mode && *mode);
if (!*path) {
error = EINVAL;
goto error;
}
#if _WIN32 || _WIN64
if ((error = dns_fopen_addflag(mode_cloexec, mode, sizeof mode_cloexec, 'N')))
goto error;
if (!(fp = fopen(path, mode_cloexec)))
goto syerr;
#else
if ((error = dns_fopen_addflag(mode_cloexec, mode, sizeof mode_cloexec, 'e')))
goto error;
if (!(fp = fopen(path, mode_cloexec))) {
if (errno != EINVAL)
goto syerr;
if (!(fp = fopen(path, mode)))
goto syerr;
}
#endif
return fp;
syerr:
error = dns_syerr();
error:
*_error = error;
return NULL;
} /* dns_fopen() */
/*
* F I X E D - S I Z E D B U F F E R R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define DNS_B_INIT(src, n) { \
(unsigned char *)(src), \
(unsigned char *)(src), \
(unsigned char *)(src) + (n), \
}
#define DNS_B_FROM(src, n) DNS_B_INIT((src), (n))
#define DNS_B_INTO(src, n) DNS_B_INIT((src), (n))
struct dns_buf {
const unsigned char *base;
unsigned char *p;
const unsigned char *pe;
dns_error_t error;
size_t overflow;
}; /* struct dns_buf */
static DNS_INLINE size_t
dns_b_tell(struct dns_buf *b)
{
return b->p - b->base;
}
static DNS_INLINE dns_error_t
dns_b_setoverflow(struct dns_buf *b, size_t n, dns_error_t error)
{
b->overflow += n;
return b->error = error;
}
DNS_NOTUSED static struct dns_buf *
dns_b_into(struct dns_buf *b, void *src, size_t n)
{
*b = (struct dns_buf)DNS_B_INTO(src, n);
return b;
}
static dns_error_t
dns_b_putc(struct dns_buf *b, unsigned char uc)
{
if (!(b->p < b->pe))
return dns_b_setoverflow(b, 1, DNS_ENOBUFS);
*b->p++ = uc;
return 0;
}
static dns_error_t
dns_b_pputc(struct dns_buf *b, unsigned char uc, size_t p)
{
size_t pe = b->pe - b->base;
if (pe <= p)
return dns_b_setoverflow(b, p - pe + 1, DNS_ENOBUFS);
*((unsigned char *)b->base + p) = uc;
return 0;
}
static DNS_INLINE dns_error_t
dns_b_put16(struct dns_buf *b, uint16_t u)
{
return dns_b_putc(b, u >> 8), dns_b_putc(b, u >> 0);
}
static DNS_INLINE dns_error_t
dns_b_pput16(struct dns_buf *b, uint16_t u, size_t p)
{
if (dns_b_pputc(b, u >> 8, p) || dns_b_pputc(b, u >> 0, p + 1))
return b->error;
return 0;
}
DNS_NOTUSED static DNS_INLINE dns_error_t
dns_b_put32(struct dns_buf *b, uint32_t u)
{
return dns_b_putc(b, u >> 24), dns_b_putc(b, u >> 16),
dns_b_putc(b, u >> 8), dns_b_putc(b, u >> 0);
}
static dns_error_t
dns_b_put(struct dns_buf *b, const void *src, size_t len)
{
size_t n = DNS_PP_MIN((size_t)(b->pe - b->p), len);
memcpy(b->p, src, n);
b->p += n;
if (n < len)
return dns_b_setoverflow(b, len - n, DNS_ENOBUFS);
return 0;
}
static dns_error_t
dns_b_puts(struct dns_buf *b, const void *src)
{
return dns_b_put(b, src, strlen(src));
}
DNS_NOTUSED static DNS_INLINE dns_error_t
dns_b_fmtju(struct dns_buf *b, const uintmax_t u, const unsigned width)
{
size_t digits, padding, overflow;
uintmax_t r;
unsigned char *tp, *te, tc;
digits = 0;
r = u;
do {
digits++;
r /= 10;
} while (r);
padding = width - DNS_PP_MIN(digits, width);
overflow = (digits + padding) - DNS_PP_MIN((size_t)(b->pe - b->p), (digits + padding));
while (padding--) {
dns_b_putc(b, '0');
}
digits = 0;
tp = b->p;
r = u;
do {
if (overflow < ++digits)
dns_b_putc(b, '0' + (r % 10));
r /= 10;
} while (r);
te = b->p;
while (tp < te) {
tc = *--te;
*te = *tp;
*tp++ = tc;
}
return b->error;
}
static void
dns_b_popc(struct dns_buf *b)
{
if (b->overflow && !--b->overflow)
b->error = 0;
if (b->p > b->base)
b->p--;
}
static DNS_INLINE const char *
dns_b_tolstring(struct dns_buf *b, size_t *n)
{
if (b->p < b->pe) {
*b->p = '\0';
*n = b->p - b->base;
return (const char *)b->base;
} else if (b->p > b->base) {
if (b->p[-1] != '\0') {
dns_b_setoverflow(b, 1, DNS_ENOBUFS);
b->p[-1] = '\0';
}
*n = &b->p[-1] - b->base;
return (const char *)b->base;
} else {
*n = 0;
return "";
}
}
static DNS_INLINE const char *
dns_b_tostring(struct dns_buf *b)
{
size_t n;
return dns_b_tolstring(b, &n);
}
static DNS_INLINE size_t
dns_b_strlen(struct dns_buf *b)
{
size_t n;
dns_b_tolstring(b, &n);
return n;
}
static DNS_INLINE size_t
dns_b_strllen(struct dns_buf *b)
{
size_t n = dns_b_strlen(b);
return n + b->overflow;
}
DNS_NOTUSED static const struct dns_buf *
dns_b_from(const struct dns_buf *b, const void *src, size_t n)
{
*(struct dns_buf *)b = (struct dns_buf)DNS_B_FROM(src, n);
return b;
}
static DNS_INLINE int
dns_b_getc(const struct dns_buf *_b, const int eof)
{
struct dns_buf *b = (struct dns_buf *)_b;
if (!(b->p < b->pe))
return dns_b_setoverflow(b, 1, DNS_EILLEGAL), eof;
return *b->p++;
}
static DNS_INLINE intmax_t
dns_b_get16(const struct dns_buf *b, const intmax_t eof)
{
intmax_t n;
n = (dns_b_getc(b, 0) << 8);
n |= (dns_b_getc(b, 0) << 0);
return (!b->overflow)? n : eof;
}
DNS_NOTUSED static DNS_INLINE intmax_t
dns_b_get32(const struct dns_buf *b, const intmax_t eof)
{
intmax_t n;
n = (dns_b_get16(b, 0) << 16);
n |= (dns_b_get16(b, 0) << 0);
return (!b->overflow)? n : eof;
}
static DNS_INLINE dns_error_t
dns_b_move(struct dns_buf *dst, const struct dns_buf *_src, size_t n)
{
struct dns_buf *src = (struct dns_buf *)_src;
size_t src_n = DNS_PP_MIN((size_t)(src->pe - src->p), n);
size_t src_r = n - src_n;
dns_b_put(dst, src->p, src_n);
src->p += src_n;
if (src_r)
return dns_b_setoverflow(src, src_r, DNS_EILLEGAL);
return dst->error;
}
/*
* P A C K E T R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
unsigned dns_p_count(struct dns_packet *P, enum dns_section section) {
unsigned count;
switch (section) {
case DNS_S_QD:
return ntohs(dns_header(P)->qdcount);
case DNS_S_AN:
return ntohs(dns_header(P)->ancount);
case DNS_S_NS:
return ntohs(dns_header(P)->nscount);
case DNS_S_AR:
return ntohs(dns_header(P)->arcount);
default:
count = 0;
if (section & DNS_S_QD)
count += ntohs(dns_header(P)->qdcount);
if (section & DNS_S_AN)
count += ntohs(dns_header(P)->ancount);
if (section & DNS_S_NS)
count += ntohs(dns_header(P)->nscount);
if (section & DNS_S_AR)
count += ntohs(dns_header(P)->arcount);
return count;
}
} /* dns_p_count() */
struct dns_packet *dns_p_init(struct dns_packet *P, size_t size) {
if (!P)
return 0;
assert(size >= offsetof(struct dns_packet, data) + 12);
memset(P, 0, sizeof *P);
P->size = size - offsetof(struct dns_packet, data);
P->end = 12;
memset(P->data, '\0', 12);
return P;
} /* dns_p_init() */
static struct dns_packet *dns_p_reset(struct dns_packet *P) {
return dns_p_init(P, offsetof(struct dns_packet, data) + P->size);
} /* dns_p_reset() */
static unsigned short dns_p_qend(struct dns_packet *P) {
unsigned short qend = 12;
unsigned i, count = dns_p_count(P, DNS_S_QD);
for (i = 0; i < count && qend < P->end; i++) {
if (P->end == (qend = dns_d_skip(qend, P)))
goto invalid;
if (P->end - qend < 4)
goto invalid;
qend += 4;
}
return DNS_PP_MIN(qend, P->end);
invalid:
return P->end;
} /* dns_p_qend() */
struct dns_packet *dns_p_make(size_t len, int *error) {
struct dns_packet *P;
size_t size = dns_p_calcsize(len);
if (!(P = dns_p_init(malloc(size), size)))
*error = dns_syerr();
return P;
} /* dns_p_make() */
static void dns_p_free(struct dns_packet *P) {
free(P);
} /* dns_p_free() */
/* convience routine to free any existing packet before storing new packet */
static struct dns_packet *dns_p_setptr(struct dns_packet **dst, struct dns_packet *src) {
dns_p_free(*dst);
*dst = src;
return src;
} /* dns_p_setptr() */
static struct dns_packet *dns_p_movptr(struct dns_packet **dst, struct dns_packet **src) {
dns_p_setptr(dst, *src);
*src = NULL;
return *dst;
} /* dns_p_movptr() */
int dns_p_grow(struct dns_packet **P) {
struct dns_packet *tmp;
size_t size;
int error;
if (!*P) {
if (!(*P = dns_p_make(DNS_P_QBUFSIZ, &error)))
return error;
return 0;
}
size = dns_p_sizeof(*P);
size |= size >> 1;
size |= size >> 2;
size |= size >> 4;
size |= size >> 8;
size++;
if (size > 65536)
return DNS_ENOBUFS;
if (!(tmp = realloc(*P, dns_p_calcsize(size))))
return dns_syerr();
tmp->size = size;
*P = tmp;
return 0;
} /* dns_p_grow() */
struct dns_packet *dns_p_copy(struct dns_packet *P, const struct dns_packet *P0) {
if (!P)
return 0;
P->end = DNS_PP_MIN(P->size, P0->end);
memcpy(P->data, P0->data, P->end);
return P;
} /* dns_p_copy() */
struct dns_packet *dns_p_merge(struct dns_packet *A, enum dns_section Amask, struct dns_packet *B, enum dns_section Bmask, int *error_) {
size_t bufsiz = DNS_PP_MIN(65535, ((A)? A->end : 0) + ((B)? B->end : 0));
struct dns_packet *M;
enum dns_section section;
struct dns_rr rr, mr;
int error, copy;
if (!A && B) {
A = B;
Amask = Bmask;
B = 0;
}
merge:
if (!(M = dns_p_make(bufsiz, &error)))
goto error;
for (section = DNS_S_QD; (DNS_S_ALL & section); section <<= 1) {
if (A && (section & Amask)) {
dns_rr_foreach(&rr, A, .section = section) {
if ((error = dns_rr_copy(M, &rr, A)))
goto error;
}
}
if (B && (section & Bmask)) {
dns_rr_foreach(&rr, B, .section = section) {
copy = 1;
dns_rr_foreach(&mr, M, .type = rr.type, .section = DNS_S_ALL) {
if (!(copy = dns_rr_cmp(&rr, B, &mr, M)))
break;
}
if (copy && (error = dns_rr_copy(M, &rr, B)))
goto error;
}
}
}
return M;
error:
dns_p_setptr(&M, NULL);
if (error == DNS_ENOBUFS && bufsiz < 65535) {
bufsiz = DNS_PP_MIN(65535, bufsiz * 2);
goto merge;
}
*error_ = error;
return 0;
} /* dns_p_merge() */
static unsigned short dns_l_skip(unsigned short, const unsigned char *, size_t);
void dns_p_dictadd(struct dns_packet *P, unsigned short dn) {
unsigned short lp, lptr, i;
lp = dn;
while (lp < P->end) {
if (0xc0 == (0xc0 & P->data[lp]) && P->end - lp >= 2 && lp != dn) {
lptr = ((0x3f & P->data[lp + 0]) << 8)
| ((0xff & P->data[lp + 1]) << 0);
for (i = 0; i < lengthof(P->dict) && P->dict[i]; i++) {
if (P->dict[i] == lptr) {
P->dict[i] = dn;
return;
}
}
}
lp = dns_l_skip(lp, P->data, P->end);
}
for (i = 0; i < lengthof(P->dict); i++) {
if (!P->dict[i]) {
P->dict[i] = dn;
break;
}
}
} /* dns_p_dictadd() */
int dns_p_push(struct dns_packet *P, enum dns_section section, const void *dn, size_t dnlen, enum dns_type type, enum dns_class class, unsigned ttl, const void *any) {
size_t end = P->end;
int error;
if ((error = dns_d_push(P, dn, dnlen)))
goto error;
if (P->size - P->end < 4)
goto nobufs;
P->data[P->end++] = 0xff & (type >> 8);
P->data[P->end++] = 0xff & (type >> 0);
P->data[P->end++] = 0xff & (class >> 8);
P->data[P->end++] = 0xff & (class >> 0);
if (section == DNS_S_QD)
goto update;
if (P->size - P->end < 6)
goto nobufs;
if (type != DNS_T_OPT)
ttl = DNS_PP_MIN(ttl, 0x7fffffffU);
P->data[P->end++] = ttl >> 24;
P->data[P->end++] = ttl >> 16;
P->data[P->end++] = ttl >> 8;
P->data[P->end++] = ttl >> 0;
if ((error = dns_any_push(P, (union dns_any *)any, type)))
goto error;
update:
switch (section) {
case DNS_S_QD:
if (dns_p_count(P, DNS_S_AN|DNS_S_NS|DNS_S_AR))
goto order;
if (!P->memo.qd.base && (error = dns_p_study(P)))
goto error;
dns_header(P)->qdcount = htons(ntohs(dns_header(P)->qdcount) + 1);
P->memo.qd.end = P->end;
P->memo.an.base = P->end;
P->memo.an.end = P->end;
P->memo.ns.base = P->end;
P->memo.ns.end = P->end;
P->memo.ar.base = P->end;
P->memo.ar.end = P->end;
break;
case DNS_S_AN:
if (dns_p_count(P, DNS_S_NS|DNS_S_AR))
goto order;
if (!P->memo.an.base && (error = dns_p_study(P)))
goto error;
dns_header(P)->ancount = htons(ntohs(dns_header(P)->ancount) + 1);
P->memo.an.end = P->end;
P->memo.ns.base = P->end;
P->memo.ns.end = P->end;
P->memo.ar.base = P->end;
P->memo.ar.end = P->end;
break;
case DNS_S_NS:
if (dns_p_count(P, DNS_S_AR))
goto order;
if (!P->memo.ns.base && (error = dns_p_study(P)))
goto error;
dns_header(P)->nscount = htons(ntohs(dns_header(P)->nscount) + 1);
P->memo.ns.end = P->end;
P->memo.ar.base = P->end;
P->memo.ar.end = P->end;
break;
case DNS_S_AR:
if (!P->memo.ar.base && (error = dns_p_study(P)))
goto error;
dns_header(P)->arcount = htons(ntohs(dns_header(P)->arcount) + 1);
P->memo.ar.end = P->end;
if (type == DNS_T_OPT && !P->memo.opt.p) {
P->memo.opt.p = end;
P->memo.opt.maxudp = class;
P->memo.opt.ttl = ttl;
}
break;
default:
error = DNS_ESECTION;
goto error;
} /* switch() */
return 0;
nobufs:
error = DNS_ENOBUFS;
goto error;
order:
error = DNS_EORDER;
goto error;
error:
P->end = end;
return error;
} /* dns_p_push() */
static void dns_p_dump3(struct dns_packet *P, struct dns_rr_i *I, FILE *fp) {
enum dns_section section;
struct dns_rr rr;
int error;
union dns_any any;
char pretty[sizeof any * 2];
size_t len;
fputs(";; [HEADER]\n", fp);
fprintf(fp, ";; qid : %d\n", ntohs(dns_header(P)->qid));
fprintf(fp, ";; qr : %s(%d)\n", (dns_header(P)->qr)? "RESPONSE" : "QUERY", dns_header(P)->qr);
fprintf(fp, ";; opcode : %s(%d)\n", dns_stropcode(dns_header(P)->opcode), dns_header(P)->opcode);
fprintf(fp, ";; aa : %s(%d)\n", (dns_header(P)->aa)? "AUTHORITATIVE" : "NON-AUTHORITATIVE", dns_header(P)->aa);
fprintf(fp, ";; tc : %s(%d)\n", (dns_header(P)->tc)? "TRUNCATED" : "NOT-TRUNCATED", dns_header(P)->tc);
fprintf(fp, ";; rd : %s(%d)\n", (dns_header(P)->rd)? "RECURSION-DESIRED" : "RECURSION-NOT-DESIRED", dns_header(P)->rd);
fprintf(fp, ";; ra : %s(%d)\n", (dns_header(P)->ra)? "RECURSION-ALLOWED" : "RECURSION-NOT-ALLOWED", dns_header(P)->ra);
fprintf(fp, ";; rcode : %s(%d)\n", dns_strrcode(dns_p_rcode(P)), dns_p_rcode(P));
section = 0;
while (dns_rr_grep(&rr, 1, I, P, &error)) {
if (section != rr.section)
fprintf(fp, "\n;; [%s:%d]\n", dns_strsection(rr.section), dns_p_count(P, rr.section));
if ((len = dns_rr_print(pretty, sizeof pretty, &rr, P, &error)))
fprintf(fp, "%s\n", pretty);
section = rr.section;
}
} /* dns_p_dump3() */
void dns_p_dump(struct dns_packet *P, FILE *fp) {
dns_p_dump3(P, dns_rr_i_new(P, .section = 0), fp);
} /* dns_p_dump() */
static void dns_s_unstudy(struct dns_s_memo *m)
{ m->base = 0; m->end = 0; }
static void dns_m_unstudy(struct dns_p_memo *m) {
dns_s_unstudy(&m->qd);
dns_s_unstudy(&m->an);
dns_s_unstudy(&m->ns);
dns_s_unstudy(&m->ar);
m->opt.p = 0;
m->opt.maxudp = 0;
m->opt.ttl = 0;
} /* dns_m_unstudy() */
static int dns_s_study(struct dns_s_memo *m, enum dns_section section, unsigned short base, struct dns_packet *P) {
unsigned short count, rp;
count = dns_p_count(P, section);
for (rp = base; count && rp < P->end; count--)
rp = dns_rr_skip(rp, P);
m->base = base;
m->end = rp;
return 0;
} /* dns_s_study() */
static int dns_m_study(struct dns_p_memo *m, struct dns_packet *P) {
struct dns_rr rr;
int error;
if ((error = dns_s_study(&m->qd, DNS_S_QD, 12, P)))
goto error;
if ((error = dns_s_study(&m->an, DNS_S_AN, m->qd.end, P)))
goto error;
if ((error = dns_s_study(&m->ns, DNS_S_NS, m->an.end, P)))
goto error;
if ((error = dns_s_study(&m->ar, DNS_S_AR, m->ns.end, P)))
goto error;
m->opt.p = 0;
m->opt.maxudp = 0;
m->opt.ttl = 0;
dns_rr_foreach(&rr, P, .type = DNS_T_OPT, .section = DNS_S_AR) {
m->opt.p = rr.dn.p;
m->opt.maxudp = rr.class;
m->opt.ttl = rr.ttl;
break;
}
return 0;
error:
dns_m_unstudy(m);
return error;
} /* dns_m_study() */
int dns_p_study(struct dns_packet *P) {
return dns_m_study(&P->memo, P);
} /* dns_p_study() */
enum dns_rcode dns_p_rcode(struct dns_packet *P) {
return 0xfff & ((P->memo.opt.ttl >> 20) | dns_header(P)->rcode);
} /* dns_p_rcode() */
/*
* Q U E R Y P A C K E T R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define DNS_Q_RD 0x1 /* recursion desired */
#define DNS_Q_EDNS0 0x2 /* include OPT RR */
static dns_error_t
dns_q_make2(struct dns_packet **_Q, const char *qname, size_t qlen, enum dns_type qtype, enum dns_class qclass, int qflags)
{
struct dns_packet *Q = NULL;
int error;
if (dns_p_movptr(&Q, _Q)) {
dns_p_reset(Q);
} else if (!(Q = dns_p_make(DNS_P_QBUFSIZ, &error))) {
goto error;
}
if ((error = dns_p_push(Q, DNS_S_QD, qname, qlen, qtype, qclass, 0, 0)))
goto error;
dns_header(Q)->rd = !!(qflags & DNS_Q_RD);
if (qflags & DNS_Q_EDNS0) {
struct dns_opt opt = DNS_OPT_INIT(&opt);
opt.version = 0; /* RFC 6891 version */
opt.maxudp = 4096;
if ((error = dns_p_push(Q, DNS_S_AR, ".", 1, DNS_T_OPT, dns_opt_class(&opt), dns_opt_ttl(&opt), &opt)))
goto error;
}
*_Q = Q;
return 0;
error:
dns_p_free(Q);
return error;
}
static dns_error_t
dns_q_make(struct dns_packet **Q, const char *qname, enum dns_type qtype, enum dns_class qclass, int qflags)
{
return dns_q_make2(Q, qname, strlen(qname), qtype, qclass, qflags);
}
static dns_error_t
dns_q_remake(struct dns_packet **Q, int qflags)
{
char qname[DNS_D_MAXNAME + 1];
size_t qlen;
struct dns_rr rr;
int error;
assert(Q && *Q);
if ((error = dns_rr_parse(&rr, 12, *Q)))
return error;
if (!(qlen = dns_d_expand(qname, sizeof qname, rr.dn.p, *Q, &error)))
return error;
if (qlen >= sizeof qname)
return DNS_EILLEGAL;
return dns_q_make2(Q, qname, qlen, rr.type, rr.class, qflags);
}
/*
* D O M A I N N A M E R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef DNS_D_MAXPTRS
#define DNS_D_MAXPTRS 127 /* Arbitrary; possible, valid depth is something like packet size / 2 + fudge. */
#endif
static size_t dns_l_expand(unsigned char *dst, size_t lim, unsigned short src, unsigned short *nxt, const unsigned char *data, size_t end) {
unsigned short len;
unsigned nptrs = 0;
retry:
if (src >= end)
goto invalid;
switch (0x03 & (data[src] >> 6)) {
case 0x00:
len = (0x3f & (data[src++]));
if (end - src < len)
goto invalid;
if (lim > 0) {
memcpy(dst, &data[src], DNS_PP_MIN(lim, len));
dst[DNS_PP_MIN(lim - 1, len)] = '\0';
}
*nxt = src + len;
return len;
case 0x01:
goto invalid;
case 0x02:
goto invalid;
case 0x03:
if (++nptrs > DNS_D_MAXPTRS)
goto invalid;
if (end - src < 2)
goto invalid;
src = ((0x3f & data[src + 0]) << 8)
| ((0xff & data[src + 1]) << 0);
goto retry;
} /* switch() */
/* NOT REACHED */
invalid:
*nxt = end;
return 0;
} /* dns_l_expand() */
static unsigned short dns_l_skip(unsigned short src, const unsigned char *data, size_t end) {
unsigned short len;
if (src >= end)
goto invalid;
switch (0x03 & (data[src] >> 6)) {
case 0x00:
len = (0x3f & (data[src++]));
if (end - src < len)
goto invalid;
return (len)? src + len : end;
case 0x01:
goto invalid;
case 0x02:
goto invalid;
case 0x03:
return end;
} /* switch() */
/* NOT REACHED */
invalid:
return end;
} /* dns_l_skip() */
static size_t dns_d_trim(void *dst_, size_t lim, const void *src_, size_t len, int flags) {
unsigned char *dst = dst_;
const unsigned char *src = src_;
size_t dp = 0, sp = 0;
int lc;
/* trim any leading dot(s) */
while (sp < len && src[sp] == '.')
sp++;
for (lc = 0; sp < len; lc = src[sp++]) {
/* trim extra dot(s) */
if (src[sp] == '.' && lc == '.')
continue;
if (dp < lim)
dst[dp] = src[sp];
dp++;
}
if ((flags & DNS_D_ANCHOR) && lc != '.') {
if (dp < lim)
dst[dp] = '.';
dp++;
}
if (lim > 0)
dst[DNS_PP_MIN(dp, lim - 1)] = '\0';
return dp;
} /* dns_d_trim() */
char *dns_d_init(void *dst, size_t lim, const void *src, size_t len, int flags) {
if (flags & DNS_D_TRIM) {
dns_d_trim(dst, lim, src, len, flags);
} if (flags & DNS_D_ANCHOR) {
dns_d_anchor(dst, lim, src, len);
} else {
memmove(dst, src, DNS_PP_MIN(lim, len));
if (lim > 0)
((char *)dst)[DNS_PP_MIN(len, lim - 1)] = '\0';
}
return dst;
} /* dns_d_init() */
size_t dns_d_anchor(void *dst, size_t lim, const void *src, size_t len) {
if (len == 0)
return 0;
memmove(dst, src, DNS_PP_MIN(lim, len));
if (((const char *)src)[len - 1] != '.') {
if (len < lim)
((char *)dst)[len] = '.';
len++;
}
if (lim > 0)
((char *)dst)[DNS_PP_MIN(lim - 1, len)] = '\0';
return len;
} /* dns_d_anchor() */
size_t dns_d_cleave(void *dst, size_t lim, const void *src, size_t len) {
const char *dot;
/* XXX: Skip any leading dot. Handles cleaving root ".". */
if (len == 0 || !(dot = memchr((const char *)src + 1, '.', len - 1)))
return 0;
len -= dot - (const char *)src;
/* XXX: Unless root, skip the label's trailing dot. */
if (len > 1) {
src = ++dot;
len--;
} else
src = dot;
memmove(dst, src, DNS_PP_MIN(lim, len));
if (lim > 0)
((char *)dst)[DNS_PP_MIN(lim - 1, len)] = '\0';
return len;
} /* dns_d_cleave() */
size_t dns_d_comp(void *dst_, size_t lim, const void *src_, size_t len, struct dns_packet *P, int *error) {
struct { unsigned char *b; size_t p, x; } dst, src;
unsigned char ch = '.';
dst.b = dst_;
dst.p = 0;
dst.x = 1;
src.b = (unsigned char *)src_;
src.p = 0;
src.x = 0;
while (src.x < len) {
ch = src.b[src.x];
if (ch == '.') {
if (dst.p < lim)
dst.b[dst.p] = (0x3f & (src.x - src.p));
dst.p = dst.x++;
src.p = ++src.x;
} else {
if (dst.x < lim)
dst.b[dst.x] = ch;
dst.x++;
src.x++;
}
} /* while() */
if (src.x > src.p) {
if (dst.p < lim)
dst.b[dst.p] = (0x3f & (src.x - src.p));
dst.p = dst.x;
}
if (dst.p > 1) {
if (dst.p < lim)
dst.b[dst.p] = 0x00;
dst.p++;
}
#if 1
if (dst.p < lim) {
struct { unsigned char label[DNS_D_MAXLABEL + 1]; size_t len; unsigned short p, x, y; } a, b;
unsigned i;
a.p = 0;
while ((a.len = dns_l_expand(a.label, sizeof a.label, a.p, &a.x, dst.b, lim))) {
for (i = 0; i < lengthof(P->dict) && P->dict[i]; i++) {
b.p = P->dict[i];
while ((b.len = dns_l_expand(b.label, sizeof b.label, b.p, &b.x, P->data, P->end))) {
a.y = a.x;
b.y = b.x;
while (a.len && b.len && 0 == strcasecmp((char *)a.label, (char *)b.label)) {
a.len = dns_l_expand(a.label, sizeof a.label, a.y, &a.y, dst.b, lim);
b.len = dns_l_expand(b.label, sizeof b.label, b.y, &b.y, P->data, P->end);
}
if (a.len == 0 && b.len == 0 && b.p <= 0x3fff) {
dst.b[a.p++] = 0xc0
| (0x3f & (b.p >> 8));
dst.b[a.p++] = (0xff & (b.p >> 0));
/* silence static analyzers */
dns_assume(a.p > 0);
return a.p;
}
b.p = b.x;
} /* while() */
} /* for() */
a.p = a.x;
} /* while() */
} /* if () */
#endif
if (!dst.p)
*error = DNS_EILLEGAL;
return dst.p;
} /* dns_d_comp() */
unsigned short dns_d_skip(unsigned short src, struct dns_packet *P) {
unsigned short len;
while (src < P->end) {
switch (0x03 & (P->data[src] >> 6)) {
case 0x00: /* FOLLOWS */
len = (0x3f & P->data[src++]);
if (0 == len) {
/* success ==> */ return src;
} else if (P->end - src > len) {
src += len;
break;
} else
goto invalid;
/* NOT REACHED */
case 0x01: /* RESERVED */
goto invalid;
case 0x02: /* RESERVED */
goto invalid;
case 0x03: /* POINTER */
if (P->end - src < 2)
goto invalid;
src += 2;
/* success ==> */ return src;
} /* switch() */
} /* while() */
invalid:
return P->end;
} /* dns_d_skip() */
#include
size_t dns_d_expand(void *dst, size_t lim, unsigned short src, struct dns_packet *P, int *error) {
size_t dstp = 0;
unsigned nptrs = 0;
unsigned char len;
while (src < P->end) {
switch ((0x03 & (P->data[src] >> 6))) {
case 0x00: /* FOLLOWS */
len = (0x3f & P->data[src]);
if (0 == len) {
if (dstp == 0) {
if (dstp < lim)
((unsigned char *)dst)[dstp] = '.';
dstp++;
}
/* NUL terminate */
if (lim > 0)
((unsigned char *)dst)[DNS_PP_MIN(dstp, lim - 1)] = '\0';
/* success ==> */ return dstp;
}
src++;
if (P->end - src < len)
goto toolong;
if (dstp < lim)
memcpy(&((unsigned char *)dst)[dstp], &P->data[src], DNS_PP_MIN(len, lim - dstp));
src += len;
dstp += len;
if (dstp < lim)
((unsigned char *)dst)[dstp] = '.';
dstp++;
nptrs = 0;
continue;
case 0x01: /* RESERVED */
goto reserved;
case 0x02: /* RESERVED */
goto reserved;
case 0x03: /* POINTER */
if (++nptrs > DNS_D_MAXPTRS)
goto toolong;
if (P->end - src < 2)
goto toolong;
src = ((0x3f & P->data[src + 0]) << 8)
| ((0xff & P->data[src + 1]) << 0);
continue;
} /* switch() */
} /* while() */
toolong:
*error = DNS_EILLEGAL;
if (lim > 0)
((unsigned char *)dst)[DNS_PP_MIN(dstp, lim - 1)] = '\0';
return 0;
reserved:
*error = DNS_EILLEGAL;
if (lim > 0)
((unsigned char *)dst)[DNS_PP_MIN(dstp, lim - 1)] = '\0';
return 0;
} /* dns_d_expand() */
int dns_d_push(struct dns_packet *P, const void *dn, size_t len) {
size_t lim = P->size - P->end;
unsigned dp = P->end;
int error = DNS_EILLEGAL; /* silence compiler */
len = dns_d_comp(&P->data[dp], lim, dn, len, P, &error);
if (len == 0)
return error;
if (len > lim)
return DNS_ENOBUFS;
P->end += len;
dns_p_dictadd(P, dp);
return 0;
} /* dns_d_push() */
size_t dns_d_cname(void *dst, size_t lim, const void *dn, size_t len, struct dns_packet *P, int *error_) {
char host[DNS_D_MAXNAME + 1];
struct dns_rr_i i;
struct dns_rr rr;
unsigned depth;
int error;
if (sizeof host <= dns_d_anchor(host, sizeof host, dn, len))
{ error = ENAMETOOLONG; goto error; }
for (depth = 0; depth < 7; depth++) {
dns_rr_i_init(memset(&i, 0, sizeof i), P);
i.section = DNS_S_ALL & ~DNS_S_QD;
i.name = host;
i.type = DNS_T_CNAME;
if (!dns_rr_grep(&rr, 1, &i, P, &error))
break;
if ((error = dns_cname_parse((struct dns_cname *)host, &rr, P)))
goto error;
}
return dns_strlcpy(dst, host, lim);
error:
*error_ = error;
return 0;
} /* dns_d_cname() */
/*
* R E S O U R C E R E C O R D R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int dns_rr_copy(struct dns_packet *P, struct dns_rr *rr, struct dns_packet *Q) {
unsigned char dn[DNS_D_MAXNAME + 1];
union dns_any any;
size_t len;
int error;
if (!(len = dns_d_expand(dn, sizeof dn, rr->dn.p, Q, &error)))
return error;
else if (len >= sizeof dn)
return DNS_EILLEGAL;
if (rr->section != DNS_S_QD && (error = dns_any_parse(dns_any_init(&any, sizeof any), rr, Q)))
return error;
return dns_p_push(P, rr->section, dn, len, rr->type, rr->class, rr->ttl, &any);
} /* dns_rr_copy() */
int dns_rr_parse(struct dns_rr *rr, unsigned short src, struct dns_packet *P) {
unsigned short p = src;
if (src >= P->end)
goto invalid;
rr->dn.p = p;
rr->dn.len = (p = dns_d_skip(p, P)) - rr->dn.p;
if (P->end - p < 4)
goto invalid;
rr->type = ((0xff & P->data[p + 0]) << 8)
| ((0xff & P->data[p + 1]) << 0);
rr->class = ((0xff & P->data[p + 2]) << 8)
| ((0xff & P->data[p + 3]) << 0);
p += 4;
if (src < dns_p_qend(P)) {
rr->section = DNS_S_QUESTION;
rr->ttl = 0;
rr->rd.p = 0;
rr->rd.len = 0;
return 0;
}
if (P->end - p < 4)
goto invalid;
rr->ttl = ((0xff & P->data[p + 0]) << 24)
| ((0xff & P->data[p + 1]) << 16)
| ((0xff & P->data[p + 2]) << 8)
| ((0xff & P->data[p + 3]) << 0);
if (rr->type != DNS_T_OPT)
rr->ttl = DNS_PP_MIN(rr->ttl, 0x7fffffffU);
p += 4;
if (P->end - p < 2)
goto invalid;
rr->rd.len = ((0xff & P->data[p + 0]) << 8)
| ((0xff & P->data[p + 1]) << 0);
rr->rd.p = p + 2;
p += 2;
if (P->end - p < rr->rd.len)
goto invalid;
return 0;
invalid:
return DNS_EILLEGAL;
} /* dns_rr_parse() */
static unsigned short dns_rr_len(const unsigned short src, struct dns_packet *P) {
unsigned short rp, rdlen;
rp = dns_d_skip(src, P);
if (P->end - rp < 4)
return P->end - src;
rp += 4; /* TYPE, CLASS */
if (rp <= dns_p_qend(P))
return rp - src;
if (P->end - rp < 6)
return P->end - src;
rp += 6; /* TTL, RDLEN */
rdlen = ((0xff & P->data[rp - 2]) << 8)
| ((0xff & P->data[rp - 1]) << 0);
if (P->end - rp < rdlen)
return P->end - src;
rp += rdlen;
return rp - src;
} /* dns_rr_len() */
unsigned short dns_rr_skip(unsigned short src, struct dns_packet *P) {
return src + dns_rr_len(src, P);
} /* dns_rr_skip() */
static enum dns_section dns_rr_section(unsigned short src, struct dns_packet *P) {
enum dns_section section;
unsigned count, index;
unsigned short rp;
if (src >= P->memo.qd.base && src < P->memo.qd.end)
return DNS_S_QD;
if (src >= P->memo.an.base && src < P->memo.an.end)
return DNS_S_AN;
if (src >= P->memo.ns.base && src < P->memo.ns.end)
return DNS_S_NS;
if (src >= P->memo.ar.base && src < P->memo.ar.end)
return DNS_S_AR;
/* NOTE: Possibly bad memoization. Try it the hard-way. */
for (rp = 12, index = 0; rp < src && rp < P->end; index++)
rp = dns_rr_skip(rp, P);
section = DNS_S_QD;
count = dns_p_count(P, section);
while (index >= count && section <= DNS_S_AR) {
section <<= 1;
count += dns_p_count(P, section);
}
return DNS_S_ALL & section;
} /* dns_rr_section() */
static enum dns_type dns_rr_type(unsigned short src, struct dns_packet *P) {
struct dns_rr rr;
int error;
if ((error = dns_rr_parse(&rr, src, P)))
return 0;
return rr.type;
} /* dns_rr_type() */
int dns_rr_cmp(struct dns_rr *r0, struct dns_packet *P0, struct dns_rr *r1, struct dns_packet *P1) {
char host0[DNS_D_MAXNAME + 1], host1[DNS_D_MAXNAME + 1];
union dns_any any0, any1;
int cmp, error;
size_t len;
if ((cmp = r0->type - r1->type))
return cmp;
if ((cmp = r0->class - r1->class))
return cmp;
/*
* FIXME: Do label-by-label comparison to handle illegally long names?
*/
if (!(len = dns_d_expand(host0, sizeof host0, r0->dn.p, P0, &error))
|| len >= sizeof host0)
return -1;
if (!(len = dns_d_expand(host1, sizeof host1, r1->dn.p, P1, &error))
|| len >= sizeof host1)
return 1;
if ((cmp = strcasecmp(host0, host1)))
return cmp;
if (DNS_S_QD & (r0->section | r1->section)) {
if (r0->section == r1->section)
return 0;
return (r0->section == DNS_S_QD)? -1 : 1;
}
if ((error = dns_any_parse(&any0, r0, P0)))
return -1;
if ((error = dns_any_parse(&any1, r1, P1)))
return 1;
return dns_any_cmp(&any0, r0->type, &any1, r1->type);
} /* dns_rr_cmp() */
static _Bool dns_rr_exists(struct dns_rr *rr0, struct dns_packet *P0, struct dns_packet *P1) {
struct dns_rr rr1;
dns_rr_foreach(&rr1, P1, .section = rr0->section, .type = rr0->type) {
if (0 == dns_rr_cmp(rr0, P0, &rr1, P1))
return 1;
}
return 0;
} /* dns_rr_exists() */
static unsigned short dns_rr_offset(struct dns_rr *rr) {
return rr->dn.p;
} /* dns_rr_offset() */
static _Bool dns_rr_i_match(struct dns_rr *rr, struct dns_rr_i *i, struct dns_packet *P) {
if (i->section && !(rr->section & i->section))
return 0;
if (i->type && rr->type != i->type && i->type != DNS_T_ALL)
return 0;
if (i->class && rr->class != i->class && i->class != DNS_C_ANY)
return 0;
if (i->name) {
char dn[DNS_D_MAXNAME + 1];
size_t len;
int error;
if (!(len = dns_d_expand(dn, sizeof dn, rr->dn.p, P, &error))
|| len >= sizeof dn)
return 0;
if (0 != strcasecmp(dn, i->name))
return 0;
}
if (i->data && i->type && rr->section > DNS_S_QD) {
union dns_any rd;
int error;
if ((error = dns_any_parse(&rd, rr, P)))
return 0;
if (0 != dns_any_cmp(&rd, rr->type, i->data, i->type))
return 0;
}
return 1;
} /* dns_rr_i_match() */
static unsigned short dns_rr_i_start(struct dns_rr_i *i, struct dns_packet *P) {
unsigned short rp;
struct dns_rr r0, rr;
int error;
if ((i->section & DNS_S_QD) && P->memo.qd.base)
rp = P->memo.qd.base;
else if ((i->section & DNS_S_AN) && P->memo.an.base)
rp = P->memo.an.base;
else if ((i->section & DNS_S_NS) && P->memo.ns.base)
rp = P->memo.ns.base;
else if ((i->section & DNS_S_AR) && P->memo.ar.base)
rp = P->memo.ar.base;
else
rp = 12;
for (; rp < P->end; rp = dns_rr_skip(rp, P)) {
if ((error = dns_rr_parse(&rr, rp, P)))
continue;
rr.section = dns_rr_section(rp, P);
if (!dns_rr_i_match(&rr, i, P))
continue;
r0 = rr;
goto lower;
}
return P->end;
lower:
if (i->sort == &dns_rr_i_packet)
return dns_rr_offset(&r0);
while ((rp = dns_rr_skip(rp, P)) < P->end) {
if ((error = dns_rr_parse(&rr, rp, P)))
continue;
rr.section = dns_rr_section(rp, P);
if (!dns_rr_i_match(&rr, i, P))
continue;
if (i->sort(&rr, &r0, i, P) < 0)
r0 = rr;
}
return dns_rr_offset(&r0);
} /* dns_rr_i_start() */
static unsigned short dns_rr_i_skip(unsigned short rp, struct dns_rr_i *i, struct dns_packet *P) {
struct dns_rr r0, r1, rr;
int error;
if ((error = dns_rr_parse(&r0, rp, P)))
return P->end;
r0.section = dns_rr_section(rp, P);
rp = (i->sort == &dns_rr_i_packet)? dns_rr_skip(rp, P) : 12;
for (; rp < P->end; rp = dns_rr_skip(rp, P)) {
if ((error = dns_rr_parse(&rr, rp, P)))
continue;
rr.section = dns_rr_section(rp, P);
if (!dns_rr_i_match(&rr, i, P))
continue;
if (i->sort(&rr, &r0, i, P) <= 0)
continue;
r1 = rr;
goto lower;
}
return P->end;
lower:
if (i->sort == &dns_rr_i_packet)
return dns_rr_offset(&r1);
while ((rp = dns_rr_skip(rp, P)) < P->end) {
if ((error = dns_rr_parse(&rr, rp, P)))
continue;
rr.section = dns_rr_section(rp, P);
if (!dns_rr_i_match(&rr, i, P))
continue;
if (i->sort(&rr, &r0, i, P) <= 0)
continue;
if (i->sort(&rr, &r1, i, P) >= 0)
continue;
r1 = rr;
}
return dns_rr_offset(&r1);
} /* dns_rr_i_skip() */
int dns_rr_i_packet(struct dns_rr *a, struct dns_rr *b, struct dns_rr_i *i, struct dns_packet *P) {
(void)i;
(void)P;
return (int)a->dn.p - (int)b->dn.p;
} /* dns_rr_i_packet() */
int dns_rr_i_order(struct dns_rr *a, struct dns_rr *b, struct dns_rr_i *i, struct dns_packet *P) {
int cmp;
(void)i;
if ((cmp = a->section - b->section))
return cmp;
if (a->type != b->type)
return (int)a->dn.p - (int)b->dn.p;
return dns_rr_cmp(a, P, b, P);
} /* dns_rr_i_order() */
int dns_rr_i_shuffle(struct dns_rr *a, struct dns_rr *b, struct dns_rr_i *i, struct dns_packet *P) {
int cmp;
(void)i;
(void)P;
while (!i->state.regs[0])
i->state.regs[0] = dns_random();
if ((cmp = a->section - b->section))
return cmp;
return dns_k_shuffle16(a->dn.p, i->state.regs[0]) - dns_k_shuffle16(b->dn.p, i->state.regs[0]);
} /* dns_rr_i_shuffle() */
struct dns_rr_i *dns_rr_i_init(struct dns_rr_i *i, struct dns_packet *P) {
static const struct dns_rr_i i_initializer;
(void)P;
i->state = i_initializer.state;
i->saved = i->state;
return i;
} /* dns_rr_i_init() */
unsigned dns_rr_grep(struct dns_rr *rr, unsigned lim, struct dns_rr_i *i, struct dns_packet *P, int *error_) {
unsigned count = 0;
int error;
switch (i->state.exec) {
case 0:
if (!i->sort)
i->sort = &dns_rr_i_packet;
i->state.next = dns_rr_i_start(i, P);
i->state.exec++;
/* FALL THROUGH */
case 1:
while (count < lim && i->state.next < P->end) {
if ((error = dns_rr_parse(rr, i->state.next, P)))
goto error;
rr->section = dns_rr_section(i->state.next, P);
rr++;
count++;
i->state.count++;
i->state.next = dns_rr_i_skip(i->state.next, i, P);
} /* while() */
break;
} /* switch() */
return count;
error:
*error_ = error;
return count;
} /* dns_rr_grep() */
size_t dns_rr_print(void *_dst, size_t lim, struct dns_rr *rr, struct dns_packet *P, int *_error) {
struct dns_buf dst = DNS_B_INTO(_dst, lim);
union dns_any any;
size_t n;
int error;
if (rr->section == DNS_S_QD)
dns_b_putc(&dst, ';');
if (!(n = dns_d_expand(any.ns.host, sizeof any.ns.host, rr->dn.p, P, &error)))
goto error;
dns_b_put(&dst, any.ns.host, DNS_PP_MIN(n, sizeof any.ns.host - 1));
if (rr->section != DNS_S_QD) {
dns_b_putc(&dst, ' ');
dns_b_fmtju(&dst, rr->ttl, 0);
}
dns_b_putc(&dst, ' ');
dns_b_puts(&dst, dns_strclass(rr->class));
dns_b_putc(&dst, ' ');
dns_b_puts(&dst, dns_strtype(rr->type));
if (rr->section == DNS_S_QD)
goto epilog;
dns_b_putc(&dst, ' ');
if ((error = dns_any_parse(dns_any_init(&any, sizeof any), rr, P)))
goto error;
n = dns_any_print(dst.p, dst.pe - dst.p, &any, rr->type);
dst.p += DNS_PP_MIN(n, (size_t)(dst.pe - dst.p));
epilog:
return dns_b_strllen(&dst);
error:
*_error = error;
return 0;
} /* dns_rr_print() */
int dns_a_parse(struct dns_a *a, struct dns_rr *rr, struct dns_packet *P) {
unsigned long addr;
if (rr->rd.len != 4)
return DNS_EILLEGAL;
addr = ((0xffU & P->data[rr->rd.p + 0]) << 24)
| ((0xffU & P->data[rr->rd.p + 1]) << 16)
| ((0xffU & P->data[rr->rd.p + 2]) << 8)
| ((0xffU & P->data[rr->rd.p + 3]) << 0);
a->addr.s_addr = htonl(addr);
return 0;
} /* dns_a_parse() */
int dns_a_push(struct dns_packet *P, struct dns_a *a) {
unsigned long addr;
if (P->size - P->end < 6)
return DNS_ENOBUFS;
P->data[P->end++] = 0x00;
P->data[P->end++] = 0x04;
addr = ntohl(a->addr.s_addr);
P->data[P->end++] = 0xffU & (addr >> 24);
P->data[P->end++] = 0xffU & (addr >> 16);
P->data[P->end++] = 0xffU & (addr >> 8);
P->data[P->end++] = 0xffU & (addr >> 0);
return 0;
} /* dns_a_push() */
size_t dns_a_arpa(void *_dst, size_t lim, const struct dns_a *a) {
struct dns_buf dst = DNS_B_INTO(_dst, lim);
unsigned long octets = ntohl(a->addr.s_addr);
unsigned i;
for (i = 0; i < 4; i++) {
dns_b_fmtju(&dst, 0xff & octets, 0);
dns_b_putc(&dst, '.');
octets >>= 8;
}
dns_b_puts(&dst, "in-addr.arpa.");
return dns_b_strllen(&dst);
} /* dns_a_arpa() */
int dns_a_cmp(const struct dns_a *a, const struct dns_a *b) {
if (ntohl(a->addr.s_addr) < ntohl(b->addr.s_addr))
return -1;
if (ntohl(a->addr.s_addr) > ntohl(b->addr.s_addr))
return 1;
return 0;
} /* dns_a_cmp() */
size_t dns_a_print(void *dst, size_t lim, struct dns_a *a) {
char addr[INET_ADDRSTRLEN + 1] = "0.0.0.0";
dns_inet_ntop(AF_INET, &a->addr, addr, sizeof addr);
return dns_strlcpy(dst, addr, lim);
} /* dns_a_print() */
int dns_aaaa_parse(struct dns_aaaa *aaaa, struct dns_rr *rr, struct dns_packet *P) {
if (rr->rd.len != sizeof aaaa->addr.s6_addr)
return DNS_EILLEGAL;
memcpy(aaaa->addr.s6_addr, &P->data[rr->rd.p], sizeof aaaa->addr.s6_addr);
return 0;
} /* dns_aaaa_parse() */
int dns_aaaa_push(struct dns_packet *P, struct dns_aaaa *aaaa) {
if (P->size - P->end < 2 + sizeof aaaa->addr.s6_addr)
return DNS_ENOBUFS;
P->data[P->end++] = 0x00;
P->data[P->end++] = 0x10;
memcpy(&P->data[P->end], aaaa->addr.s6_addr, sizeof aaaa->addr.s6_addr);
P->end += sizeof aaaa->addr.s6_addr;
return 0;
} /* dns_aaaa_push() */
int dns_aaaa_cmp(const struct dns_aaaa *a, const struct dns_aaaa *b) {
unsigned i;
int cmp;
for (i = 0; i < lengthof(a->addr.s6_addr); i++) {
if ((cmp = (a->addr.s6_addr[i] - b->addr.s6_addr[i])))
return cmp;
}
return 0;
} /* dns_aaaa_cmp() */
size_t dns_aaaa_arpa(void *_dst, size_t lim, const struct dns_aaaa *aaaa) {
static const unsigned char hex[16] = "0123456789abcdef";
struct dns_buf dst = DNS_B_INTO(_dst, lim);
unsigned nyble;
int i, j;
for (i = sizeof aaaa->addr.s6_addr - 1; i >= 0; i--) {
nyble = aaaa->addr.s6_addr[i];
for (j = 0; j < 2; j++) {
dns_b_putc(&dst, hex[0x0f & nyble]);
dns_b_putc(&dst, '.');
nyble >>= 4;
}
}
dns_b_puts(&dst, "ip6.arpa.");
return dns_b_strllen(&dst);
} /* dns_aaaa_arpa() */
size_t dns_aaaa_print(void *dst, size_t lim, struct dns_aaaa *aaaa) {
char addr[INET6_ADDRSTRLEN + 1] = "::";
dns_inet_ntop(AF_INET6, &aaaa->addr, addr, sizeof addr);
return dns_strlcpy(dst, addr, lim);
} /* dns_aaaa_print() */
int dns_mx_parse(struct dns_mx *mx, struct dns_rr *rr, struct dns_packet *P) {
size_t len;
int error;
if (rr->rd.len < 3)
return DNS_EILLEGAL;
mx->preference = (0xff00 & (P->data[rr->rd.p + 0] << 8))
| (0x00ff & (P->data[rr->rd.p + 1] << 0));
if (!(len = dns_d_expand(mx->host, sizeof mx->host, rr->rd.p + 2, P, &error)))
return error;
else if (len >= sizeof mx->host)
return DNS_EILLEGAL;
return 0;
} /* dns_mx_parse() */
int dns_mx_push(struct dns_packet *P, struct dns_mx *mx) {
size_t end, len;
int error;
if (P->size - P->end < 5)
return DNS_ENOBUFS;
end = P->end;
P->end += 2;
P->data[P->end++] = 0xff & (mx->preference >> 8);
P->data[P->end++] = 0xff & (mx->preference >> 0);
if ((error = dns_d_push(P, mx->host, strlen(mx->host))))
goto error;
len = P->end - end - 2;
P->data[end + 0] = 0xff & (len >> 8);
P->data[end + 1] = 0xff & (len >> 0);
return 0;
error:
P->end = end;
return error;
} /* dns_mx_push() */
int dns_mx_cmp(const struct dns_mx *a, const struct dns_mx *b) {
int cmp;
if ((cmp = a->preference - b->preference))
return cmp;
return strcasecmp(a->host, b->host);
} /* dns_mx_cmp() */
size_t dns_mx_print(void *_dst, size_t lim, struct dns_mx *mx) {
struct dns_buf dst = DNS_B_INTO(_dst, lim);
dns_b_fmtju(&dst, mx->preference, 0);
dns_b_putc(&dst, ' ');
dns_b_puts(&dst, mx->host);
return dns_b_strllen(&dst);
} /* dns_mx_print() */
size_t dns_mx_cname(void *dst, size_t lim, struct dns_mx *mx) {
return dns_strlcpy(dst, mx->host, lim);
} /* dns_mx_cname() */
int dns_ns_parse(struct dns_ns *ns, struct dns_rr *rr, struct dns_packet *P) {
size_t len;
int error;
if (!(len = dns_d_expand(ns->host, sizeof ns->host, rr->rd.p, P, &error)))
return error;
else if (len >= sizeof ns->host)
return DNS_EILLEGAL;
return 0;
} /* dns_ns_parse() */
int dns_ns_push(struct dns_packet *P, struct dns_ns *ns) {
size_t end, len;
int error;
if (P->size - P->end < 3)
return DNS_ENOBUFS;
end = P->end;
P->end += 2;
if ((error = dns_d_push(P, ns->host, strlen(ns->host))))
goto error;
len = P->end - end - 2;
P->data[end + 0] = 0xff & (len >> 8);
P->data[end + 1] = 0xff & (len >> 0);
return 0;
error:
P->end = end;
return error;
} /* dns_ns_push() */
int dns_ns_cmp(const struct dns_ns *a, const struct dns_ns *b) {
return strcasecmp(a->host, b->host);
} /* dns_ns_cmp() */
size_t dns_ns_print(void *dst, size_t lim, struct dns_ns *ns) {
return dns_strlcpy(dst, ns->host, lim);
} /* dns_ns_print() */
size_t dns_ns_cname(void *dst, size_t lim, struct dns_ns *ns) {
return dns_strlcpy(dst, ns->host, lim);
} /* dns_ns_cname() */
int dns_cname_parse(struct dns_cname *cname, struct dns_rr *rr, struct dns_packet *P) {
return dns_ns_parse((struct dns_ns *)cname, rr, P);
} /* dns_cname_parse() */
int dns_cname_push(struct dns_packet *P, struct dns_cname *cname) {
return dns_ns_push(P, (struct dns_ns *)cname);
} /* dns_cname_push() */
int dns_cname_cmp(const struct dns_cname *a, const struct dns_cname *b) {
return strcasecmp(a->host, b->host);
} /* dns_cname_cmp() */
size_t dns_cname_print(void *dst, size_t lim, struct dns_cname *cname) {
return dns_ns_print(dst, lim, (struct dns_ns *)cname);
} /* dns_cname_print() */
size_t dns_cname_cname(void *dst, size_t lim, struct dns_cname *cname) {
return dns_strlcpy(dst, cname->host, lim);
} /* dns_cname_cname() */
int dns_soa_parse(struct dns_soa *soa, struct dns_rr *rr, struct dns_packet *P) {
struct { void *dst; size_t lim; } dn[] =
{ { soa->mname, sizeof soa->mname },
{ soa->rname, sizeof soa->rname } };
unsigned *ts[] =
{ &soa->serial, &soa->refresh, &soa->retry, &soa->expire, &soa->minimum };
unsigned short rp;
unsigned i, j, n;
int error;
/* MNAME / RNAME */
if ((rp = rr->rd.p) >= P->end)
return DNS_EILLEGAL;
for (i = 0; i < lengthof(dn); i++) {
if (!(n = dns_d_expand(dn[i].dst, dn[i].lim, rp, P, &error)))
return error;
else if (n >= dn[i].lim)
return DNS_EILLEGAL;
if ((rp = dns_d_skip(rp, P)) >= P->end)
return DNS_EILLEGAL;
}
/* SERIAL / REFRESH / RETRY / EXPIRE / MINIMUM */
for (i = 0; i < lengthof(ts); i++) {
for (j = 0; j < 4; j++, rp++) {
if (rp >= P->end)
return DNS_EILLEGAL;
*ts[i] <<= 8;
*ts[i] |= (0xff & P->data[rp]);
}
}
return 0;
} /* dns_soa_parse() */
int dns_soa_push(struct dns_packet *P, struct dns_soa *soa) {
void *dn[] = { soa->mname, soa->rname };
unsigned ts[] = { (0xffffffff & soa->serial),
(0x7fffffff & soa->refresh),
(0x7fffffff & soa->retry),
(0x7fffffff & soa->expire),
(0xffffffff & soa->minimum) };
unsigned i, j;
size_t end, len;
int error;
end = P->end;
if ((P->end += 2) >= P->size)
goto toolong;
/* MNAME / RNAME */
for (i = 0; i < lengthof(dn); i++) {
if ((error = dns_d_push(P, dn[i], strlen(dn[i]))))
goto error;
}
/* SERIAL / REFRESH / RETRY / EXPIRE / MINIMUM */
for (i = 0; i < lengthof(ts); i++) {
if ((P->end += 4) >= P->size)
goto toolong;
for (j = 1; j <= 4; j++) {
P->data[P->end - j] = (0xff & ts[i]);
ts[i] >>= 8;
}
}
len = P->end - end - 2;
P->data[end + 0] = (0xff & (len >> 8));
P->data[end + 1] = (0xff & (len >> 0));
return 0;
toolong:
error = DNS_ENOBUFS;
/* FALL THROUGH */
error:
P->end = end;
return error;
} /* dns_soa_push() */
int dns_soa_cmp(const struct dns_soa *a, const struct dns_soa *b) {
int cmp;
if ((cmp = strcasecmp(a->mname, b->mname)))
return cmp;
if ((cmp = strcasecmp(a->rname, b->rname)))
return cmp;
if (a->serial > b->serial)
return -1;
else if (a->serial < b->serial)
return 1;
if (a->refresh > b->refresh)
return -1;
else if (a->refresh < b->refresh)
return 1;
if (a->retry > b->retry)
return -1;
else if (a->retry < b->retry)
return 1;
if (a->expire > b->expire)
return -1;
else if (a->expire < b->expire)
return 1;
if (a->minimum > b->minimum)
return -1;
else if (a->minimum < b->minimum)
return 1;
return 0;
} /* dns_soa_cmp() */
size_t dns_soa_print(void *_dst, size_t lim, struct dns_soa *soa) {
struct dns_buf dst = DNS_B_INTO(_dst, lim);
dns_b_puts(&dst, soa->mname);
dns_b_putc(&dst, ' ');
dns_b_puts(&dst, soa->rname);
dns_b_putc(&dst, ' ');
dns_b_fmtju(&dst, soa->serial, 0);
dns_b_putc(&dst, ' ');
dns_b_fmtju(&dst, soa->refresh, 0);
dns_b_putc(&dst, ' ');
dns_b_fmtju(&dst, soa->retry, 0);
dns_b_putc(&dst, ' ');
dns_b_fmtju(&dst, soa->expire, 0);
dns_b_putc(&dst, ' ');
dns_b_fmtju(&dst, soa->minimum, 0);
return dns_b_strllen(&dst);
} /* dns_soa_print() */
int dns_srv_parse(struct dns_srv *srv, struct dns_rr *rr, struct dns_packet *P) {
unsigned short rp;
unsigned i;
size_t n;
int error;
memset(srv, '\0', sizeof *srv);
rp = rr->rd.p;
if (rr->rd.len < 7)
return DNS_EILLEGAL;
for (i = 0; i < 2; i++, rp++) {
srv->priority <<= 8;
srv->priority |= (0xff & P->data[rp]);
}
for (i = 0; i < 2; i++, rp++) {
srv->weight <<= 8;
srv->weight |= (0xff & P->data[rp]);
}
for (i = 0; i < 2; i++, rp++) {
srv->port <<= 8;
srv->port |= (0xff & P->data[rp]);
}
if (!(n = dns_d_expand(srv->target, sizeof srv->target, rp, P, &error)))
return error;
else if (n >= sizeof srv->target)
return DNS_EILLEGAL;
return 0;
} /* dns_srv_parse() */
int dns_srv_push(struct dns_packet *P, struct dns_srv *srv) {
size_t end, len;
int error;
end = P->end;
if (P->size - P->end < 2)
goto toolong;
P->end += 2;
if (P->size - P->end < 6)
goto toolong;
P->data[P->end++] = 0xff & (srv->priority >> 8);
P->data[P->end++] = 0xff & (srv->priority >> 0);
P->data[P->end++] = 0xff & (srv->weight >> 8);
P->data[P->end++] = 0xff & (srv->weight >> 0);
P->data[P->end++] = 0xff & (srv->port >> 8);
P->data[P->end++] = 0xff & (srv->port >> 0);
if (0 == (len = dns_d_comp(&P->data[P->end], P->size - P->end, srv->target, strlen(srv->target), P, &error)))
goto error;
else if (P->size - P->end < len)
goto toolong;
P->end += len;
if (P->end > 65535)
goto toolong;
len = P->end - end - 2;
P->data[end + 0] = 0xff & (len >> 8);
P->data[end + 1] = 0xff & (len >> 0);
return 0;
toolong:
error = DNS_ENOBUFS;
/* FALL THROUGH */
error:
P->end = end;
return error;
} /* dns_srv_push() */
int dns_srv_cmp(const struct dns_srv *a, const struct dns_srv *b) {
int cmp;
if ((cmp = a->priority - b->priority))
return cmp;
/*
* FIXME: We need some sort of random seed to implement the dynamic
* weighting required by RFC 2782.
*/
if ((cmp = a->weight - b->weight))
return cmp;
if ((cmp = a->port - b->port))
return cmp;
return strcasecmp(a->target, b->target);
} /* dns_srv_cmp() */
size_t dns_srv_print(void *_dst, size_t lim, struct dns_srv *srv) {
struct dns_buf dst = DNS_B_INTO(_dst, lim);
dns_b_fmtju(&dst, srv->priority, 0);
dns_b_putc(&dst, ' ');
dns_b_fmtju(&dst, srv->weight, 0);
dns_b_putc(&dst, ' ');
dns_b_fmtju(&dst, srv->port, 0);
dns_b_putc(&dst, ' ');
dns_b_puts(&dst, srv->target);
return dns_b_strllen(&dst);
} /* dns_srv_print() */
size_t dns_srv_cname(void *dst, size_t lim, struct dns_srv *srv) {
return dns_strlcpy(dst, srv->target, lim);
} /* dns_srv_cname() */
unsigned int dns_opt_ttl(const struct dns_opt *opt) {
unsigned int ttl = 0;
ttl |= (0xffU & opt->rcode) << 24;
ttl |= (0xffU & opt->version) << 16;
ttl |= (0xffffU & opt->flags) << 0;
return ttl;
} /* dns_opt_ttl() */
unsigned short dns_opt_class(const struct dns_opt *opt) {
return opt->maxudp;
} /* dns_opt_class() */
struct dns_opt *dns_opt_init(struct dns_opt *opt, size_t size) {
assert(size >= offsetof(struct dns_opt, data));
opt->size = size - offsetof(struct dns_opt, data);
opt->len = 0;
opt->rcode = 0;
opt->version = 0;
opt->maxudp = 0;
return opt;
} /* dns_opt_init() */
static union dns_any *dns_opt_initany(union dns_any *any, size_t size) {
return dns_opt_init(&any->opt, size), any;
} /* dns_opt_initany() */
int dns_opt_parse(struct dns_opt *opt, struct dns_rr *rr, struct dns_packet *P) {
const struct dns_buf src = DNS_B_FROM(&P->data[rr->rd.p], rr->rd.len);
struct dns_buf dst = DNS_B_INTO(opt->data, opt->size);
int error;
opt->rcode = 0xfff & ((rr->ttl >> 20) | dns_header(P)->rcode);
opt->version = 0xff & (rr->ttl >> 16);
opt->flags = 0xffff & rr->ttl;
opt->maxudp = 0xffff & rr->class;
while (src.p < src.pe) {
int code, len;
if (-1 == (code = dns_b_get16(&src, -1)))
return src.error;
if (-1 == (len = dns_b_get16(&src, -1)))
return src.error;
switch (code) {
default:
dns_b_put16(&dst, code);
dns_b_put16(&dst, len);
if ((error = dns_b_move(&dst, &src, len)))
return error;
break;
}
}
return 0;
} /* dns_opt_parse() */
int dns_opt_push(struct dns_packet *P, struct dns_opt *opt) {
const struct dns_buf src = DNS_B_FROM(opt->data, opt->len);
struct dns_buf dst = DNS_B_INTO(&P->data[P->end], (P->size - P->end));
int error;
/* rdata length (see below) */
if ((error = dns_b_put16(&dst, 0)))
goto error;
/* ... push known options here */
/* push opaque option data */
if ((error = dns_b_move(&dst, &src, (size_t)(src.pe - src.p))))
goto error;
/* rdata length */
if ((error = dns_b_pput16(&dst, dns_b_tell(&dst) - 2, 0)))
goto error;
#if !DNS_DEBUG_OPT_FORMERR
P->end += dns_b_tell(&dst);
#endif
return 0;
error:
return error;
} /* dns_opt_push() */
int dns_opt_cmp(const struct dns_opt *a, const struct dns_opt *b) {
(void)a;
(void)b;
return -1;
} /* dns_opt_cmp() */
size_t dns_opt_print(void *_dst, size_t lim, struct dns_opt *opt) {
struct dns_buf dst = DNS_B_INTO(_dst, lim);
size_t p;
dns_b_putc(&dst, '"');
for (p = 0; p < opt->len; p++) {
dns_b_putc(&dst, '\\');
dns_b_fmtju(&dst, opt->data[p], 3);
}
dns_b_putc(&dst, '"');
return dns_b_strllen(&dst);
} /* dns_opt_print() */
int dns_ptr_parse(struct dns_ptr *ptr, struct dns_rr *rr, struct dns_packet *P) {
return dns_ns_parse((struct dns_ns *)ptr, rr, P);
} /* dns_ptr_parse() */
int dns_ptr_push(struct dns_packet *P, struct dns_ptr *ptr) {
return dns_ns_push(P, (struct dns_ns *)ptr);
} /* dns_ptr_push() */
size_t dns_ptr_qname(void *dst, size_t lim, int af, void *addr) {
switch (af) {
case AF_INET6:
return dns_aaaa_arpa(dst, lim, addr);
case AF_INET:
return dns_a_arpa(dst, lim, addr);
default:
return dns_a_arpa(dst, lim, &(struct dns_a){ { INADDR_NONE } });
}
} /* dns_ptr_qname() */
int dns_ptr_cmp(const struct dns_ptr *a, const struct dns_ptr *b) {
return strcasecmp(a->host, b->host);
} /* dns_ptr_cmp() */
size_t dns_ptr_print(void *dst, size_t lim, struct dns_ptr *ptr) {
return dns_ns_print(dst, lim, (struct dns_ns *)ptr);
} /* dns_ptr_print() */
size_t dns_ptr_cname(void *dst, size_t lim, struct dns_ptr *ptr) {
return dns_strlcpy(dst, ptr->host, lim);
} /* dns_ptr_cname() */
int dns_sshfp_parse(struct dns_sshfp *fp, struct dns_rr *rr, struct dns_packet *P) {
unsigned p = rr->rd.p, pe = rr->rd.p + rr->rd.len;
if (pe - p < 2)
return DNS_EILLEGAL;
fp->algo = P->data[p++];
fp->type = P->data[p++];
switch (fp->type) {
case DNS_SSHFP_SHA1:
if (pe - p < sizeof fp->digest.sha1)
return DNS_EILLEGAL;
memcpy(fp->digest.sha1, &P->data[p], sizeof fp->digest.sha1);
break;
default:
break;
} /* switch() */
return 0;
} /* dns_sshfp_parse() */
int dns_sshfp_push(struct dns_packet *P, struct dns_sshfp *fp) {
unsigned p = P->end, pe = P->size, n;
if (pe - p < 4)
return DNS_ENOBUFS;
p += 2;
P->data[p++] = 0xff & fp->algo;
P->data[p++] = 0xff & fp->type;
switch (fp->type) {
case DNS_SSHFP_SHA1:
if (pe - p < sizeof fp->digest.sha1)
return DNS_ENOBUFS;
memcpy(&P->data[p], fp->digest.sha1, sizeof fp->digest.sha1);
p += sizeof fp->digest.sha1;
break;
default:
return DNS_EILLEGAL;
} /* switch() */
n = p - P->end - 2;
P->data[P->end++] = 0xff & (n >> 8);
P->data[P->end++] = 0xff & (n >> 0);
P->end = p;
return 0;
} /* dns_sshfp_push() */
int dns_sshfp_cmp(const struct dns_sshfp *a, const struct dns_sshfp *b) {
int cmp;
if ((cmp = a->algo - b->algo) || (cmp = a->type - b->type))
return cmp;
switch (a->type) {
case DNS_SSHFP_SHA1:
return memcmp(a->digest.sha1, b->digest.sha1, sizeof a->digest.sha1);
default:
return 0;
} /* switch() */
/* NOT REACHED */
} /* dns_sshfp_cmp() */
size_t dns_sshfp_print(void *_dst, size_t lim, struct dns_sshfp *fp) {
static const unsigned char hex[16] = "0123456789abcdef";
struct dns_buf dst = DNS_B_INTO(_dst, lim);
size_t i;
dns_b_fmtju(&dst, fp->algo, 0);
dns_b_putc(&dst, ' ');
dns_b_fmtju(&dst, fp->type, 0);
dns_b_putc(&dst, ' ');
switch (fp->type) {
case DNS_SSHFP_SHA1:
for (i = 0; i < sizeof fp->digest.sha1; i++) {
dns_b_putc(&dst, hex[0x0f & (fp->digest.sha1[i] >> 4)]);
dns_b_putc(&dst, hex[0x0f & (fp->digest.sha1[i] >> 0)]);
}
break;
default:
dns_b_putc(&dst, '0');
break;
} /* switch() */
return dns_b_strllen(&dst);
} /* dns_sshfp_print() */
struct dns_txt *dns_txt_init(struct dns_txt *txt, size_t size) {
assert(size > offsetof(struct dns_txt, data));
txt->size = size - offsetof(struct dns_txt, data);
txt->len = 0;
return txt;
} /* dns_txt_init() */
static union dns_any *dns_txt_initany(union dns_any *any, size_t size) {
/* NB: union dns_any is already initialized as struct dns_txt */
(void)size;
return any;
} /* dns_txt_initany() */
int dns_txt_parse(struct dns_txt *txt, struct dns_rr *rr, struct dns_packet *P) {
struct { unsigned char *b; size_t p, end; } dst, src;
unsigned n;
dst.b = txt->data;
dst.p = 0;
dst.end = txt->size;
src.b = P->data;
src.p = rr->rd.p;
src.end = src.p + rr->rd.len;
while (src.p < src.end) {
n = 0xff & P->data[src.p++];
if (src.end - src.p < n || dst.end - dst.p < n)
return DNS_EILLEGAL;
memcpy(&dst.b[dst.p], &src.b[src.p], n);
dst.p += n;
src.p += n;
}
txt->len = dst.p;
return 0;
} /* dns_txt_parse() */
int dns_txt_push(struct dns_packet *P, struct dns_txt *txt) {
struct { unsigned char *b; size_t p, end; } dst, src;
unsigned n;
dst.b = P->data;
dst.p = P->end;
dst.end = P->size;
src.b = txt->data;
src.p = 0;
src.end = txt->len;
if (dst.end - dst.p < 2)
return DNS_ENOBUFS;
n = txt->len + ((txt->len + 254) / 255);
dst.b[dst.p++] = 0xff & (n >> 8);
dst.b[dst.p++] = 0xff & (n >> 0);
while (src.p < src.end) {
n = DNS_PP_MIN(255, src.end - src.p);
if (dst.p >= dst.end)
return DNS_ENOBUFS;
dst.b[dst.p++] = n;
if (dst.end - dst.p < n)
return DNS_ENOBUFS;
memcpy(&dst.b[dst.p], &src.b[src.p], n);
dst.p += n;
src.p += n;
}
P->end = dst.p;
return 0;
} /* dns_txt_push() */
int dns_txt_cmp(const struct dns_txt *a, const struct dns_txt *b) {
(void)a;
(void)b;
return -1;
} /* dns_txt_cmp() */
size_t dns_txt_print(void *_dst, size_t lim, struct dns_txt *txt) {
struct dns_buf src = DNS_B_FROM(txt->data, txt->len);
struct dns_buf dst = DNS_B_INTO(_dst, lim);
unsigned i;
if (src.p < src.pe) {
do {
dns_b_putc(&dst, '"');
for (i = 0; i < 256 && src.p < src.pe; i++, src.p++) {
if (*src.p < 32 || *src.p > 126 || *src.p == '"' || *src.p == '\\') {
dns_b_putc(&dst, '\\');
dns_b_fmtju(&dst, *src.p, 3);
} else {
dns_b_putc(&dst, *src.p);
}
}
dns_b_putc(&dst, '"');
dns_b_putc(&dst, ' ');
} while (src.p < src.pe);
dns_b_popc(&dst);
} else {
dns_b_putc(&dst, '"');
dns_b_putc(&dst, '"');
}
return dns_b_strllen(&dst);
} /* dns_txt_print() */
static const struct dns_rrtype {
enum dns_type type;
const char *name;
union dns_any *(*init)(union dns_any *, size_t);
int (*parse)();
int (*push)();
int (*cmp)();
size_t (*print)();
size_t (*cname)();
} dns_rrtypes[] = {
{ DNS_T_A, "A", 0, &dns_a_parse, &dns_a_push, &dns_a_cmp, &dns_a_print, 0, },
{ DNS_T_AAAA, "AAAA", 0, &dns_aaaa_parse, &dns_aaaa_push, &dns_aaaa_cmp, &dns_aaaa_print, 0, },
{ DNS_T_MX, "MX", 0, &dns_mx_parse, &dns_mx_push, &dns_mx_cmp, &dns_mx_print, &dns_mx_cname, },
{ DNS_T_NS, "NS", 0, &dns_ns_parse, &dns_ns_push, &dns_ns_cmp, &dns_ns_print, &dns_ns_cname, },
{ DNS_T_CNAME, "CNAME", 0, &dns_cname_parse, &dns_cname_push, &dns_cname_cmp, &dns_cname_print, &dns_cname_cname, },
{ DNS_T_SOA, "SOA", 0, &dns_soa_parse, &dns_soa_push, &dns_soa_cmp, &dns_soa_print, 0, },
{ DNS_T_SRV, "SRV", 0, &dns_srv_parse, &dns_srv_push, &dns_srv_cmp, &dns_srv_print, &dns_srv_cname, },
{ DNS_T_OPT, "OPT", &dns_opt_initany, &dns_opt_parse, &dns_opt_push, &dns_opt_cmp, &dns_opt_print, 0, },
{ DNS_T_PTR, "PTR", 0, &dns_ptr_parse, &dns_ptr_push, &dns_ptr_cmp, &dns_ptr_print, &dns_ptr_cname, },
{ DNS_T_TXT, "TXT", &dns_txt_initany, &dns_txt_parse, &dns_txt_push, &dns_txt_cmp, &dns_txt_print, 0, },
{ DNS_T_SPF, "SPF", &dns_txt_initany, &dns_txt_parse, &dns_txt_push, &dns_txt_cmp, &dns_txt_print, 0, },
{ DNS_T_SSHFP, "SSHFP", 0, &dns_sshfp_parse, &dns_sshfp_push, &dns_sshfp_cmp, &dns_sshfp_print, 0, },
{ DNS_T_AXFR, "AXFR", 0, 0, 0, 0, 0, 0, },
}; /* dns_rrtypes[] */
static const struct dns_rrtype *dns_rrtype(enum dns_type type) {
const struct dns_rrtype *t;
for (t = dns_rrtypes; t < endof(dns_rrtypes); t++) {
if (t->type == type && t->parse) {
return t;
}
}
return NULL;
} /* dns_rrtype() */
union dns_any *dns_any_init(union dns_any *any, size_t size) {
dns_static_assert(dns_same_type(any->txt, any->rdata, 1), "unexpected rdata type");
return (union dns_any *)dns_txt_init(&any->rdata, size);
} /* dns_any_init() */
static size_t dns_any_sizeof(union dns_any *any) {
dns_static_assert(dns_same_type(any->txt, any->rdata, 1), "unexpected rdata type");
return offsetof(struct dns_txt, data) + any->rdata.size;
} /* dns_any_sizeof() */
static union dns_any *dns_any_reinit(union dns_any *any, const struct dns_rrtype *t) {
return (t->init)? t->init(any, dns_any_sizeof(any)) : any;
} /* dns_any_reinit() */
int dns_any_parse(union dns_any *any, struct dns_rr *rr, struct dns_packet *P) {
const struct dns_rrtype *t;
if ((t = dns_rrtype(rr->type)))
return t->parse(dns_any_reinit(any, t), rr, P);
if (rr->rd.len > any->rdata.size)
return DNS_EILLEGAL;
memcpy(any->rdata.data, &P->data[rr->rd.p], rr->rd.len);
any->rdata.len = rr->rd.len;
return 0;
} /* dns_any_parse() */
int dns_any_push(struct dns_packet *P, union dns_any *any, enum dns_type type) {
const struct dns_rrtype *t;
if ((t = dns_rrtype(type)))
return t->push(P, any);
if (P->size - P->end < any->rdata.len + 2)
return DNS_ENOBUFS;
P->data[P->end++] = 0xff & (any->rdata.len >> 8);
P->data[P->end++] = 0xff & (any->rdata.len >> 0);
memcpy(&P->data[P->end], any->rdata.data, any->rdata.len);
P->end += any->rdata.len;
return 0;
} /* dns_any_push() */
int dns_any_cmp(const union dns_any *a, enum dns_type x, const union dns_any *b, enum dns_type y) {
const struct dns_rrtype *t;
int cmp;
if ((cmp = x - y))
return cmp;
if ((t = dns_rrtype(x)))
return t->cmp(a, b);
return -1;
} /* dns_any_cmp() */
size_t dns_any_print(void *_dst, size_t lim, union dns_any *any, enum dns_type type) {
const struct dns_rrtype *t;
struct dns_buf src, dst;
if ((t = dns_rrtype(type)))
return t->print(_dst, lim, any);
dns_b_from(&src, any->rdata.data, any->rdata.len);
dns_b_into(&dst, _dst, lim);
dns_b_putc(&dst, '"');
while (src.p < src.pe) {
dns_b_putc(&dst, '\\');
dns_b_fmtju(&dst, *src.p++, 3);
}
dns_b_putc(&dst, '"');
return dns_b_strllen(&dst);
} /* dns_any_print() */
size_t dns_any_cname(void *dst, size_t lim, union dns_any *any, enum dns_type type) {
const struct dns_rrtype *t;
if ((t = dns_rrtype(type)) && t->cname)
return t->cname(dst, lim, any);
return 0;
} /* dns_any_cname() */
/*
* H O S T S R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct dns_hosts {
struct dns_hosts_entry {
char host[DNS_D_MAXNAME + 1];
char arpa[73 + 1];
int af;
union {
struct in_addr a4;
struct in6_addr a6;
} addr;
_Bool alias;
struct dns_hosts_entry *next;
} *head, **tail;
dns_atomic_t refcount;
}; /* struct dns_hosts */
struct dns_hosts *dns_hosts_open(int *error) {
static const struct dns_hosts hosts_initializer = { .refcount = 1 };
struct dns_hosts *hosts;
if (!(hosts = malloc(sizeof *hosts)))
goto syerr;
*hosts = hosts_initializer;
hosts->tail = &hosts->head;
return hosts;
syerr:
*error = dns_syerr();
free(hosts);
return 0;
} /* dns_hosts_open() */
void dns_hosts_close(struct dns_hosts *hosts) {
struct dns_hosts_entry *ent, *xnt;
if (!hosts || 1 != dns_hosts_release(hosts))
return;
for (ent = hosts->head; ent; ent = xnt) {
xnt = ent->next;
free(ent);
}
free(hosts);
return;
} /* dns_hosts_close() */
dns_refcount_t dns_hosts_acquire(struct dns_hosts *hosts) {
return dns_atomic_fetch_add(&hosts->refcount);
} /* dns_hosts_acquire() */
dns_refcount_t dns_hosts_release(struct dns_hosts *hosts) {
return dns_atomic_fetch_sub(&hosts->refcount);
} /* dns_hosts_release() */
struct dns_hosts *dns_hosts_mortal(struct dns_hosts *hosts) {
if (hosts)
dns_hosts_release(hosts);
return hosts;
} /* dns_hosts_mortal() */
#if defined(BELLE_SIP_WINDOWS_PHONE) || defined(BELLE_SIP_WINDOWS_UNIVERSAL)
static int dns_hosts_add_localhost(struct dns_hosts *hosts) {
struct dns_hosts_entry ent;
memset(&ent, '\0', sizeof(ent));
ent.af = AF_INET;
dns_inet_pton(ent.af, "127.0.0.1", &ent.addr);
dns_d_anchor(ent.host, sizeof(ent.host), "localhost", 9);
dns_hosts_insert(hosts, ent.af, &ent.addr, ent.host, 0);
memset(&ent, '\0', sizeof(ent));
ent.af = AF_INET6;
dns_inet_pton(ent.af, "::1", &ent.addr);
dns_d_anchor(ent.host, sizeof(ent.host), "localhost", 9);
dns_hosts_insert(hosts, ent.af, &ent.addr, ent.host, 1);
return 0;
}
#endif
struct dns_hosts *dns_hosts_local(int *error_) {
struct dns_hosts *hosts;
int error;
if (!(hosts = dns_hosts_open(&error)))
goto error;
#ifdef _WIN32
#if defined(BELLE_SIP_WINDOWS_PHONE) || defined(BELLE_SIP_WINDOWS_UNIVERSAL)
if ((error = dns_hosts_add_localhost(hosts)))
#else
if ((error = dns_hosts_loadpath(hosts, "C:/Windows/System32/drivers/etc/hosts")))
#endif
#else
if ((error = dns_hosts_loadpath(hosts, "/etc/hosts")))
#endif
goto error;
return hosts;
error:
*error_ = error;
dns_hosts_close(hosts);
return 0;
} /* dns_hosts_local() */
#define dns_hosts_issep(ch) (dns_isspace(ch))
#define dns_hosts_iscom(ch) ((ch) == '#' || (ch) == ';')
int dns_hosts_loadfile(struct dns_hosts *hosts, FILE *fp) {
struct dns_hosts_entry ent;
char word[DNS_PP_MAX(INET6_ADDRSTRLEN, DNS_D_MAXNAME) + 1];
unsigned wp, wc, skip;
int ch, error;
rewind(fp);
do {
memset(&ent, '\0', sizeof ent);
wc = 0;
skip = 0;
do {
memset(word, '\0', sizeof word);
wp = 0;
while (EOF != (ch = fgetc(fp)) && ch != '\n') {
skip |= !!dns_hosts_iscom(ch);
if (skip)
continue;
if (dns_hosts_issep(ch))
break;
if (wp < sizeof word - 1)
word[wp] = ch;
wp++;
}
if (!wp)
continue;
wc++;
switch (wc) {
case 0:
break;
case 1:
ent.af = (strchr(word, ':'))? AF_INET6 : AF_INET;
// Normalize some strange IPv4 addresses, eg. 127.1 --> 127.0.0.1
if (ent.af == AF_INET) {
int nbdots = 0;
char *p = word;
while ((p = strchr(p, '.')) != NULL) {
nbdots++;
p++;
}
if (nbdots == 1) {
p = strchr(word, '.');
p++;
memmove(p + 4, p, strlen(p));
memcpy(p, "0.0.", 4);
}
}
skip = (1 != dns_inet_pton(ent.af, word, &ent.addr));
break;
default:
if (!wp)
break;
dns_d_anchor(ent.host, sizeof ent.host, word, wp);
if ((error = dns_hosts_insert(hosts, ent.af, &ent.addr, ent.host, (wc > 2))))
return error;
break;
} /* switch() */
} while (ch != EOF && ch != '\n');
} while (ch != EOF);
return 0;
} /* dns_hosts_loadfile() */
int dns_hosts_loadpath(struct dns_hosts *hosts, const char *path) {
FILE *fp;
int error;
if (!(fp = dns_fopen(path, "rt", &error)))
return error;
error = dns_hosts_loadfile(hosts, fp);
fclose(fp);
return error;
} /* dns_hosts_loadpath() */
int dns_hosts_dump(struct dns_hosts *hosts, FILE *fp) {
struct dns_hosts_entry *ent, *xnt;
char addr[INET6_ADDRSTRLEN + 1];
unsigned i;
for (ent = hosts->head; ent; ent = xnt) {
xnt = ent->next;
dns_inet_ntop(ent->af, &ent->addr, addr, sizeof addr);
fputs(addr, fp);
for (i = strlen(addr); i < INET_ADDRSTRLEN; i++)
fputc(' ', fp);
fputc(' ', fp);
fputs(ent->host, fp);
fputc('\n', fp);
}
return 0;
} /* dns_hosts_dump() */
int dns_hosts_insert(struct dns_hosts *hosts, int af, const void *addr, const void *host, _Bool alias) {
struct dns_hosts_entry *ent;
int error;
if (!(ent = malloc(sizeof *ent)))
goto syerr;
dns_d_anchor(ent->host, sizeof ent->host, host, strlen(host));
switch ((ent->af = af)) {
case AF_INET6:
memcpy(&ent->addr.a6, addr, sizeof ent->addr.a6);
dns_aaaa_arpa(ent->arpa, sizeof ent->arpa, addr);
break;
case AF_INET:
memcpy(&ent->addr.a4, addr, sizeof ent->addr.a4);
dns_a_arpa(ent->arpa, sizeof ent->arpa, addr);
break;
default:
error = EINVAL;
goto error;
} /* switch() */
ent->alias = alias;
ent->next = 0;
*hosts->tail = ent;
hosts->tail = &ent->next;
return 0;
syerr:
error = dns_syerr();
error:
free(ent);
return error;
} /* dns_hosts_insert() */
struct dns_packet *dns_hosts_query(struct dns_hosts *hosts, struct dns_packet *Q, int *error_) {
struct dns_packet *P = dns_p_new(512);
struct dns_packet *A = 0;
struct dns_rr rr;
struct dns_hosts_entry *ent;
int error, af;
char qname[DNS_D_MAXNAME + 1];
size_t qlen;
if ((error = dns_rr_parse(&rr, 12, Q)))
goto error;
if (!(qlen = dns_d_expand(qname, sizeof qname, rr.dn.p, Q, &error)))
goto error;
else if (qlen >= sizeof qname)
goto toolong;
if ((error = dns_p_push(P, DNS_S_QD, qname, qlen, rr.type, rr.class, 0, 0)))
goto error;
switch (rr.type) {
case DNS_T_PTR:
for (ent = hosts->head; ent; ent = ent->next) {
if (ent->alias || 0 != strcasecmp(qname, ent->arpa))
continue;
if ((error = dns_p_push(P, DNS_S_AN, qname, qlen, rr.type, rr.class, 0, ent->host)))
goto error;
}
break;
case DNS_T_AAAA:
af = AF_INET6;
goto loop;
case DNS_T_A:
af = AF_INET;
loop: for (ent = hosts->head; ent; ent = ent->next) {
if (ent->af != af || 0 != strcasecmp(qname, ent->host))
continue;
if ((error = dns_p_push(P, DNS_S_AN, qname, qlen, rr.type, rr.class, 0, &ent->addr)))
goto error;
}
break;
default:
break;
} /* switch() */
if (!(A = dns_p_copy(dns_p_make(P->end, &error), P)))
goto error;
return A;
toolong:
error = DNS_EILLEGAL;
error:
*error_ = error;
dns_p_free(A);
return 0;
} /* dns_hosts_query() */
/*
* R E S O L V . C O N F R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct dns_resolv_conf *dns_resconf_open(int *error) {
static const struct dns_resolv_conf resconf_initializer = {
.lookup = "fb",
.family = { AF_INET, AF_INET6 },
.options = { .ndots = 1, .timeout = 5, .attempts = 2, .tcp = DNS_RESCONF_TCP_ENABLE, },
.iface = { .ss_family = AF_INET },
};
struct dns_resolv_conf *resconf;
struct sockaddr_in *sin;
if (!(resconf = malloc(sizeof *resconf)))
goto syerr;
*resconf = resconf_initializer;
sin = (struct sockaddr_in *)&resconf->nameserver[0];
sin->sin_family = AF_INET;
sin->sin_addr.s_addr = INADDR_ANY;
sin->sin_port = htons(53);
#if defined(SA_LEN)
sin->sin_len = sizeof *sin;
#endif
if (0 != gethostname(resconf->search[0], sizeof resconf->search[0]))
goto syerr;
dns_d_anchor(resconf->search[0], sizeof resconf->search[0], resconf->search[0], strlen(resconf->search[0]));
dns_d_cleave(resconf->search[0], sizeof resconf->search[0], resconf->search[0], strlen(resconf->search[0]));
/*
* XXX: If gethostname() returned a string without any label
* separator, then search[0][0] should be NUL.
*/
dns_resconf_acquire(resconf);
return resconf;
syerr:
*error = dns_syerr();
free(resconf);
return 0;
} /* dns_resconf_open() */
void dns_resconf_close(struct dns_resolv_conf *resconf) {
if (!resconf || 1 != dns_resconf_release(resconf))
return /* void */;
free(resconf);
} /* dns_resconf_close() */
dns_refcount_t dns_resconf_acquire(struct dns_resolv_conf *resconf) {
return dns_atomic_fetch_add(&resconf->_.refcount);
} /* dns_resconf_acquire() */
dns_refcount_t dns_resconf_release(struct dns_resolv_conf *resconf) {
return dns_atomic_fetch_sub(&resconf->_.refcount);
} /* dns_resconf_release() */
struct dns_resolv_conf *dns_resconf_mortal(struct dns_resolv_conf *resconf) {
if (resconf)
dns_resconf_release(resconf);
return resconf;
} /* dns_resconf_mortal() */
struct dns_resolv_conf *dns_resconf_local(int *error_) {
struct dns_resolv_conf *resconf;
int error;
if (!(resconf = dns_resconf_open(&error)))
goto error;
if ((error = dns_resconf_loadpath(resconf, "/etc/resolv.conf"))) {
/*
* NOTE: Both the glibc and BIND9 resolvers ignore a missing
* /etc/resolv.conf, defaulting to a nameserver of
* 127.0.0.1. See also dns_hints_insert_resconf, and the
* default initialization of nameserver[0] in
* dns_resconf_open.
*/
if (error != ENOENT)
goto error;
}
if ((error = dns_nssconf_loadpath(resconf, "/etc/nsswitch.conf"))) {
if (error != ENOENT)
goto error;
}
return resconf;
error:
*error_ = error;
dns_resconf_close(resconf);
return 0;
} /* dns_resconf_local() */
struct dns_resolv_conf *dns_resconf_root(int *error) {
struct dns_resolv_conf *resconf;
if ((resconf = dns_resconf_local(error)))
resconf->options.recurse = 1;
return resconf;
} /* dns_resconf_root() */
static time_t dns_resconf_timeout(const struct dns_resolv_conf *resconf) {
return (time_t)DNS_PP_MIN(INT_MAX, resconf->options.timeout);
} /* dns_resconf_timeout() */
enum dns_resconf_keyword {
DNS_RESCONF_NAMESERVER,
DNS_RESCONF_DOMAIN,
DNS_RESCONF_SEARCH,
DNS_RESCONF_LOOKUP,
DNS_RESCONF_FILE,
DNS_RESCONF_BIND,
DNS_RESCONF_CACHE,
DNS_RESCONF_FAMILY,
DNS_RESCONF_INET4,
DNS_RESCONF_INET6,
DNS_RESCONF_OPTIONS,
DNS_RESCONF_EDNS0,
DNS_RESCONF_NDOTS,
DNS_RESCONF_TIMEOUT,
DNS_RESCONF_ATTEMPTS,
DNS_RESCONF_ROTATE,
DNS_RESCONF_RECURSE,
DNS_RESCONF_SMART,
DNS_RESCONF_TCP,
DNS_RESCONF_TCPx,
DNS_RESCONF_INTERFACE,
DNS_RESCONF_ZERO,
DNS_RESCONF_ONE,
DNS_RESCONF_ENABLE,
DNS_RESCONF_ONLY,
DNS_RESCONF_DISABLE,
}; /* enum dns_resconf_keyword */
static enum dns_resconf_keyword dns_resconf_keyword(const char *word) {
static const char *words[] = {
[DNS_RESCONF_NAMESERVER] = "nameserver",
[DNS_RESCONF_DOMAIN] = "domain",
[DNS_RESCONF_SEARCH] = "search",
[DNS_RESCONF_LOOKUP] = "lookup",
[DNS_RESCONF_FILE] = "file",
[DNS_RESCONF_BIND] = "bind",
[DNS_RESCONF_CACHE] = "cache",
[DNS_RESCONF_FAMILY] = "family",
[DNS_RESCONF_INET4] = "inet4",
[DNS_RESCONF_INET6] = "inet6",
[DNS_RESCONF_OPTIONS] = "options",
[DNS_RESCONF_EDNS0] = "edns0",
[DNS_RESCONF_ROTATE] = "rotate",
[DNS_RESCONF_RECURSE] = "recurse",
[DNS_RESCONF_SMART] = "smart",
[DNS_RESCONF_TCP] = "tcp",
[DNS_RESCONF_INTERFACE] = "interface",
[DNS_RESCONF_ZERO] = "0",
[DNS_RESCONF_ONE] = "1",
[DNS_RESCONF_ENABLE] = "enable",
[DNS_RESCONF_ONLY] = "only",
[DNS_RESCONF_DISABLE] = "disable",
};
unsigned i;
for (i = 0; i < lengthof(words); i++) {
if (words[i] && 0 == strcasecmp(words[i], word))
return i;
}
if (0 == strncasecmp(word, "ndots:", sizeof "ndots:" - 1))
return DNS_RESCONF_NDOTS;
if (0 == strncasecmp(word, "timeout:", sizeof "timeout:" - 1))
return DNS_RESCONF_TIMEOUT;
if (0 == strncasecmp(word, "attempts:", sizeof "attempts:" - 1))
return DNS_RESCONF_ATTEMPTS;
if (0 == strncasecmp(word, "tcp:", sizeof "tcp:" - 1))
return DNS_RESCONF_TCPx;
return -1;
} /* dns_resconf_keyword() */
/** OpenBSD-style "[1.2.3.4]:53" nameserver syntax */
int dns_resconf_pton(struct sockaddr_storage *ss, const char *src) {
struct { char buf[128], *p; } addr = { "", addr.buf };
unsigned short port = 0;
struct addrinfo *ai;
int ch, af = AF_INET;
while ((ch = *src++)) {
switch (ch) {
case ' ':
/* FALL THROUGH */
case '\t':
break;
case '[':
break;
case ']':
while ((ch = *src++)) {
if (dns_isdigit(ch)) {
port *= 10;
port += ch - '0';
}
}
goto inet;
case ':':
af = AF_INET6;
/* FALL THROUGH */
default:
if (addr.p < endof(addr.buf) - 1)
*addr.p++ = ch;
break;
} /* switch() */
} /* while() */
inet:
port = (!port)? 53 : port;
ai = bctbx_ip_address_to_addrinfo(af, SOCK_DGRAM, addr.buf, port);
if (ai == NULL) return dns_soerr();
memcpy(ss, ai->ai_addr, ai->ai_addrlen);
bctbx_freeaddrinfo(ai);
return 0;
} /* dns_resconf_pton() */
#define dns_resconf_issep(ch) (dns_isspace(ch) || (ch) == ',')
#define dns_resconf_iscom(ch) ((ch) == '#' || (ch) == ';')
int dns_resconf_loadfile(struct dns_resolv_conf *resconf, FILE *fp) {
unsigned sa_count = 0;
char words[6][DNS_D_MAXNAME + 1];
unsigned wp, wc, i, j, n;
int ch, error;
rewind(fp);
do {
memset(words, '\0', sizeof words);
wp = 0;
wc = 0;
while (EOF != (ch = getc(fp)) && ch != '\n') {
if (dns_resconf_issep(ch)) {
if (wp > 0) {
wp = 0;
if (++wc >= lengthof(words))
goto skip;
}
} else if (dns_resconf_iscom(ch)) {
skip:
do {
ch = getc(fp);
} while (ch != EOF && ch != '\n');
break;
} else if (wp < sizeof words[wc] - 1) {
words[wc][wp++] = ch;
} else {
wp = 0; /* drop word */
goto skip;
}
}
if (wp > 0)
wc++;
if (wc < 2)
continue;
switch (dns_resconf_keyword(words[0])) {
case DNS_RESCONF_NAMESERVER:
if (sa_count >= lengthof(resconf->nameserver))
continue;
if ((error = dns_resconf_pton(&resconf->nameserver[sa_count], words[1])))
continue;
sa_count++;
break;
case DNS_RESCONF_DOMAIN:
case DNS_RESCONF_SEARCH:
memset(resconf->search, '\0', sizeof resconf->search);
for (i = 1, j = 0; i < wc && j < lengthof(resconf->search); i++, j++)
dns_d_anchor(resconf->search[j], sizeof resconf->search[j], words[i], strlen(words[i]));
break;
case DNS_RESCONF_LOOKUP:
for (i = 1, j = 0; i < wc && j < lengthof(resconf->lookup); i++) {
switch (dns_resconf_keyword(words[i])) {
case DNS_RESCONF_FILE:
resconf->lookup[j++] = 'f';
break;
case DNS_RESCONF_BIND:
resconf->lookup[j++] = 'b';
break;
case DNS_RESCONF_CACHE:
resconf->lookup[j++] = 'c';
break;
default:
break;
} /* switch() */
} /* for() */
break;
case DNS_RESCONF_FAMILY:
for (i = 1, j = 0; i < wc && j < lengthof(resconf->family); i++) {
switch (dns_resconf_keyword(words[i])) {
case DNS_RESCONF_INET4:
resconf->family[j++] = AF_INET;
break;
case DNS_RESCONF_INET6:
resconf->family[j++] = AF_INET6;
break;
default:
break;
}
}
break;
case DNS_RESCONF_OPTIONS:
for (i = 1; i < wc; i++) {
switch (dns_resconf_keyword(words[i])) {
case DNS_RESCONF_EDNS0:
resconf->options.edns0 = 1;
break;
case DNS_RESCONF_NDOTS:
for (j = sizeof "ndots:" - 1, n = 0; dns_isdigit(words[i][j]); j++) {
n *= 10;
n += words[i][j] - '0';
} /* for() */
resconf->options.ndots = n;
break;
case DNS_RESCONF_TIMEOUT:
for (j = sizeof "timeout:" - 1, n = 0; dns_isdigit(words[i][j]); j++) {
n *= 10;
n += words[i][j] - '0';
} /* for() */
resconf->options.timeout = n;
break;
case DNS_RESCONF_ATTEMPTS:
for (j = sizeof "attempts:" - 1, n = 0; dns_isdigit(words[i][j]); j++) {
n *= 10;
n += words[i][j] - '0';
} /* for() */
resconf->options.attempts = n;
break;
case DNS_RESCONF_ROTATE:
resconf->options.rotate = 1;
break;
case DNS_RESCONF_RECURSE:
resconf->options.recurse = 1;
break;
case DNS_RESCONF_SMART:
resconf->options.smart = 1;
break;
case DNS_RESCONF_TCP:
resconf->options.tcp = DNS_RESCONF_TCP_ONLY;
break;
case DNS_RESCONF_TCPx:
switch (dns_resconf_keyword(&words[i][sizeof "tcp:" - 1])) {
case DNS_RESCONF_ENABLE:
resconf->options.tcp = DNS_RESCONF_TCP_ENABLE;
break;
case DNS_RESCONF_ONE:
case DNS_RESCONF_ONLY:
resconf->options.tcp = DNS_RESCONF_TCP_ONLY;
break;
case DNS_RESCONF_ZERO:
case DNS_RESCONF_DISABLE:
resconf->options.tcp = DNS_RESCONF_TCP_DISABLE;
break;
default:
break;
} /* switch() */
break;
default:
break;
} /* switch() */
} /* for() */
break;
case DNS_RESCONF_INTERFACE:
for (i = 0, n = 0; dns_isdigit(words[2][i]); i++) {
n *= 10;
n += words[2][i] - '0';
}
dns_resconf_setiface(resconf, words[1], n);
break;
default:
break;
} /* switch() */
} while (ch != EOF);
return 0;
} /* dns_resconf_loadfile() */
int dns_resconf_loadpath(struct dns_resolv_conf *resconf, const char *path) {
FILE *fp;
int error;
if (!(fp = dns_fopen(path, "rt", &error)))
return error;
error = dns_resconf_loadfile(resconf, fp);
fclose(fp);
return error;
} /* dns_resconf_loadpath() */
#ifdef USE_FIXED_NAMESERVERS
int dns_resconf_load_fixed_nameservers(struct dns_resolv_conf *resconf) {
const char * const nameservers[] = {
"8.8.8.8",
"8.8.4.4"
};
int i;
int error = 0;
for (i = 0; !error && (i < lengthof(nameservers)); i++) {
error = dns_resconf_pton(&resconf->nameserver[i], nameservers[i]);
}
return error;
}
#endif /* USE_FIXED_NAMESERVERS */
#ifdef USE_STRUCT_RES_STATE_NAMESERVERS
int dns_resconf_load_struct_res_state_nameservers(struct dns_resolv_conf *resconf) {
int i;
struct __res_state *rs = __res_get_state();
for (i = 0; i < rs->nscount; i++) {
memcpy(&resconf->nameserver[i], (struct sockaddr_storage *)&rs->nsaddr_list[i], sizeof(struct sockaddr_in));
}
return 0;
}
#endif /* USE_STRUCT_RES_STATE_NAMESERVERS */
#if defined(_WIN32) && !defined(USE_FIXED_NAMESERVERS)
int dns_resconf_loadwin(struct dns_resolv_conf *resconf) {
FIXED_INFO *pFixedInfo;
ULONG ulOutBufLen;
DWORD dwRetVal;
IP_ADDR_STRING *pIPAddr;
unsigned sa_count = 0;
int error;
pFixedInfo = (FIXED_INFO *) malloc(sizeof(FIXED_INFO));
if (pFixedInfo == NULL) {
return -1;
}
ulOutBufLen = sizeof(FIXED_INFO);
if (GetNetworkParams(pFixedInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW) {
free(pFixedInfo);
pFixedInfo = (FIXED_INFO *) malloc(ulOutBufLen);
if (pFixedInfo == NULL) {
return -1;
}
}
if ((dwRetVal = GetNetworkParams(pFixedInfo, &ulOutBufLen)) == NO_ERROR) {
memset(resconf->search, '\0', sizeof resconf->search);
memcpy(resconf->search[0], pFixedInfo->DomainName, sizeof pFixedInfo->DomainName);
pIPAddr = &pFixedInfo->DnsServerList;
do {
error = dns_resconf_pton(&resconf->nameserver[sa_count], pIPAddr->IpAddress.String);
pIPAddr = pIPAddr->Next;
sa_count++;
} while (!error && pIPAddr && (sa_count < lengthof(resconf->nameserver)));
}
free(pFixedInfo);
return 0;
}
#endif /* dns_resconf_loadwin() */
#ifdef __ANDROID__
int dns_resconf_loadandroid(struct dns_resolv_conf *resconf) {
char dns[PROP_VALUE_MAX];
char prop_name[PROP_NAME_MAX];
unsigned int sa_count = 0;
int error = 0;
unsigned int i;
for (i = 1; !error && (i <= lengthof(resconf->nameserver)); i++) {
snprintf(prop_name, sizeof(prop_name), "net.dns%d", i);
if (__system_property_get(prop_name, dns) > 0) {
if (dns_resconf_pton(&resconf->nameserver[sa_count], dns) == 0){
sa_count++;
}
}
}
if (sa_count == 0) {
/* No net.dnsX property found, return an error. */
error = -1;
}
return error;
} /* dns_resconf_loadandroid */
#endif
#ifdef HAVE_RESINIT
static int guess_scope_id(void){
struct ifaddrs *ifp;
struct ifaddrs *ifpstart;
int scope_id = -1;
if (getifaddrs(&ifpstart) < 0) {
return -1;
}
#ifndef __linux__
#define UP_FLAG IFF_UP /* interface is up */
#else
#define UP_FLAG IFF_RUNNING /* resources allocated */
#endif
for (ifp = ifpstart; ifp != NULL; ifp = ifp->ifa_next) {
if (ifp->ifa_addr && ifp->ifa_addr->sa_family == AF_INET6
&& (ifp->ifa_flags & UP_FLAG) && !(ifp->ifa_flags & IFF_LOOPBACK))
{
struct sockaddr_in6 *in6 = (struct sockaddr_in6*)ifp->ifa_addr;
if (in6->sin6_addr.__u6_addr.__u6_addr16[0] == 0x80fe){
scope_id = in6->sin6_scope_id;
belle_sip_warning("Best guess for scope id is %i", scope_id);
break;
}
}
}
freeifaddrs(ifpstart);
return scope_id;
}
int dns_resconf_loadfromresolv(struct dns_resolv_conf *resconf) {
struct __res_state res;
union res_sockaddr_union addresses[3];
int i,error,write_index;
if ((error = res_ninit(&res))) {
return error;
}
error=res_getservers(&res,addresses,3);
if (error>0){
for (i = 0,write_index=0; inameserver[write_index++],&addresses[i],sizeof(union res_sockaddr_union));
}
} else {
memcpy(&resconf->nameserver[write_index++],&addresses[i],sizeof(union res_sockaddr_union));
}
}
error=0;
}else error=-1;
res_ndestroy(&res);
return error;
}
#endif /*HAVE_RESINIT*/
struct dns_anyconf {
char *token[16];
unsigned count;
char buffer[1024], *tp, *cp;
}; /* struct dns_anyconf */
static void dns_anyconf_reset(struct dns_anyconf *cf) {
cf->count = 0;
cf->tp = cf->cp = cf->buffer;
} /* dns_anyconf_reset() */
static int dns_anyconf_push(struct dns_anyconf *cf) {
if (!(cf->cp < endof(cf->buffer) && cf->count < lengthof(cf->token)))
return ENOMEM;
*cf->cp++ = '\0';
cf->token[cf->count++] = cf->tp;
cf->tp = cf->cp;
return 0;
} /* dns_anyconf_push() */
static void dns_anyconf_pop(struct dns_anyconf *cf) {
if (cf->count > 0) {
--cf->count;
cf->tp = cf->cp = cf->token[cf->count];
cf->token[cf->count] = 0;
}
} /* dns_anyconf_pop() */
static int dns_anyconf_addc(struct dns_anyconf *cf, int ch) {
if (!(cf->cp < endof(cf->buffer)))
return ENOMEM;
*cf->cp++ = ch;
return 0;
} /* dns_anyconf_addc() */
static _Bool dns_anyconf_match(const char *pat, int mc) {
_Bool match;
int pc;
if (*pat == '^') {
match = 0;
++pat;
} else {
match = 1;
}
while ((pc = *(const unsigned char *)pat++)) {
switch (pc) {
case '%':
if (!(pc = *(const unsigned char *)pat++))
return !match;
switch (pc) {
case 'a':
if (dns_isalpha(mc))
return match;
break;
case 'd':
if (dns_isdigit(mc))
return match;
break;
case 'w':
if (dns_isalnum(mc))
return match;
break;
case 's':
if (dns_isspace(mc))
return match;
break;
default:
if (mc == pc)
return match;
break;
} /* switch() */
break;
default:
if (mc == pc)
return match;
break;
} /* switch() */
} /* while() */
return !match;
} /* dns_anyconf_match() */
static int dns_anyconf_peek(FILE *fp) {
int ch;
ch = getc(fp);
ungetc(ch, fp);
return ch;
} /* dns_anyconf_peek() */
static size_t dns_anyconf_skip(const char *pat, FILE *fp) {
size_t count = 0;
int ch;
while (EOF != (ch = getc(fp))) {
if (dns_anyconf_match(pat, ch)) {
count++;
continue;
}
ungetc(ch, fp);
break;
}
return count;
} /* dns_anyconf_skip() */
static size_t dns_anyconf_scan(struct dns_anyconf *cf, const char *pat, FILE *fp, int *error) {
size_t len;
int ch;
while (EOF != (ch = getc(fp))) {
if (dns_anyconf_match(pat, ch)) {
if ((*error = dns_anyconf_addc(cf, ch)))
return 0;
continue;
} else {
ungetc(ch, fp);
break;
}
}
if ((len = cf->cp - cf->tp)) {
if ((*error = dns_anyconf_push(cf)))
return 0;
return len;
} else {
*error = 0;
return 0;
}
} /* dns_anyconf_scan() */
DNS_NOTUSED static void dns_anyconf_dump(struct dns_anyconf *cf, FILE *fp) {
unsigned i;
fprintf(fp, "tokens:");
for (i = 0; i < cf->count; i++) {
fprintf(fp, " %s", cf->token[i]);
}
fputc('\n', fp);
} /* dns_anyconf_dump() */
enum dns_nssconf_keyword {
DNS_NSSCONF_INVALID = 0,
DNS_NSSCONF_HOSTS = 1,
DNS_NSSCONF_SUCCESS,
DNS_NSSCONF_NOTFOUND,
DNS_NSSCONF_UNAVAIL,
DNS_NSSCONF_TRYAGAIN,
DNS_NSSCONF_CONTINUE,
DNS_NSSCONF_RETURN,
DNS_NSSCONF_FILES,
DNS_NSSCONF_DNS,
DNS_NSSCONF_MDNS,
DNS_NSSCONF_LAST,
}; /* enum dns_nssconf_keyword */
static enum dns_nssconf_keyword dns_nssconf_keyword(const char *word) {
static const char *list[] = {
[DNS_NSSCONF_HOSTS] = "hosts",
[DNS_NSSCONF_SUCCESS] = "success",
[DNS_NSSCONF_NOTFOUND] = "notfound",
[DNS_NSSCONF_UNAVAIL] = "unavail",
[DNS_NSSCONF_TRYAGAIN] = "tryagain",
[DNS_NSSCONF_CONTINUE] = "continue",
[DNS_NSSCONF_RETURN] = "return",
[DNS_NSSCONF_FILES] = "files",
[DNS_NSSCONF_DNS] = "dns",
[DNS_NSSCONF_MDNS] = "mdns",
};
unsigned i;
for (i = 1; i < lengthof(list); i++) {
if (list[i] && 0 == strcasecmp(list[i], word))
return i;
}
return DNS_NSSCONF_INVALID;
} /* dns_nssconf_keyword() */
static enum dns_nssconf_keyword dns_nssconf_c2k(int ch) {
static const char map[] = {
['S'] = DNS_NSSCONF_SUCCESS,
['N'] = DNS_NSSCONF_NOTFOUND,
['U'] = DNS_NSSCONF_UNAVAIL,
['T'] = DNS_NSSCONF_TRYAGAIN,
['C'] = DNS_NSSCONF_CONTINUE,
['R'] = DNS_NSSCONF_RETURN,
['f'] = DNS_NSSCONF_FILES,
['F'] = DNS_NSSCONF_FILES,
['d'] = DNS_NSSCONF_DNS,
['D'] = DNS_NSSCONF_DNS,
['b'] = DNS_NSSCONF_DNS,
['B'] = DNS_NSSCONF_DNS,
['m'] = DNS_NSSCONF_MDNS,
['M'] = DNS_NSSCONF_MDNS,
};
return (ch >= 0 && ch < (int)lengthof(map))? map[ch] : DNS_NSSCONF_INVALID;
} /* dns_nssconf_c2k() */
DNS_PRAGMA_PUSH
DNS_PRAGMA_QUIET
static int dns_nssconf_k2c(int k) {
static const char map[DNS_NSSCONF_LAST] = {
[DNS_NSSCONF_SUCCESS] = 'S',
[DNS_NSSCONF_NOTFOUND] = 'N',
[DNS_NSSCONF_UNAVAIL] = 'U',
[DNS_NSSCONF_TRYAGAIN] = 'T',
[DNS_NSSCONF_CONTINUE] = 'C',
[DNS_NSSCONF_RETURN] = 'R',
[DNS_NSSCONF_FILES] = 'f',
[DNS_NSSCONF_DNS] = 'b',
[DNS_NSSCONF_MDNS] = 'm',
};
return (k >= 0 && k < (int)lengthof(map))? (map[k]? map[k] : '?') : '?';
} /* dns_nssconf_k2c() */
static const char *dns_nssconf_k2s(int k) {
static const char *const map[DNS_NSSCONF_LAST] = {
[DNS_NSSCONF_SUCCESS] = "SUCCESS",
[DNS_NSSCONF_NOTFOUND] = "NOTFOUND",
[DNS_NSSCONF_UNAVAIL] = "UNAVAIL",
[DNS_NSSCONF_TRYAGAIN] = "TRYAGAIN",
[DNS_NSSCONF_CONTINUE] = "continue",
[DNS_NSSCONF_RETURN] = "return",
[DNS_NSSCONF_FILES] = "files",
[DNS_NSSCONF_DNS] = "dns",
[DNS_NSSCONF_MDNS] = "mdns",
};
return (k >= 0 && k < (int)lengthof(map))? (map[k]? map[k] : "") : "";
} /* dns_nssconf_k2s() */
DNS_PRAGMA_POP
int dns_nssconf_loadfile(struct dns_resolv_conf *resconf, FILE *fp) {
enum dns_nssconf_keyword source, status, action;
char lookup[sizeof resconf->lookup] = "", *lp;
struct dns_anyconf cf;
size_t i;
int error;
while (!feof(fp) && !ferror(fp)) {
dns_anyconf_reset(&cf);
dns_anyconf_skip("%s", fp);
if (!dns_anyconf_scan(&cf, "%w_", fp, &error))
goto nextent;
if (DNS_NSSCONF_HOSTS != dns_nssconf_keyword(cf.token[0]))
goto nextent;
dns_anyconf_pop(&cf);
if (!dns_anyconf_skip(": \t", fp))
goto nextent;
*(lp = lookup) = '\0';
while (dns_anyconf_scan(&cf, "%w_", fp, &error)) {
dns_anyconf_skip(" \t", fp);
if ('[' == dns_anyconf_peek(fp)) {
dns_anyconf_skip("[ \t", fp);
while (dns_anyconf_scan(&cf, "%w_!", fp, &error)) {
dns_anyconf_skip("= \t", fp);
if (!dns_anyconf_scan(&cf, "%w_", fp, &error)) {
dns_anyconf_pop(&cf); /* discard status */
dns_anyconf_skip("^#;]\n", fp); /* skip to end of criteria */
break;
}
dns_anyconf_skip(" \t", fp);
}
dns_anyconf_skip("] \t", fp);
}
if ((size_t)(endof(lookup) - lp) < cf.count + 1) /* +1 for '\0' */
goto nextsrc;
source = dns_nssconf_keyword(cf.token[0]);
switch (source) {
case DNS_NSSCONF_DNS:
case DNS_NSSCONF_MDNS:
case DNS_NSSCONF_FILES:
*lp++ = dns_nssconf_k2c(source);
break;
default:
goto nextsrc;
}
for (i = 1; i + 1 < cf.count; i += 2) {
status = dns_nssconf_keyword(cf.token[i]);
action = dns_nssconf_keyword(cf.token[i + 1]);
switch (status) {
case DNS_NSSCONF_SUCCESS:
case DNS_NSSCONF_NOTFOUND:
case DNS_NSSCONF_UNAVAIL:
case DNS_NSSCONF_TRYAGAIN:
*lp++ = dns_nssconf_k2c(status);
break;
default:
continue;
}
switch (action) {
case DNS_NSSCONF_CONTINUE:
case DNS_NSSCONF_RETURN:
break;
default:
action = (status == DNS_NSSCONF_SUCCESS)
? DNS_NSSCONF_RETURN
: DNS_NSSCONF_CONTINUE;
break;
}
*lp++ = dns_nssconf_k2c(action);
}
nextsrc:
*lp = '\0';
dns_anyconf_reset(&cf);
}
nextent:
dns_anyconf_skip("^\n", fp);
}
if (*lookup)
strncpy(resconf->lookup, lookup, sizeof resconf->lookup);
return 0;
} /* dns_nssconf_loadfile() */
int dns_nssconf_loadpath(struct dns_resolv_conf *resconf, const char *path) {
FILE *fp;
int error;
if (!(fp = dns_fopen(path, "rt", &error)))
return error;
error = dns_nssconf_loadfile(resconf, fp);
fclose(fp);
return error;
} /* dns_nssconf_loadpath() */
struct dns_nssconf_source {
enum dns_nssconf_keyword source, success, notfound, unavail, tryagain;
}; /* struct dns_nssconf_source */
typedef unsigned dns_nssconf_i;
static DNS_INLINE int dns_nssconf_peek(const struct dns_resolv_conf *resconf, dns_nssconf_i state) {
return (state < lengthof(resconf->lookup) && resconf->lookup[state])? resconf->lookup[state] : 0;
} /* dns_nssconf_peek() */
static _Bool dns_nssconf_next(struct dns_nssconf_source *src, const struct dns_resolv_conf *resconf, dns_nssconf_i *state) {
int source, status, action;
src->source = DNS_NSSCONF_INVALID;
src->success = DNS_NSSCONF_RETURN;
src->notfound = DNS_NSSCONF_CONTINUE;
src->unavail = DNS_NSSCONF_CONTINUE;
src->tryagain = DNS_NSSCONF_CONTINUE;
while ((source = dns_nssconf_peek(resconf, *state))) {
source = dns_nssconf_c2k(source);
++*state;
switch (source) {
case DNS_NSSCONF_FILES:
case DNS_NSSCONF_DNS:
case DNS_NSSCONF_MDNS:
src->source = source;
break;
default:
continue;
}
while ((status = dns_nssconf_peek(resconf, *state)) && (action = dns_nssconf_peek(resconf, *state + 1))) {
status = dns_nssconf_c2k(status);
action = dns_nssconf_c2k(action);
switch (action) {
case DNS_NSSCONF_RETURN:
case DNS_NSSCONF_CONTINUE:
break;
default:
goto done;
}
switch (status) {
case DNS_NSSCONF_SUCCESS:
src->success = action;
break;
case DNS_NSSCONF_NOTFOUND:
src->notfound = action;
break;
case DNS_NSSCONF_UNAVAIL:
src->unavail = action;
break;
case DNS_NSSCONF_TRYAGAIN:
src->tryagain = action;
break;
default:
goto done;
}
*state += 2;
}
break;
}
done:
return src->source != DNS_NSSCONF_INVALID;
} /* dns_nssconf_next() */
static int dns_nssconf_dump_status(int status, int action, unsigned *count, FILE *fp) {
switch (status) {
case DNS_NSSCONF_SUCCESS:
if (action == DNS_NSSCONF_RETURN)
return 0;
break;
default:
if (action == DNS_NSSCONF_CONTINUE)
return 0;
break;
}
fputc(' ', fp);
if (!*count)
fputc('[', fp);
fprintf(fp, "%s=%s", dns_nssconf_k2s(status), dns_nssconf_k2s(action));
++*count;
return 0;
} /* dns_nssconf_dump_status() */
int dns_nssconf_dump(struct dns_resolv_conf *resconf, FILE *fp) {
struct dns_nssconf_source src;
dns_nssconf_i i = 0;
fputs("hosts:", fp);
while (dns_nssconf_next(&src, resconf, &i)) {
unsigned n = 0;
fprintf(fp, " %s", dns_nssconf_k2s(src.source));
dns_nssconf_dump_status(DNS_NSSCONF_SUCCESS, src.success, &n, fp);
dns_nssconf_dump_status(DNS_NSSCONF_NOTFOUND, src.notfound, &n, fp);
dns_nssconf_dump_status(DNS_NSSCONF_UNAVAIL, src.unavail, &n, fp);
dns_nssconf_dump_status(DNS_NSSCONF_TRYAGAIN, src.tryagain, &n, fp);
if (n)
fputc(']', fp);
}
fputc('\n', fp);
return 0;
} /* dns_nssconf_dump() */
int dns_resconf_setiface(struct dns_resolv_conf *resconf, const char *addr, unsigned short port) {
int af = (strchr(addr, ':'))? AF_INET6 : AF_INET;
int error;
if ((error = dns_pton(af, addr, dns_sa_addr(af, &resconf->iface, NULL))))
return error;
*dns_sa_port(af, &resconf->iface) = htons(port);
resconf->iface.ss_family = af;
return 0;
} /* dns_resconf_setiface() */
size_t dns_resconf_search(void *dst, size_t lim, const void *qname, size_t qlen, struct dns_resolv_conf *resconf, dns_resconf_i_t *state) {
unsigned srchi = 0xff & (*state >> 8);
unsigned ndots = 0xff & (*state >> 16);
unsigned len = 0;
const char *qp, *qe;
switch (0xff & *state) {
case 0:
qp = qname;
qe = qp + qlen;
while ((qp = memchr(qp, '.', qe - qp)))
{ ndots++; qp++; }
++*state;
if (ndots >= resconf->options.ndots) {
len = dns_d_anchor(dst, lim, qname, qlen);
break;
}
/* FALL THROUGH */
case 1:
if (srchi < lengthof(resconf->search) && resconf->search[srchi][0] && strcmp(resconf->search[srchi], ".")) {
len = dns_d_anchor(dst, lim, qname, qlen);
len += dns_strlcpy((char *)dst + DNS_PP_MIN(len, lim), resconf->search[srchi], lim - DNS_PP_MIN(len, lim));
srchi++;
break;
}
++*state;
/* FALL THROUGH */
case 2:
++*state;
if (ndots < resconf->options.ndots) {
len = dns_d_anchor(dst, lim, qname, qlen);
break;
}
/* FALL THROUGH */
default:
break;
} /* switch() */
*state = ((0xff & *state) << 0)
| ((0xff & srchi) << 8)
| ((0xff & ndots) << 16);
if (lim > 0)
((char *)dst)[DNS_PP_MIN(lim - 1, len)] = '\0';
return len;
} /* dns_resconf_search() */
int dns_resconf_dump(struct dns_resolv_conf *resconf, FILE *fp) {
unsigned i;
int af;
for (i = 0; i < lengthof(resconf->nameserver) && (af = resconf->nameserver[i].ss_family) != AF_UNSPEC; i++) {
char addr[INET6_ADDRSTRLEN + 1] = "[INVALID]";
unsigned short port;
dns_inet_ntop(af, dns_sa_addr(af, &resconf->nameserver[i], NULL), addr, sizeof addr);
port = ntohs(*dns_sa_port(af, &resconf->nameserver[i]));
if (port == 53)
fprintf(fp, "nameserver %s\n", addr);
else
fprintf(fp, "nameserver [%s]:%hu\n", addr, port);
}
fprintf(fp, "search");
for (i = 0; i < lengthof(resconf->search) && resconf->search[i][0]; i++)
fprintf(fp, " %s", resconf->search[i]);
fputc('\n', fp);
fputs("; ", fp);
dns_nssconf_dump(resconf, fp);
fprintf(fp, "lookup");
for (i = 0; i < lengthof(resconf->lookup) && resconf->lookup[i]; i++) {
switch (resconf->lookup[i]) {
case 'b':
fprintf(fp, " bind"); break;
case 'f':
fprintf(fp, " file"); break;
case 'c':
fprintf(fp, " cache"); break;
}
}
fputc('\n', fp);
fprintf(fp, "options ndots:%u timeout:%u attempts:%u", resconf->options.ndots, resconf->options.timeout, resconf->options.attempts);
if (resconf->options.edns0)
fprintf(fp, " edns0");
if (resconf->options.rotate)
fprintf(fp, " rotate");
if (resconf->options.recurse)
fprintf(fp, " recurse");
if (resconf->options.smart)
fprintf(fp, " smart");
switch (resconf->options.tcp) {
case DNS_RESCONF_TCP_ENABLE:
break;
case DNS_RESCONF_TCP_ONLY:
fprintf(fp, " tcp");
break;
case DNS_RESCONF_TCP_DISABLE:
fprintf(fp, " tcp:disable");
break;
}
fputc('\n', fp);
if ((af = resconf->iface.ss_family) != AF_UNSPEC) {
char addr[INET6_ADDRSTRLEN + 1] = "[INVALID]";
dns_inet_ntop(af, dns_sa_addr(af, &resconf->iface, NULL), addr, sizeof addr);
fprintf(fp, "interface %s %hu\n", addr, ntohs(*dns_sa_port(af, &resconf->iface)));
}
return 0;
} /* dns_resconf_dump() */
/*
* H I N T S E R V E R R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct dns_hints_soa {
unsigned char zone[DNS_D_MAXNAME + 1];
struct {
struct sockaddr_storage ss;
unsigned priority;
} addrs[16];
unsigned count;
struct dns_hints_soa *next;
}; /* struct dns_hints_soa */
struct dns_hints {
dns_atomic_t refcount;
struct dns_hints_soa *head;
}; /* struct dns_hints */
struct dns_hints *dns_hints_open(struct dns_resolv_conf *resconf, int *error) {
static const struct dns_hints H_initializer;
struct dns_hints *H;
(void)resconf;
if (!(H = malloc(sizeof *H)))
goto syerr;
*H = H_initializer;
dns_hints_acquire(H);
return H;
syerr:
*error = dns_syerr();
free(H);
return 0;
} /* dns_hints_open() */
void dns_hints_close(struct dns_hints *H) {
struct dns_hints_soa *soa, *nxt;
if (!H || 1 != dns_hints_release(H))
return /* void */;
for (soa = H->head; soa; soa = nxt) {
nxt = soa->next;
free(soa);
}
free(H);
return /* void */;
} /* dns_hints_close() */
dns_refcount_t dns_hints_acquire(struct dns_hints *H) {
return dns_atomic_fetch_add(&H->refcount);
} /* dns_hints_acquire() */
dns_refcount_t dns_hints_release(struct dns_hints *H) {
return dns_atomic_fetch_sub(&H->refcount);
} /* dns_hints_release() */
struct dns_hints *dns_hints_mortal(struct dns_hints *hints) {
if (hints)
dns_hints_release(hints);
return hints;
} /* dns_hints_mortal() */
struct dns_hints *dns_hints_local(struct dns_resolv_conf *resconf, int *error_) {
struct dns_hints *hints = 0;
int error;
if (resconf)
dns_resconf_acquire(resconf);
else if (!(resconf = dns_resconf_local(&error)))
goto error;
if (!(hints = dns_hints_open(resconf, &error)))
goto error;
error = 0;
if (0 == dns_hints_insert_resconf(hints, ".", resconf, &error) && error)
goto error;
dns_resconf_close(resconf);
return hints;
error:
*error_ = error;
dns_resconf_close(resconf);
dns_hints_close(hints);
return 0;
} /* dns_hints_local() */
struct dns_hints *dns_hints_root(struct dns_resolv_conf *resconf, int *error_) {
static const struct {
int af;
char addr[INET6_ADDRSTRLEN];
} root_hints[] = {
{ AF_INET, "198.41.0.4" }, /* A.ROOT-SERVERS.NET. */
{ AF_INET6, "2001:503:ba3e::2:30" }, /* A.ROOT-SERVERS.NET. */
{ AF_INET, "192.228.79.201" }, /* B.ROOT-SERVERS.NET. */
{ AF_INET6, "2001:500:84::b" }, /* B.ROOT-SERVERS.NET. */
{ AF_INET, "192.33.4.12" }, /* C.ROOT-SERVERS.NET. */
{ AF_INET6, "2001:500:2::c" }, /* C.ROOT-SERVERS.NET. */
{ AF_INET, "199.7.91.13" }, /* D.ROOT-SERVERS.NET. */
{ AF_INET6, "2001:500:2d::d" }, /* D.ROOT-SERVERS.NET. */
{ AF_INET, "192.203.230.10" }, /* E.ROOT-SERVERS.NET. */
{ AF_INET, "192.5.5.241" }, /* F.ROOT-SERVERS.NET. */
{ AF_INET6, "2001:500:2f::f" }, /* F.ROOT-SERVERS.NET. */
{ AF_INET, "192.112.36.4" }, /* G.ROOT-SERVERS.NET. */
{ AF_INET, "128.63.2.53" }, /* H.ROOT-SERVERS.NET. */
{ AF_INET6, "2001:500:1::803f:235" }, /* H.ROOT-SERVERS.NET. */
{ AF_INET, "192.36.148.17" }, /* I.ROOT-SERVERS.NET. */
{ AF_INET6, "2001:7FE::53" }, /* I.ROOT-SERVERS.NET. */
{ AF_INET, "192.58.128.30" }, /* J.ROOT-SERVERS.NET. */
{ AF_INET6, "2001:503:c27::2:30" }, /* J.ROOT-SERVERS.NET. */
{ AF_INET, "193.0.14.129" }, /* K.ROOT-SERVERS.NET. */
{ AF_INET6, "2001:7FD::1" }, /* K.ROOT-SERVERS.NET. */
{ AF_INET, "199.7.83.42" }, /* L.ROOT-SERVERS.NET. */
{ AF_INET6, "2001:500:3::42" }, /* L.ROOT-SERVERS.NET. */
{ AF_INET, "202.12.27.33" }, /* M.ROOT-SERVERS.NET. */
{ AF_INET6, "2001:DC3::35" }, /* M.ROOT-SERVERS.NET. */
};
struct dns_hints *hints = 0;
struct sockaddr_storage ss;
unsigned i;
int error, af;
if (!(hints = dns_hints_open(resconf, &error)))
goto error;
for (i = 0; i < lengthof(root_hints); i++) {
af = root_hints[i].af;
if ((error = dns_pton(af, root_hints[i].addr, dns_sa_addr(af, &ss, NULL))))
goto error;
*dns_sa_port(af, &ss) = htons(53);
ss.ss_family = af;
if ((error = dns_hints_insert(hints, ".", (struct sockaddr *)&ss, 1)))
goto error;
}
return hints;
error:
*error_ = error;
dns_hints_close(hints);
return 0;
} /* dns_hints_root() */
static struct dns_hints_soa *dns_hints_fetch(struct dns_hints *H, const char *zone) {
struct dns_hints_soa *soa;
for (soa = H->head; soa; soa = soa->next) {
if (0 == strcasecmp(zone, (char *)soa->zone))
return soa;
}
return 0;
} /* dns_hints_fetch() */
int dns_hints_insert(struct dns_hints *H, const char *zone, const struct sockaddr *sa, unsigned priority) {
static const struct dns_hints_soa soa_initializer;
struct dns_hints_soa *soa;
unsigned i;
if (!(soa = dns_hints_fetch(H, zone))) {
if (!(soa = malloc(sizeof *soa)))
return dns_syerr();
*soa = soa_initializer;
dns_strlcpy((char *)soa->zone, zone, sizeof soa->zone);
soa->next = H->head;
H->head = soa;
}
i = soa->count % lengthof(soa->addrs);
memcpy(&soa->addrs[i].ss, sa, dns_sa_len(sa));
soa->addrs[i].priority = DNS_PP_MAX(1, priority);
if (soa->count < lengthof(soa->addrs))
soa->count++;
return 0;
} /* dns_hints_insert() */
static _Bool dns_hints_isinaddr_any(const void *sa) {
struct in_addr *addr;
if (dns_sa_family(sa) != AF_INET)
return 0;
addr = dns_sa_addr(AF_INET, sa, NULL);
return addr->s_addr == htonl(INADDR_ANY);
}
unsigned dns_hints_insert_resconf(struct dns_hints *H, const char *zone, const struct dns_resolv_conf *resconf, int *error_) {
unsigned i, n, p;
int error;
for (i = 0, n = 0, p = 1; i < lengthof(resconf->nameserver) && resconf->nameserver[i].ss_family != AF_UNSPEC; i++, n++) {
union { struct sockaddr_in sin; } tmp;
struct sockaddr *ns;
/*
* dns_resconf_open initializes nameserver[0] to INADDR_ANY.
*
* Traditionally the semantics of 0.0.0.0 meant the default
* interface, which evolved to mean the loopback interface.
* See comment block preceding resolv/res_init.c:res_init in
* glibc 2.23. As of 2.23, glibc no longer translates
* 0.0.0.0 despite the code comment, but it does default to
* 127.0.0.1 when no nameservers are present.
*
* BIND9 as of 9.10.3 still translates 0.0.0.0 to 127.0.0.1.
* See lib/lwres/lwconfig.c:lwres_create_addr and the
* convert_zero flag. 127.0.0.1 is also the default when no
* nameservers are present.
*/
if (dns_hints_isinaddr_any(&resconf->nameserver[i])) {
memcpy(&tmp.sin, &resconf->nameserver[i], sizeof tmp.sin);
tmp.sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
ns = (struct sockaddr *)&tmp.sin;
} else {
ns = (struct sockaddr *)&resconf->nameserver[i];
}
if ((error = dns_hints_insert(H, zone, ns, p)))
goto error;
p += !resconf->options.rotate;
}
return n;
error:
*error_ = error;
return n;
} /* dns_hints_insert_resconf() */
static int dns_hints_i_cmp(unsigned a, unsigned b, struct dns_hints_i *i, struct dns_hints_soa *soa) {
int cmp;
if ((cmp = soa->addrs[a].priority - soa->addrs[b].priority))
return cmp;
return dns_k_shuffle16(a, i->state.seed) - dns_k_shuffle16(b, i->state.seed);
} /* dns_hints_i_cmp() */
static unsigned dns_hints_i_start(struct dns_hints_i *i, struct dns_hints_soa *soa) {
unsigned p0, p;
p0 = 0;
for (p = 1; p < soa->count; p++) {
if (dns_hints_i_cmp(p, p0, i, soa) < 0)
p0 = p;
}
return p0;
} /* dns_hints_i_start() */
static unsigned dns_hints_i_skip(unsigned p0, struct dns_hints_i *i, struct dns_hints_soa *soa) {
unsigned pZ, p;
for (pZ = 0; pZ < soa->count; pZ++) {
if (dns_hints_i_cmp(pZ, p0, i, soa) > 0)
goto cont;
}
return soa->count;
cont:
for (p = pZ + 1; p < soa->count; p++) {
if (dns_hints_i_cmp(p, p0, i, soa) <= 0)
continue;
if (dns_hints_i_cmp(p, pZ, i, soa) >= 0)
continue;
pZ = p;
}
return pZ;
} /* dns_hints_i_skip() */
static struct dns_hints_i *dns_hints_i_init(struct dns_hints_i *i, struct dns_hints *hints) {
static const struct dns_hints_i i_initializer;
struct dns_hints_soa *soa;
i->state = i_initializer.state;
do {
i->state.seed = dns_random();
} while (0 == i->state.seed);
if ((soa = dns_hints_fetch(hints, i->zone))) {
i->state.next = dns_hints_i_start(i, soa);
}
return i;
} /* dns_hints_i_init() */
unsigned dns_hints_grep(struct sockaddr **sa, socklen_t *sa_len, unsigned lim, struct dns_hints_i *i, struct dns_hints *H) {
struct dns_hints_soa *soa;
unsigned n;
if (!(soa = dns_hints_fetch(H, i->zone)))
return 0;
n = 0;
while (i->state.next < soa->count && n < lim) {
*sa = (struct sockaddr *)&soa->addrs[i->state.next].ss;
*sa_len = dns_sa_len(*sa);
sa++;
sa_len++;
n++;
i->state.next = dns_hints_i_skip(i->state.next, i, soa);
}
return n;
} /* dns_hints_grep() */
struct dns_packet *dns_hints_query(struct dns_hints *hints, struct dns_packet *Q, int *error_) {
struct dns_packet *A, *P;
struct dns_rr rr;
char zone[DNS_D_MAXNAME + 1];
size_t zlen;
struct dns_hints_i i;
struct sockaddr *sa;
socklen_t slen;
int error;
if (!dns_rr_grep(&rr, 1, dns_rr_i_new(Q, .section = DNS_S_QUESTION), Q, &error))
goto error;
if (!(zlen = dns_d_expand(zone, sizeof zone, rr.dn.p, Q, &error)))
goto error;
else if (zlen >= sizeof zone)
goto toolong;
P = dns_p_new(512);
dns_header(P)->qr = 1;
if ((error = dns_rr_copy(P, &rr, Q)))
goto error;
if ((error = dns_p_push(P, DNS_S_AUTHORITY, ".", strlen("."), DNS_T_NS, DNS_C_IN, 0, "hints.local.")))
goto error;
do {
i.zone = zone;
dns_hints_i_init(&i, hints);
while (dns_hints_grep(&sa, &slen, 1, &i, hints)) {
int af = sa->sa_family;
int rtype = (af == AF_INET6)? DNS_T_AAAA : DNS_T_A;
if ((error = dns_p_push(P, DNS_S_ADDITIONAL, "hints.local.", strlen("hints.local."), rtype, DNS_C_IN, 0, dns_sa_addr(af, sa, NULL))))
goto error;
}
} while ((zlen = dns_d_cleave(zone, sizeof zone, zone, zlen)));
if (!(A = dns_p_copy(dns_p_make(P->end, &error), P)))
goto error;
return A;
toolong:
error = DNS_EILLEGAL;
error:
*error_ = error;
return 0;
} /* dns_hints_query() */
/**
* Fill a whole sockaddr from the the nameservers' sockaddr contained in the hints. This is needed for scope link IPv6 nameservers.
**/
static void dns_fill_sockaddr_from_hints(struct dns_hints *hints, int af, struct sockaddr *addr) {
struct dns_hints_soa *soa;
unsigned i;
for (soa = hints->head; soa; soa = soa->next) {
for (i = 0; i < soa->count; i++) {
if (af != soa->addrs[i].ss.ss_family)
continue;
if ((af == AF_INET)
&& (memcmp(&((struct sockaddr_in *)&soa->addrs[i].ss)->sin_addr, &((struct sockaddr_in *)addr)->sin_addr, sizeof(struct in_addr))))
continue;
if ((af == AF_INET6)
&& (memcmp(&((struct sockaddr_in6 *)&soa->addrs[i].ss)->sin6_addr, &((struct sockaddr_in6 *)addr)->sin6_addr, sizeof(struct in6_addr))))
continue;
memcpy(addr, &soa->addrs[i].ss, dns_af_len(af));
return;
}
}
}
int dns_hints_dump(struct dns_hints *hints, FILE *fp) {
struct dns_hints_soa *soa;
char addr[INET6_ADDRSTRLEN];
unsigned i;
int af, error;
for (soa = hints->head; soa; soa = soa->next) {
fprintf(fp, "ZONE \"%s\"\n", soa->zone);
for (i = 0; i < soa->count; i++) {
af = soa->addrs[i].ss.ss_family;
if ((error = dns_ntop(af, dns_sa_addr(af, &soa->addrs[i].ss, NULL), addr, sizeof addr)))
return error;
fprintf(fp, "\t(%d) [%s]:%hu\n", (int)soa->addrs[i].priority, addr, ntohs(*dns_sa_port(af, &soa->addrs[i].ss)));
}
}
return 0;
} /* dns_hints_dump() */
/*
* C A C H E R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static dns_refcount_t dns_cache_acquire(struct dns_cache *cache) {
return dns_atomic_fetch_add(&cache->_.refcount);
} /* dns_cache_acquire() */
static dns_refcount_t dns_cache_release(struct dns_cache *cache) {
return dns_atomic_fetch_sub(&cache->_.refcount);
} /* dns_cache_release() */
static struct dns_packet *dns_cache_query(struct dns_packet *query, struct dns_cache *cache, int *error) {
(void)query;
(void)cache;
(void)error;
return NULL;
} /* dns_cache_query() */
static int dns_cache_submit(struct dns_packet *query, struct dns_cache *cache) {
(void)query;
(void)cache;
return 0;
} /* dns_cache_submit() */
static int dns_cache_check(struct dns_cache *cache) {
(void)cache;
return 0;
} /* dns_cache_check() */
static struct dns_packet *dns_cache_fetch(struct dns_cache *cache, int *error) {
(void)cache;
(void)error;
return NULL;
} /* dns_cache_fetch() */
static int dns_cache_pollfd(struct dns_cache *cache) {
(void)cache;
return -1;
} /* dns_cache_pollfd() */
static short dns_cache_events(struct dns_cache *cache) {
(void)cache;
return 0;
} /* dns_cache_events() */
static void dns_cache_clear(struct dns_cache *cache) {
(void)cache;
return;
} /* dns_cache_clear() */
struct dns_cache *dns_cache_init(struct dns_cache *cache) {
static const struct dns_cache c_init = {
.acquire = &dns_cache_acquire,
.release = &dns_cache_release,
.query = &dns_cache_query,
.submit = &dns_cache_submit,
.check = &dns_cache_check,
.fetch = &dns_cache_fetch,
.pollfd = &dns_cache_pollfd,
.events = &dns_cache_events,
.clear = &dns_cache_clear,
._ = { .refcount = 1, },
};
*cache = c_init;
return cache;
} /* dns_cache_init() */
void dns_cache_close(struct dns_cache *cache) {
if (cache)
cache->release(cache);
} /* dns_cache_close() */
/*
* S O C K E T R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void dns_socketclose(int *fd, const struct dns_options *opts) {
if (opts && opts->closefd.cb)
opts->closefd.cb(fd, opts->closefd.arg);
if (*fd != -1) {
#if _WIN32
closesocket(*fd);
#else
close(*fd);
#endif
*fd = -1;
}
} /* dns_socketclose() */
#ifndef HAVE_IOCTLSOCKET
#define HAVE_IOCTLSOCKET (_WIN32 || _WIN64)
#endif
#ifndef HAVE_SOCK_CLOEXEC
#if (defined SOCK_CLOEXEC)
#define HAVE_SOCK_CLOEXEC 1
#endif
#endif
#ifndef HAVE_SOCK_NONBLOCK
#if (defined SOCK_NONBLOCK)
#define HAVE_SOCK_NONBLOCK 1
#endif
#endif
#define DNS_SO_MAXTRY 7
static int dns_socket(struct sockaddr *local, int type, int *error_) {
int fd = -1, flags, error;
#if defined FIONBIO
unsigned long opt;
#endif
flags = 0;
#if HAVE_SOCK_CLOEXEC
flags |= SOCK_CLOEXEC;
#endif
#if HAVE_SOCK_NONBLOCK
flags |= SOCK_NONBLOCK;
#endif
if (-1 == (fd = socket(local->sa_family, type|flags, 0)))
goto soerr;
if (local->sa_family == AF_INET6){
int value=0;
setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&value, sizeof(value));
}
#if defined F_SETFD && !HAVE_SOCK_CLOEXEC
if (-1 == fcntl(fd, F_SETFD, 1))
goto syerr;
#endif
#if defined O_NONBLOCK && !HAVE_SOCK_NONBLOCK
if (-1 == (flags = fcntl(fd, F_GETFL)))
goto syerr;
if (-1 == fcntl(fd, F_SETFL, flags | O_NONBLOCK))
goto syerr;
#elif defined FIONBIO && HAVE_IOCTLSOCKET
opt = 1;
if (0 != ioctlsocket(fd, FIONBIO, &opt))
goto soerr;
#endif
#if defined SO_NOSIGPIPE
if (type != SOCK_DGRAM) {
if (0 != setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &(int){ 1 }, sizeof (int)))
goto soerr;
}
#endif
if (local->sa_family != AF_INET && local->sa_family != AF_INET6)
return fd;
if (type != SOCK_DGRAM)
return fd;
/*
* FreeBSD, Linux, OpenBSD, OS X, and Solaris use random ports by
* default. Though the ephemeral range is quite small on OS X
* (49152-65535 on 10.10) and Linux (32768-60999 on 4.4.0, Ubuntu
* Xenial). See also RFC 6056.
*
* TODO: Optionally rely on the kernel to select a random port.
*/
if (*dns_sa_port(local->sa_family, local) == 0) {
/*bellesip: let the system find a random port*/
return fd;
/* NB: continue to next bind statement */
}
if (0 == bind(fd, local, dns_sa_len(local)))
return fd;
/* FALL THROUGH */
soerr:
error = dns_soerr();
goto error;
#if (defined F_SETFD && !HAVE_SOCK_CLOEXEC) || (defined O_NONBLOCK && !HAVE_SOCK_NONBLOCK)
syerr:
error = dns_syerr();
goto error;
#endif
error:
*error_ = error;
dns_socketclose(&fd, NULL);
return -1;
} /* dns_socket() */
enum {
DNS_SO_UDP_INIT = 1,
DNS_SO_UDP_CONN,
DNS_SO_UDP_SEND,
DNS_SO_UDP_RECV,
DNS_SO_UDP_DONE,
DNS_SO_TCP_INIT,
DNS_SO_TCP_CONN,
DNS_SO_TCP_SEND,
DNS_SO_TCP_RECV,
DNS_SO_TCP_DONE,
};
struct dns_socket {
struct dns_options opts;
int udp;
int tcp;
int *old;
unsigned onum, olim;
int type;
struct sockaddr_storage local, remote;
struct dns_k_permutor qids;
struct dns_stat stat;
/*
* NOTE: dns_so_reset() zeroes everything from here down.
*/
int state;
unsigned short qid;
char qname[DNS_D_MAXNAME + 1];
size_t qlen;
enum dns_type qtype;
enum dns_class qclass;
struct dns_packet *query;
size_t qout;
struct dns_clock elapsed;
struct dns_packet *answer;
size_t alen, apos;
int ip_differ; /*set when remote address and response from which it is received are different*/
}; /* struct dns_socket */
/*
* NOTE: Actual closure delayed so that kqueue(2) and epoll(2) callers have
* a chance to recognize a state change after installing a persistent event
* and where sequential descriptors with the same integer value returned
* from _pollfd() would be ambiguous. See dns_so_closefds().
*/
static int dns_so_closefd(struct dns_socket *so, int *fd) {
int error;
if (*fd == -1)
return 0;
if (so->opts.closefd.cb) {
if ((error = so->opts.closefd.cb(fd, so->opts.closefd.arg))) {
return error;
} else if (*fd == -1)
return 0;
}
if (!(so->onum < so->olim)) {
unsigned olim = DNS_PP_MAX(4, so->olim * 2);
void *old;
if (!(old = realloc(so->old, sizeof so->old[0] * olim)))
return dns_syerr();
so->old = old;
so->olim = olim;
}
so->old[so->onum++] = *fd;
*fd = -1;
return 0;
} /* dns_so_closefd() */
#define DNS_SO_CLOSE_UDP 0x01
#define DNS_SO_CLOSE_TCP 0x02
#define DNS_SO_CLOSE_OLD 0x04
#define DNS_SO_CLOSE_ALL (DNS_SO_CLOSE_UDP|DNS_SO_CLOSE_TCP|DNS_SO_CLOSE_OLD)
static void dns_so_closefds(struct dns_socket *so, int which) {
if (DNS_SO_CLOSE_UDP & which)
dns_socketclose(&so->udp, &so->opts);
if (DNS_SO_CLOSE_TCP & which)
dns_socketclose(&so->tcp, &so->opts);
if (DNS_SO_CLOSE_OLD & which) {
unsigned i;
for (i = 0; i < so->onum; i++)
dns_socketclose(&so->old[i], &so->opts);
so->onum = 0;
free(so->old);
so->old = 0;
so->olim = 0;
}
} /* dns_so_closefds() */
static void dns_so_destroy(struct dns_socket *);
static struct dns_socket *dns_so_init(struct dns_socket *so, const struct sockaddr *local, int type, const struct dns_options *opts, int *error) {
static const struct dns_socket so_initializer = { .opts = DNS_OPTS_INITIALIZER, .udp = -1, .tcp = -1};
*so = so_initializer;
so->type = type;
if (opts)
so->opts = *opts;
if (local)
memcpy(&so->local, local, dns_sa_len(local));
if (-1 == (so->udp = dns_socket((struct sockaddr *)&so->local, SOCK_DGRAM, error)))
goto error;
dns_k_permutor_init(&so->qids, 1, 65535);
return so;
error:
dns_so_destroy(so);
return 0;
} /* dns_so_init() */
struct dns_socket *dns_so_open(const struct sockaddr *local, int type, const struct dns_options *opts, int *error) {
struct dns_socket *so;
if (!(so = malloc(sizeof *so)))
goto syerr;
if (!dns_so_init(so, local, type, opts, error))
goto error;
return so;
syerr:
*error = dns_syerr();
error:
dns_so_close(so);
return 0;
} /* dns_so_open() */
static void dns_so_destroy(struct dns_socket *so) {
dns_so_reset(so);
dns_so_closefds(so, DNS_SO_CLOSE_ALL);
} /* dns_so_destroy() */
void dns_so_close(struct dns_socket *so) {
if (!so)
return;
dns_so_destroy(so);
free(so);
} /* dns_so_close() */
void dns_so_reset(struct dns_socket *so) {
dns_p_setptr(&so->answer, NULL);
memset(&so->state, '\0', sizeof *so - offsetof(struct dns_socket, state));
} /* dns_so_reset() */
unsigned short dns_so_mkqid(struct dns_socket *so) {
return dns_k_permutor_step(&so->qids);
} /* dns_so_mkqid() */
#define DNS_SO_MINBUF 768
static int dns_so_newanswer(struct dns_socket *so, size_t len) {
size_t size = offsetof(struct dns_packet, data) + DNS_PP_MAX(len, DNS_SO_MINBUF);
void *p;
if (!(p = realloc(so->answer, size)))
return dns_syerr();
so->answer = dns_p_init(p, size);
return 0;
} /* dns_so_newanswer() */
int dns_so_submit(struct dns_socket *so, struct dns_packet *Q, struct sockaddr *host) {
struct dns_rr rr;
int error = DNS_EUNKNOWN;
dns_so_reset(so);
if ((error = dns_rr_parse(&rr, 12, Q)))
goto error;
if (!(so->qlen = dns_d_expand(so->qname, sizeof so->qname, rr.dn.p, Q, &error)))
goto error;
/*
* NOTE: Don't bail if expansion is too long; caller may be
* intentionally sending long names. However, we won't be able to
* verify it on return.
*/
so->qtype = rr.type;
so->qclass = rr.class;
if ((error = dns_so_newanswer(so, (Q->memo.opt.maxudp)? Q->memo.opt.maxudp : DNS_SO_MINBUF)))
goto syerr;
if (so->local.ss_family==AF_INET6 && host->sa_family==AF_INET){
socklen_t addrlen = sizeof(so->remote);
uint32_t *addr=(uint32_t*)dns_sa_addr(AF_INET6,&so->remote, &addrlen);
/* add v4mapping*/
so->remote.ss_family=AF_INET6;
addr[0]=0;
addr[1]=0;
addr[2]=ntohl(0xffff);
addr[3]=((struct sockaddr_in*)host)->sin_addr.s_addr;
*dns_sa_port(AF_INET6,&so->remote)=((struct sockaddr_in*)host)->sin_port;
}else memcpy(&so->remote, host, dns_sa_len(host));
so->query = Q;
so->qout = 0;
dns_begin(&so->elapsed);
if (dns_header(so->query)->qid == 0)
dns_header(so->query)->qid = dns_so_mkqid(so);
so->qid = dns_header(so->query)->qid;
so->state = (so->type == SOCK_STREAM)? DNS_SO_TCP_INIT : DNS_SO_UDP_INIT;
so->stat.queries++;
return 0;
syerr:
error = dns_syerr();
error:
dns_so_reset(so);
return error;
} /* dns_so_submit() */
static int dns_so_verify(struct dns_socket *so, struct dns_packet *P) {
char qname[DNS_D_MAXNAME + 1];
size_t qlen;
struct dns_rr rr;
int error = -1;
if (so->qid != dns_header(so->answer)->qid)
goto reject;
if (!dns_p_count(so->answer, DNS_S_QD))
goto reject;
if (0 != dns_rr_parse(&rr, 12, so->answer))
goto reject;
if (rr.type != so->qtype || rr.class != so->qclass)
goto reject;
if (!(qlen = dns_d_expand(qname, sizeof qname, rr.dn.p, P, &error)))
goto error;
else if (qlen >= sizeof qname || qlen != so->qlen)
goto reject;
if (0 != strcasecmp(so->qname, qname))
goto reject;
return 0;
reject:
error = DNS_EUNKNOWN;
error:
DNS_SHOW(P, "rejecting packet (%s)", dns_strerror(error));
return error;
} /* dns_so_verify() */
static _Bool dns_so_tcp_keep(struct dns_socket *so) {
struct sockaddr_storage remote;
if (so->tcp == -1)
return 0;
if (0 != getpeername(so->tcp, (struct sockaddr *)&remote, &(socklen_t){ sizeof remote }))
return 0;
return 0 == dns_sa_cmp(&remote, &so->remote);
} /* dns_so_tcp_keep() */
#if defined __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warray-bounds"
#endif
static int dns_so_tcp_send(struct dns_socket *so) {
unsigned char *qsrc;
size_t qend;
long n;
so->query->data[-2] = 0xff & (so->query->end >> 8);
so->query->data[-1] = 0xff & (so->query->end >> 0);
qsrc = &so->query->data[-2] + so->qout;
qend = so->query->end + 2;
while (so->qout < qend) {
if (0 > (n = dns_send(so->tcp, (void *)&qsrc[so->qout], qend - so->qout, 0)))
return dns_soerr();
so->qout += n;
so->stat.tcp.sent.bytes += n;
}
so->stat.tcp.sent.count++;
return 0;
} /* dns_so_tcp_send() */
static int dns_so_tcp_recv(struct dns_socket *so) {
unsigned char *asrc;
size_t aend, alen;
int error;
long n;
aend = so->alen + 2;
while (so->apos < aend) {
asrc = &so->answer->data[-2];
if (0 > (n = recv(so->tcp, (void *)&asrc[so->apos], aend - so->apos, 0)))
return dns_soerr();
else if (n == 0)
return DNS_EUNKNOWN; /* FIXME */
so->apos += n;
so->stat.tcp.rcvd.bytes += n;
if (so->alen == 0 && so->apos >= 2) {
alen = ((0xff & so->answer->data[-2]) << 8)
| ((0xff & so->answer->data[-1]) << 0);
if ((error = dns_so_newanswer(so, alen)))
return error;
so->alen = alen;
aend = alen + 2;
}
}
so->answer->end = so->alen;
so->stat.tcp.rcvd.count++;
return 0;
} /* dns_so_tcp_recv() */
#if __clang__
#pragma clang diagnostic pop
#endif
int dns_so_check(struct dns_socket *so) {
struct sockaddr_storage tmp_ss;
socklen_t tmp_ss_len = sizeof(tmp_ss);
int error;
long n;
retry:
switch (so->state) {
case DNS_SO_UDP_INIT:
so->state++;
case DNS_SO_UDP_CONN:
memset(&tmp_ss, 0, sizeof(tmp_ss));
connect(so->udp, (struct sockaddr *)&tmp_ss, sizeof(tmp_ss)); // Reset the previous connection
if (so->opts.udp_uses_connect){
if (0 != connect(so->udp, (struct sockaddr *)&so->remote, dns_sa_len(&so->remote)))
goto soerr;
}
so->state++;
case DNS_SO_UDP_SEND:
if (so->opts.udp_uses_connect){
if (0 > (n = send(so->udp, (void *)so->query->data, so->query->end, 0)))
goto soerr;
}else{
if (0 > (n = sendto(so->udp, (void *)so->query->data, so->query->end, 0, (struct sockaddr *)&so->remote, dns_sa_len(&so->remote))))
goto soerr;
}
so->stat.udp.sent.bytes += n;
so->stat.udp.sent.count++;
so->state++;
case DNS_SO_UDP_RECV:
if (so->opts.udp_uses_connect){
if (0 > (n = recv(so->udp, (void *)so->answer->data, so->answer->size, 0)))
goto soerr;
}else{
memset(&tmp_ss, 0, sizeof(tmp_ss));
tmp_ss_len = sizeof(tmp_ss);
if (0 > (n = recvfrom(so->udp, (void *)so->answer->data, so->answer->size, 0, (struct sockaddr *)&tmp_ss, &tmp_ss_len)))
goto soerr;
if (memcmp(&tmp_ss, &so->remote, tmp_ss_len) != 0){
so->ip_differ = 1;
}
}
so->stat.udp.rcvd.bytes += n;
so->stat.udp.rcvd.count++;
if ((so->answer->end = n) < 12)
goto trash;
if ((error = dns_so_verify(so, so->answer)))
goto trash;
so->state++;
case DNS_SO_UDP_DONE:
if (!dns_header(so->answer)->tc || so->type == SOCK_DGRAM)
return 0;
so->state++;
case DNS_SO_TCP_INIT:
if (dns_so_tcp_keep(so)) {
so->state = DNS_SO_TCP_SEND;
goto retry;
}
if ((error = dns_so_closefd(so, &so->tcp)))
goto error;
if (-1 == (so->tcp = dns_socket((struct sockaddr *)&so->local, SOCK_STREAM, &error)))
goto error;
so->state++;
case DNS_SO_TCP_CONN:
if (0 != connect(so->tcp, (struct sockaddr *)&so->remote, dns_sa_len(&so->remote))) {
if (dns_soerr() != DNS_EISCONN)
goto soerr;
}
so->state++;
case DNS_SO_TCP_SEND:
if ((error = dns_so_tcp_send(so)))
goto error;
so->state++;
case DNS_SO_TCP_RECV:
if ((error = dns_so_tcp_recv(so)))
goto error;
so->state++;
case DNS_SO_TCP_DONE:
/* close unless DNS_RESCONF_TCP_ONLY (see dns_res_tcp2type) */
if (so->type != SOCK_STREAM) {
if ((error = dns_so_closefd(so, &so->tcp)))
goto error;
}
if (so->answer->end < 12)
return DNS_EILLEGAL;
if ((error = dns_so_verify(so, so->answer)))
goto error;
return 0;
default:
error = DNS_EUNKNOWN;
goto error;
} /* switch() */
trash:
DNS_CARP("discarding packet");
goto retry;
soerr:
error = dns_soerr();
goto error;
error:
switch (error) {
case DNS_EINTR:
goto retry;
case DNS_EINPROGRESS:
/* FALL THROUGH */
case DNS_EALREADY:
/* FALL THROUGH */
#if DNS_EWOULDBLOCK != DNS_EAGAIN
case DNS_EWOULDBLOCK:
/* FALL THROUGH */
#endif
error = DNS_EAGAIN;
break;
} /* switch() */
return error;
} /* dns_so_check() */
struct dns_packet *dns_so_fetch(struct dns_socket *so, int *error) {
struct dns_packet *answer;
switch (so->state) {
case DNS_SO_UDP_DONE:
case DNS_SO_TCP_DONE:
answer = so->answer;
so->answer = 0;
return answer;
default:
*error = DNS_EUNKNOWN;
return 0;
}
} /* dns_so_fetch() */
struct dns_packet *dns_so_query(struct dns_socket *so, struct dns_packet *Q, struct sockaddr *host, int *error_) {
struct dns_packet *A;
int error;
if (!so->state) {
if ((error = dns_so_submit(so, Q, host)))
goto error;
}
if ((error = dns_so_check(so)))
goto error;
if (!(A = dns_so_fetch(so, &error)))
goto error;
dns_so_reset(so);
return A;
error:
*error_ = error;
return 0;
} /* dns_so_query() */
time_t dns_so_elapsed(struct dns_socket *so) {
return dns_elapsed(&so->elapsed);
} /* dns_so_elapsed() */
void dns_so_clear(struct dns_socket *so) {
dns_so_closefds(so, DNS_SO_CLOSE_OLD);
} /* dns_so_clear() */
static int dns_so_events2(struct dns_socket *so, enum dns_events type) {
int events = 0;
switch (so->state) {
case DNS_SO_UDP_CONN:
case DNS_SO_UDP_SEND:
events |= DNS_POLLOUT;
break;
case DNS_SO_UDP_RECV:
events |= DNS_POLLIN;
break;
case DNS_SO_TCP_CONN:
case DNS_SO_TCP_SEND:
events |= DNS_POLLOUT;
break;
case DNS_SO_TCP_RECV:
events |= DNS_POLLIN;
break;
} /* switch() */
switch (type) {
case DNS_LIBEVENT:
return DNS_POLL2EV(events);
default:
return events;
} /* switch() */
} /* dns_so_events2() */
int dns_so_events(struct dns_socket *so) {
return dns_so_events2(so, so->opts.events);
} /* dns_so_events() */
int dns_so_pollfd(struct dns_socket *so) {
switch (so->state) {
case DNS_SO_UDP_CONN:
case DNS_SO_UDP_SEND:
case DNS_SO_UDP_RECV:
return so->udp;
case DNS_SO_TCP_CONN:
case DNS_SO_TCP_SEND:
case DNS_SO_TCP_RECV:
return so->tcp;
} /* switch() */
return -1;
} /* dns_so_pollfd() */
int dns_so_poll(struct dns_socket *so, int timeout) {
return dns_poll(dns_so_pollfd(so), dns_so_events2(so, DNS_SYSPOLL), timeout);
} /* dns_so_poll() */
const struct dns_stat *dns_so_stat(struct dns_socket *so) {
return &so->stat;
} /* dns_so_stat() */
/*
* R E S O L V E R R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
enum dns_res_state {
DNS_R_INIT,
DNS_R_GLUE,
DNS_R_SWITCH, /* (B)IND, (F)ILE, (C)ACHE */
DNS_R_FILE, /* Lookup in local hosts database */
DNS_R_CACHE, /* Lookup in application cache */
DNS_R_SUBMIT,
DNS_R_CHECK,
DNS_R_FETCH,
DNS_R_BIND, /* Lookup in the network */
DNS_R_SEARCH,
DNS_R_HINTS,
DNS_R_ITERATE,
DNS_R_FOREACH_NS,
DNS_R_RESOLV0_NS, /* Prologue: Setup next frame and recurse */
DNS_R_RESOLV1_NS, /* Epilog: Inspect answer */
DNS_R_FOREACH_A,
DNS_R_QUERY_A,
DNS_R_CNAME0_A,
DNS_R_CNAME1_A,
DNS_R_FINISH,
DNS_R_SMART0_A,
DNS_R_SMART1_A,
DNS_R_DONE,
DNS_R_SERVFAIL,
}; /* enum dns_res_state */
#define DNS_R_MAXDEPTH 8
#define DNS_R_ENDFRAME (DNS_R_MAXDEPTH - 1)
struct dns_resolver {
struct dns_socket so;
struct dns_resolv_conf *resconf;
struct dns_hosts *hosts;
struct dns_hints *hints;
struct dns_cache *cache;
dns_atomic_t refcount;
/* Reset zeroes everything below here. */
char qname[DNS_D_MAXNAME + 1];
size_t qlen;
enum dns_type qtype;
enum dns_class qclass;
struct dns_clock elapsed;
dns_resconf_i_t search;
struct dns_rr_i smart;
struct dns_packet *nodata; /* answer if nothing better */
unsigned sp;
struct dns_res_frame {
enum dns_res_state state;
int error;
int which; /* (B)IND, (F)ILE; index into resconf->lookup */
int qflags;
unsigned attempts;
struct dns_packet *query, *answer, *hints;
struct dns_rr_i hints_i, hints_j;
struct dns_rr hints_ns, ans_cname;
} stack[DNS_R_MAXDEPTH];
unsigned char search_enabled;
}; /* struct dns_resolver */
static int dns_res_tcp2type(int tcp) {
switch (tcp) {
case DNS_RESCONF_TCP_ONLY:
return SOCK_STREAM;
case DNS_RESCONF_TCP_DISABLE:
return SOCK_DGRAM;
default:
return 0;
}
} /* dns_res_tcp2type() */
struct dns_resolver *dns_res_open(struct dns_resolv_conf *resconf, struct dns_hosts *hosts, struct dns_hints *hints, struct dns_cache *cache, const struct dns_options *opts, int *_error) {
static const struct dns_resolver R_initializer
= { .refcount = 1, };
struct dns_resolver *R = 0;
int type, error;
/*
* Grab ref count early because the caller may have passed us a mortal
* reference, and we want to do the right thing if we return early
* from an error.
*/
if (resconf)
dns_resconf_acquire(resconf);
if (hosts)
dns_hosts_acquire(hosts);
if (hints)
dns_hints_acquire(hints);
if (cache)
dns_cache_acquire(cache);
/*
* Don't try to load it ourselves because a NULL object might be an
* error from, say, dns_resconf_root(), and loading
* dns_resconf_local() by default would create undesirable surpises.
*/
if (!resconf || !hosts || !hints)
goto _error;
if (!(R = malloc(sizeof *R)))
goto syerr;
*R = R_initializer;
type = dns_res_tcp2type(resconf->options.tcp);
if (!dns_so_init(&R->so, (struct sockaddr *)&resconf->iface, type, opts, &error))
goto error;
R->resconf = resconf;
R->hosts = hosts;
R->hints = hints;
R->cache = cache;
return R;
syerr:
error = dns_syerr();
error:
*_error = error;
_error:
dns_res_close(R);
dns_resconf_close(resconf);
dns_hosts_close(hosts);
dns_hints_close(hints);
dns_cache_close(cache);
return 0;
} /* dns_res_open() */
struct dns_resolver *dns_res_stub(const struct dns_options *opts, int *error) {
struct dns_resolv_conf *resconf = 0;
struct dns_hosts *hosts = 0;
struct dns_hints *hints = 0;
struct dns_resolver *res = 0;
if (!(resconf = dns_resconf_local(error)))
goto epilog;
if (!(hosts = dns_hosts_local(error)))
goto epilog;
if (!(hints = dns_hints_local(resconf, error)))
goto epilog;
if (!(res = dns_res_open(resconf, hosts, hints, NULL, opts, error)))
goto epilog;
epilog:
dns_resconf_close(resconf);
dns_hosts_close(hosts);
dns_hints_close(hints);
return res;
} /* dns_res_stub() */
static void dns_res_frame_destroy(struct dns_resolver *R, struct dns_res_frame *frame) {
(void)R;
dns_p_setptr(&frame->query, NULL);
dns_p_setptr(&frame->answer, NULL);
dns_p_setptr(&frame->hints, NULL);
} /* dns_res_frame_destroy() */
static void dns_res_frame_init(struct dns_resolver *R, struct dns_res_frame *frame) {
memset(frame, '\0', sizeof *frame);
if (R != NULL && R->resconf != NULL) {
if (!R->resconf->options.recurse)
frame->qflags |= DNS_Q_RD;
if (R->resconf->options.edns0)
frame->qflags |= DNS_Q_EDNS0;
}
} /* dns_res_frame_init() */
static void dns_res_frame_reset(struct dns_resolver *R, struct dns_res_frame *frame) {
dns_res_frame_destroy(R, frame);
dns_res_frame_init(R, frame);
} /* dns_res_frame_reset() */
static dns_error_t dns_res_frame_prepare(struct dns_resolver *R, struct dns_res_frame *F, const char *qname, enum dns_type qtype, enum dns_class qclass) {
struct dns_packet *P = NULL;
if (!(F < endof(R->stack)))
return DNS_EUNKNOWN;
dns_p_movptr(&P, &F->query);
dns_res_frame_reset(R, F);
dns_p_movptr(&F->query, &P);
return dns_q_make(&F->query, qname, qtype, qclass, F->qflags);
} /* dns_res_frame_prepare() */
void dns_res_reset(struct dns_resolver *R) {
unsigned i;
dns_so_reset(&R->so);
dns_p_setptr(&R->nodata, NULL);
for (i = 0; i < lengthof(R->stack); i++)
dns_res_frame_destroy(R, &R->stack[i]);
memset(&R->qname, '\0', sizeof *R - offsetof(struct dns_resolver, qname));
for (i = 0; i < lengthof(R->stack); i++)
dns_res_frame_init(R, &R->stack[i]);
} /* dns_res_reset() */
void dns_res_close(struct dns_resolver *R) {
if (!R || 1 < dns_res_release(R))
return;
dns_res_reset(R);
dns_so_destroy(&R->so);
dns_hints_close(R->hints);
dns_hosts_close(R->hosts);
dns_resconf_close(R->resconf);
dns_cache_close(R->cache);
free(R);
} /* dns_res_close() */
dns_refcount_t dns_res_acquire(struct dns_resolver *R) {
return dns_atomic_fetch_add(&R->refcount);
} /* dns_res_acquire() */
dns_refcount_t dns_res_release(struct dns_resolver *R) {
return dns_atomic_fetch_sub(&R->refcount);
} /* dns_res_release() */
struct dns_resolver *dns_res_mortal(struct dns_resolver *res) {
if (res)
dns_res_release(res);
return res;
} /* dns_res_mortal() */
static struct dns_packet *dns_res_merge(struct dns_packet *P0, struct dns_packet *P1, int *error_) {
size_t bufsiz = P0->end + P1->end;
struct dns_packet *P[3] = { P0, P1, 0 };
struct dns_rr rr[3];
int error, copy, i;
enum dns_section section;
retry:
if (!(P[2] = dns_p_make(bufsiz, &error)))
goto error;
dns_rr_foreach(&rr[0], P[0], .section = DNS_S_QD) {
if ((error = dns_rr_copy(P[2], &rr[0], P[0])))
goto error;
}
for (section = DNS_S_AN; (DNS_S_ALL & section); section <<= 1) {
for (i = 0; i < 2; i++) {
dns_rr_foreach(&rr[i], P[i], .section = section) {
copy = 1;
dns_rr_foreach(&rr[2], P[2], .type = rr[i].type, .section = (DNS_S_ALL & ~DNS_S_QD)) {
if (0 == dns_rr_cmp(&rr[i], P[i], &rr[2], P[2])) {
copy = 0;
break;
}
}
if (copy && (error = dns_rr_copy(P[2], &rr[i], P[i]))) {
if (error == DNS_ENOBUFS && bufsiz < 65535) {
dns_p_setptr(&P[2], NULL);
bufsiz = DNS_PP_MAX(65535, bufsiz * 2);
goto retry;
}
goto error;
}
} /* foreach(rr) */
} /* foreach(packet) */
} /* foreach(section) */
return P[2];
error:
*error_ = error;
dns_p_free(P[2]);
return 0;
} /* dns_res_merge() */
static struct dns_packet *dns_res_glue(struct dns_resolver *R, struct dns_packet *Q) {
struct dns_packet *P = dns_p_new(512);
char qname[DNS_D_MAXNAME + 1];
size_t qlen;
enum dns_type qtype;
struct dns_rr rr;
unsigned sp;
int error;
if (!(qlen = dns_d_expand(qname, sizeof qname, 12, Q, &error))
|| qlen >= sizeof qname)
return 0;
if (!(qtype = dns_rr_type(12, Q)))
return 0;
if ((error = dns_p_push(P, DNS_S_QD, qname, strlen(qname), qtype, DNS_C_IN, 0, 0)))
return 0;
for (sp = 0; sp <= R->sp; sp++) {
if (!R->stack[sp].answer)
continue;
dns_rr_foreach(&rr, R->stack[sp].answer, .name = qname, .type = qtype, .section = (DNS_S_ALL & ~DNS_S_QD)) {
rr.section = DNS_S_AN;
if ((error = dns_rr_copy(P, &rr, R->stack[sp].answer)))
return 0;
}
}
if (dns_p_count(P, DNS_S_AN) > 0)
goto copy;
/* Otherwise, look for a CNAME */
for (sp = 0; sp <= R->sp; sp++) {
if (!R->stack[sp].answer)
continue;
dns_rr_foreach(&rr, R->stack[sp].answer, .name = qname, .type = DNS_T_CNAME, .section = (DNS_S_ALL & ~DNS_S_QD)) {
rr.section = DNS_S_AN;
if ((error = dns_rr_copy(P, &rr, R->stack[sp].answer)))
return 0;
}
}
if (!dns_p_count(P, DNS_S_AN))
return 0;
copy:
return dns_p_copy(dns_p_make(P->end, &error), P);
} /* dns_res_glue() */
/*
* Sort NS records by three criteria:
*
* 1) Whether glue is present.
* 2) Whether glue record is original or of recursive lookup.
* 3) Randomly shuffle records which share the above criteria.
*
* NOTE: Assumes only NS records passed, AND ASSUMES no new NS records will
* be added during an iteration.
*
* FIXME: Only groks A glue, not AAAA glue.
*/
static int dns_res_nameserv_cmp(struct dns_rr *a, struct dns_rr *b, struct dns_rr_i *i, struct dns_packet *P) {
_Bool glued[2] = { 0 };
struct dns_rr x = { 0 }, y = { 0 };
struct dns_ns ns;
int cmp, error;
if (!(error = dns_ns_parse(&ns, a, P)))
glued[0] = !!dns_rr_grep(&x, 1, dns_rr_i_new(P, .section = (DNS_S_ALL & ~DNS_S_QD), .name = ns.host, .type = DNS_T_A), P, &error);
if (!(error = dns_ns_parse(&ns, b, P)))
glued[1] = !!dns_rr_grep(&y, 1, dns_rr_i_new(P, .section = (DNS_S_ALL & ~DNS_S_QD), .name = ns.host, .type = DNS_T_A), P, &error);
if ((cmp = glued[1] - glued[0])) {
return cmp;
} else if ((cmp = (dns_rr_offset(&y) < i->args[0]) - (dns_rr_offset(&x) < i->args[0]))) {
return cmp;
} else {
return dns_rr_i_shuffle(a, b, i, P);
}
} /* dns_res_nameserv_cmp() */
#define dgoto(sp, i) \
do { R->stack[(sp)].state = (i); goto exec; } while (0)
static int dns_res_exec(struct dns_resolver *R) {
struct dns_res_frame *F;
struct dns_packet *P;
union {
char host[DNS_D_MAXNAME + 1];
char name[DNS_D_MAXNAME + 1];
struct dns_ns ns;
struct dns_cname cname;
} u;
size_t len;
struct dns_rr rr;
int error;
exec:
F = &R->stack[R->sp];
switch (F->state) {
case DNS_R_INIT:
F->state++;
case DNS_R_GLUE:
if (R->sp == 0)
dgoto(R->sp, DNS_R_SWITCH);
if (!F->query)
goto noquery;
if (!(F->answer = dns_res_glue(R, F->query)))
dgoto(R->sp, DNS_R_SWITCH);
if (!(len = dns_d_expand(u.name, sizeof u.name, 12, F->query, &error)))
goto error;
else if (len >= sizeof u.name)
goto toolong;
dns_rr_foreach(&rr, F->answer, .name = u.name, .type = dns_rr_type(12, F->query), .section = DNS_S_AN) {
dgoto(R->sp, DNS_R_FINISH);
}
dns_rr_foreach(&rr, F->answer, .name = u.name, .type = DNS_T_CNAME, .section = DNS_S_AN) {
F->ans_cname = rr;
dgoto(R->sp, DNS_R_CNAME0_A);
}
F->state++;
case DNS_R_SWITCH:
while (F->which < (int)sizeof R->resconf->lookup && R->resconf->lookup[F->which]) {
switch (R->resconf->lookup[F->which++]) {
case 'b': case 'B':
dgoto(R->sp, DNS_R_BIND);
case 'f': case 'F':
dgoto(R->sp, DNS_R_FILE);
case 'c': case 'C':
if (R->cache)
dgoto(R->sp, DNS_R_CACHE);
break;
default:
break;
}
}
/*
* FIXME: Examine more closely whether our logic is correct
* and DNS_R_SERVFAIL is the correct default response.
*
* Case 1: We got here because we never got an answer on the
* wire. All queries timed-out and we reached maximum
* attempts count. See DNS_R_FOREACH_NS. In that case
* DNS_R_SERVFAIL is the correct state, unless we want to
* return DNS_ETIMEDOUT.
*
* Case 2: We were a stub resolver and got an unsatisfactory
* answer (empty ANSWER section) which caused us to jump
* back to DNS_R_SEARCH and ultimately to DNS_R_SWITCH. We
* return the answer returned from the wire, which we
* stashed in R->nodata.
*
* Case 3: We reached maximum attempts count as in case #1,
* but never got an authoritative response which caused us
* to short-circuit. See end of DNS_R_QUERY_A case. We
* should probably prepare R->nodata as in case #2.
*/
if (R->sp == 0 && R->nodata) { /* XXX: can we just return nodata regardless? */
dns_p_movptr(&F->answer, &R->nodata);
dgoto(R->sp, DNS_R_FINISH);
}
dgoto(R->sp, DNS_R_SERVFAIL);
case DNS_R_FILE:
if (R->sp > 0) {
if (!dns_p_setptr(&F->answer, dns_hosts_query(R->hosts, F->query, &error)))
goto error;
if (dns_p_count(F->answer, DNS_S_AN) > 0)
dgoto(R->sp, DNS_R_FINISH);
dns_p_setptr(&F->answer, NULL);
} else {
R->search = 0;
while ((len = dns_resconf_search(u.name, sizeof u.name, R->qname, R->qlen, R->resconf, &R->search))) {
if ((error = dns_q_make2(&F->query, u.name, len, R->qtype, R->qclass, F->qflags)))
goto error;
if (!dns_p_setptr(&F->answer, dns_hosts_query(R->hosts, F->query, &error)))
goto error;
if (dns_p_count(F->answer, DNS_S_AN) > 0)
dgoto(R->sp, DNS_R_FINISH);
dns_p_setptr(&F->answer, NULL);
}
}
dgoto(R->sp, DNS_R_SWITCH);
case DNS_R_CACHE:
error = 0;
if (!F->query && (error = dns_q_make(&F->query, R->qname, R->qtype, R->qclass, F->qflags)))
goto error;
if (dns_p_setptr(&F->answer, R->cache->query(F->query, R->cache, &error))) {
if (dns_p_count(F->answer, DNS_S_AN) > 0)
dgoto(R->sp, DNS_R_FINISH);
dns_p_setptr(&F->answer, NULL);
dgoto(R->sp, DNS_R_SWITCH);
} else if (error)
goto error;
F->state++;
case DNS_R_SUBMIT:
if ((error = R->cache->submit(F->query, R->cache)))
goto error;
F->state++;
case DNS_R_CHECK:
if ((error = R->cache->check(R->cache)))
goto error;
F->state++;
case DNS_R_FETCH:
error = 0;
if (dns_p_setptr(&F->answer, R->cache->fetch(R->cache, &error))) {
if (dns_p_count(F->answer, DNS_S_AN) > 0)
dgoto(R->sp, DNS_R_FINISH);
dns_p_setptr(&F->answer, NULL);
dgoto(R->sp, DNS_R_SWITCH);
} else if (error)
goto error;
dgoto(R->sp, DNS_R_SWITCH);
case DNS_R_BIND:
if (R->sp > 0) {
if (!F->query)
goto noquery;
dgoto(R->sp, DNS_R_HINTS);
}
R->search = 0;
F->state++;
case DNS_R_SEARCH:
/*
* XXX: We probably should only apply the domain search
* algorithm if R->sp == 0.
*/
if (!(len = dns_resconf_search(u.name, sizeof u.name, R->qname, R->qlen, R->resconf, &R->search)))
dgoto(R->sp, DNS_R_SWITCH);
if ((error = dns_q_make2(&F->query, u.name, len, R->qtype, R->qclass, F->qflags)))
goto error;
F->state++;
case DNS_R_HINTS:
if (!dns_p_setptr(&F->hints, dns_hints_query(R->hints, F->query, &error)))
goto error;
F->state++;
case DNS_R_ITERATE:
dns_rr_i_init(&F->hints_i, F->hints);
F->hints_i.section = DNS_S_AUTHORITY;
F->hints_i.type = DNS_T_NS;
F->hints_i.sort = &dns_res_nameserv_cmp;
F->hints_i.args[0] = F->hints->end;
F->state++;
case DNS_R_FOREACH_NS:
dns_rr_i_save(&F->hints_i);
/* Load our next nameserver host. */
if (!dns_rr_grep(&F->hints_ns, 1, &F->hints_i, F->hints, &error)) {
if (++F->attempts < R->resconf->options.attempts)
dgoto(R->sp, DNS_R_ITERATE);
dgoto(R->sp, DNS_R_SWITCH);
}
dns_rr_i_init(&F->hints_j, F->hints);
/* Assume there are glue records */
dgoto(R->sp, DNS_R_FOREACH_A);
case DNS_R_RESOLV0_NS:
/* Have we reached our max depth? */
if (&F[1] >= endof(R->stack))
dgoto(R->sp, DNS_R_FOREACH_NS);
if ((error = dns_ns_parse(&u.ns, &F->hints_ns, F->hints)))
goto error;
if ((error = dns_res_frame_prepare(R, &F[1], u.ns.host, DNS_T_A, DNS_C_IN)))
goto error;
F->state++;
dgoto(++R->sp, DNS_R_INIT);
case DNS_R_RESOLV1_NS:
if (!(len = dns_d_expand(u.host, sizeof u.host, 12, F[1].query, &error)))
goto error;
else if (len >= sizeof u.host)
goto toolong;
dns_rr_foreach(&rr, F[1].answer, .name = u.host, .type = DNS_T_A, .section = (DNS_S_ALL & ~DNS_S_QD)) {
rr.section = DNS_S_AR;
if ((error = dns_rr_copy(F->hints, &rr, F[1].answer)))
goto error;
dns_rr_i_rewind(&F->hints_i); /* Now there's glue. */
}
dgoto(R->sp, DNS_R_FOREACH_NS);
case DNS_R_FOREACH_A: {
struct sockaddr_storage saddr;
memset(&saddr, 0, sizeof(saddr));
socklen_t saddr_len = sizeof(saddr);
/*
* NOTE: Iterator initialized in DNS_R_FOREACH_NS because
* this state is re-entrant, but we need to reset
* .name to a valid pointer each time.
*/
if ((error = dns_ns_parse(&u.ns, &F->hints_ns, F->hints)))
goto error;
F->hints_j.name = u.ns.host;
F->hints_j.type = DNS_T_ALL;
F->hints_j.section = DNS_S_ALL & ~DNS_S_QD;
if (!dns_rr_grep(&rr, 1, &F->hints_j, F->hints, &error)) {
if (!dns_rr_i_count(&F->hints_j))
dgoto(R->sp, DNS_R_RESOLV0_NS);
dgoto(R->sp, DNS_R_FOREACH_NS);
}
saddr.ss_family = rr.type==DNS_T_AAAA ? AF_INET6 : AF_INET;
if (saddr.ss_family==AF_INET){
if ((error = dns_a_parse((struct dns_a *)dns_sa_addr(saddr.ss_family, &saddr, &saddr_len), &rr, F->hints)))
goto error;
}else{
if ((error = dns_aaaa_parse((struct dns_aaaa *)dns_sa_addr(saddr.ss_family, &saddr, &saddr_len), &rr, F->hints)))
goto error;
}
if (R->sp == 0) dns_fill_sockaddr_from_hints(R->hints, saddr.ss_family, (struct sockaddr *)&saddr);
else *dns_sa_port(saddr.ss_family, &saddr) = htons(53);
if (DNS_DEBUG) {
char addr[INET_ADDRSTRLEN + 1];
if (saddr.ss_family==AF_INET)
dns_a_print(addr, sizeof addr, (struct dns_a *)dns_sa_addr(saddr.ss_family, &saddr, &saddr_len));
else dns_aaaa_print(addr, sizeof addr, (struct dns_aaaa *)dns_sa_addr(saddr.ss_family, &saddr, &saddr_len));
dns_header(F->query)->qid = dns_so_mkqid(&R->so);
DNS_SHOW(F->query, "ASKING: %s/%s @ DEPTH: %u)", u.ns.host, addr, R->sp);
}
if ((error = dns_so_submit(&R->so, F->query, (struct sockaddr *)&saddr)))
goto error;
F->state++;
}
case DNS_R_QUERY_A:
if (dns_so_elapsed(&R->so) >= dns_resconf_timeout(R->resconf))
dgoto(R->sp, DNS_R_FOREACH_A);
if ((error = dns_so_check(&R->so)) != 0){
if (error == DNS_ENETUNREACH
|| error == DNS_ECONNREFUSED
|| error == DNS_ECONNRESET
|| error == EINVAL
|| error == DNS_EHOSTUNREACH) { /* maybe even more case*/
char remote_sock[64];
struct sockaddr *addr = (struct sockaddr*)&R->so.remote;
bctbx_sockaddr_to_printable_ip_address(addr, dns_sa_len(addr), remote_sock, sizeof(remote_sock));
belle_sip_error("Cannot reach [%s] because [%s]", remote_sock, strerror(error));
dgoto(R->sp, DNS_R_FOREACH_A);
} else goto error;
}
if (!dns_p_setptr(&F->answer, dns_so_fetch(&R->so, &error)))
goto error;
if (DNS_DEBUG) {
DNS_SHOW(F->answer, "ANSWER @ DEPTH: %u)", R->sp);
}
if (dns_p_rcode(F->answer) == DNS_RC_FORMERR ||
dns_p_rcode(F->answer) == DNS_RC_NOTIMP ||
dns_p_rcode(F->answer) == DNS_RC_BADVERS) {
/* Temporarily disable EDNS0 and try again. */
if (F->qflags & DNS_Q_EDNS0) {
F->qflags &= ~DNS_Q_EDNS0;
if ((error = dns_q_remake(&F->query, F->qflags)))
goto error;
dgoto(R->sp, DNS_R_FOREACH_A);
}
}
if (dns_p_rcode(F->answer) == DNS_RC_REFUSED) {
dgoto(R->sp, DNS_R_FOREACH_A);
}
if ((error = dns_rr_parse(&rr, 12, F->query)))
goto error;
if (!(len = dns_d_expand(u.name, sizeof u.name, rr.dn.p, F->query, &error)))
goto error;
else if (len >= sizeof u.name)
goto toolong;
dns_rr_foreach(&rr, F->answer, .section = DNS_S_AN, .name = u.name, .type = rr.type) {
dgoto(R->sp, DNS_R_FINISH); /* Found */
}
dns_rr_foreach(&rr, F->answer, .section = DNS_S_AN, .name = u.name, .type = DNS_T_CNAME) {
F->ans_cname = rr;
dgoto(R->sp, DNS_R_CNAME0_A);
}
/*
* XXX: The condition here should probably check whether
* R->sp == 0, because DNS_R_SEARCH runs regardless of
* options.recurse. See DNS_R_BIND.
*/
if (!R->resconf->options.recurse) {
/* Make first answer our tentative answer */
if (!R->nodata)
dns_p_movptr(&R->nodata, &F->answer);
if (R->search_enabled)
dgoto(R->sp, DNS_R_SEARCH);
else
dgoto(R->sp, DNS_R_FINISH);
}
dns_rr_foreach(&rr, F->answer, .section = DNS_S_NS, .type = DNS_T_NS) {
dns_p_movptr(&F->hints, &F->answer);
dgoto(R->sp, DNS_R_ITERATE);
}
/* XXX: Should this go further up? */
if (dns_header(F->answer)->aa)
dgoto(R->sp, DNS_R_FINISH);
/* XXX: Should we copy F->answer to R->nodata? */
dgoto(R->sp, DNS_R_FOREACH_A);
case DNS_R_CNAME0_A:
if (&F[1] >= endof(R->stack))
dgoto(R->sp, DNS_R_FINISH);
if ((error = dns_cname_parse(&u.cname, &F->ans_cname, F->answer)))
goto error;
if ((error = dns_res_frame_prepare(R, &F[1], u.cname.host, dns_rr_type(12, F->query), DNS_C_IN)))
goto error;
F->state++;
dgoto(++R->sp, DNS_R_INIT);
case DNS_R_CNAME1_A:
if (!(P = dns_res_merge(F->answer, F[1].answer, &error)))
goto error;
dns_p_setptr(&F->answer, P);
dgoto(R->sp, DNS_R_FINISH);
case DNS_R_FINISH:
if (!F->answer)
goto noanswer;
if (!R->resconf->options.smart || R->sp > 0)
dgoto(R->sp, DNS_R_DONE);
R->smart.section = DNS_S_AN;
R->smart.type = R->qtype;
dns_rr_i_init(&R->smart, F->answer);
F->state++;
case DNS_R_SMART0_A:
if (&F[1] >= endof(R->stack))
dgoto(R->sp, DNS_R_DONE);
while (dns_rr_grep(&rr, 1, &R->smart, F->answer, &error)) {
union {
struct dns_ns ns;
struct dns_mx mx;
struct dns_srv srv;
} rd;
const char *qname;
enum dns_type qtype;
enum dns_class qclass;
switch (rr.type) {
case DNS_T_NS:
if ((error = dns_ns_parse(&rd.ns, &rr, F->answer)))
goto error;
qname = rd.ns.host;
qtype = DNS_T_A;
qclass = DNS_C_IN;
break;
case DNS_T_MX:
if ((error = dns_mx_parse(&rd.mx, &rr, F->answer)))
goto error;
qname = rd.mx.host;
qtype = DNS_T_A;
qclass = DNS_C_IN;
break;
case DNS_T_SRV:
if ((error = dns_srv_parse(&rd.srv, &rr, F->answer)))
goto error;
qname = rd.srv.target;
qtype = DNS_T_A;
qclass = DNS_C_IN;
break;
default:
continue;
} /* switch() */
if ((error = dns_res_frame_prepare(R, &F[1], qname, qtype, qclass)))
goto error;
F->state++;
dgoto(++R->sp, DNS_R_INIT);
} /* while() */
/*
* NOTE: SMTP specification says to fallback to A record.
*
* XXX: Should we add a mock MX answer?
*/
if (R->qtype == DNS_T_MX && R->smart.state.count == 0) {
if ((error = dns_res_frame_prepare(R, &F[1], R->qname, DNS_T_A, DNS_C_IN)))
goto error;
R->smart.state.count++;
F->state++;
dgoto(++R->sp, DNS_R_INIT);
}
dgoto(R->sp, DNS_R_DONE);
case DNS_R_SMART1_A:
if (!F[1].answer)
goto noanswer;
/*
* FIXME: For CNAME chains (which are typically illegal in
* this context), we should rewrite the record host name
* to the original smart qname. All the user cares about
* is locating that A/AAAA record.
*/
dns_rr_foreach(&rr, F[1].answer, .section = DNS_S_AN, .type = DNS_T_A) {
rr.section = DNS_S_AR;
if (dns_rr_exists(&rr, F[1].answer, F->answer))
continue;
while ((error = dns_rr_copy(F->answer, &rr, F[1].answer))) {
if (error != DNS_ENOBUFS)
goto error;
if ((error = dns_p_grow(&F->answer)))
goto error;
}
}
dgoto(R->sp, DNS_R_SMART0_A);
case DNS_R_DONE:
if (!F->answer)
goto noanswer;
if (R->sp > 0)
dgoto(--R->sp, F[-1].state);
break;
case DNS_R_SERVFAIL:
if (!dns_p_setptr(&F->answer, dns_p_make(DNS_P_QBUFSIZ, &error)))
goto error;
dns_header(F->answer)->qr = 1;
dns_header(F->answer)->rcode = DNS_RC_SERVFAIL;
if ((error = dns_p_push(F->answer, DNS_S_QD, R->qname, strlen(R->qname), R->qtype, R->qclass, 0, 0)))
goto error;
dgoto(R->sp, DNS_R_DONE);
default:
error = EINVAL;
goto error;
} /* switch () */
return 0;
noquery:
error = DNS_ENOQUERY;
goto error;
noanswer:
error = DNS_ENOANSWER;
goto error;
toolong:
error = DNS_EILLEGAL;
/* FALL THROUGH */
error:
return error;
} /* dns_res_exec() */
#undef goto
void dns_res_clear(struct dns_resolver *R) {
switch (R->stack[R->sp].state) {
case DNS_R_CHECK:
R->cache->clear(R->cache);
break;
default:
dns_so_clear(&R->so);
break;
}
} /* dns_res_clear() */
static int dns_res_events2(struct dns_resolver *R, enum dns_events type) {
int events;
switch (R->stack[R->sp].state) {
case DNS_R_CHECK:
events = R->cache->events(R->cache);
return (type == DNS_LIBEVENT)? DNS_POLL2EV(events) : events;
default:
return dns_so_events2(&R->so, type);
}
} /* dns_res_events2() */
int dns_res_events(struct dns_resolver *R) {
return dns_res_events2(R, R->so.opts.events);
} /* dns_res_events() */
int dns_res_pollfd(struct dns_resolver *R) {
switch (R->stack[R->sp].state) {
case DNS_R_CHECK:
return R->cache->pollfd(R->cache);
default:
return dns_so_pollfd(&R->so);
}
} /* dns_res_pollfd() */
time_t dns_res_timeout(struct dns_resolver *R) {
time_t elapsed;
switch (R->stack[R->sp].state) {
#if 0
case DNS_R_QUERY_AAAA:
#endif
case DNS_R_QUERY_A:
elapsed = dns_so_elapsed(&R->so);
if (elapsed <= dns_resconf_timeout(R->resconf))
return R->resconf->options.timeout - elapsed;
break;
default:
break;
} /* switch() */
/*
* NOTE: We're not in a pollable state, or the user code hasn't
* called dns_res_check properly. The calling code is probably
* broken. Put them into a slow-burn pattern.
*/
return 1;
} /* dns_res_timeout() */
time_t dns_res_elapsed(struct dns_resolver *R) {
return dns_elapsed(&R->elapsed);
} /* dns_res_elapsed() */
int dns_res_poll(struct dns_resolver *R, int timeout) {
return dns_poll(dns_res_pollfd(R), dns_res_events2(R, DNS_SYSPOLL), timeout);
} /* dns_res_poll() */
int dns_res_submit2(struct dns_resolver *R, const char *qname, size_t qlen, enum dns_type qtype, enum dns_class qclass) {
dns_res_reset(R);
/* Don't anchor; that can conflict with searchlist generation. */
dns_d_init(R->qname, sizeof R->qname, qname, (R->qlen = qlen), 0);
R->qtype = qtype;
R->qclass = qclass;
dns_begin(&R->elapsed);
return 0;
} /* dns_res_submit2() */
int dns_res_submit(struct dns_resolver *R, const char *qname, enum dns_type qtype, enum dns_class qclass) {
return dns_res_submit2(R, qname, strlen(qname), qtype, qclass);
} /* dns_res_submit() */
int dns_res_check(struct dns_resolver *R) {
int error;
if (R->stack[0].state != DNS_R_DONE) {
if ((error = dns_res_exec(R)))
return error;
}
return 0;
} /* dns_res_check() */
struct dns_packet *dns_res_fetch(struct dns_resolver *R, int *error) {
struct dns_packet *P = NULL;
if (R->stack[0].state != DNS_R_DONE) {
*error = DNS_EUNKNOWN;
return NULL;
}
if (!dns_p_movptr(&P, &R->stack[0].answer)) {
*error = DNS_EFETCHED;
return NULL;
}
return P;
} /* dns_res_fetch() */
static struct dns_packet *dns_res_fetch_and_study(struct dns_resolver *R, int *_error) {
struct dns_packet *P = NULL;
int error;
if (!(P = dns_res_fetch(R, &error)))
goto error;
if ((error = dns_p_study(P)))
goto error;
return P;
error:
*_error = error;
dns_p_free(P);
return NULL;
} /* dns_res_fetch_and_study() */
struct dns_packet *dns_res_query(struct dns_resolver *res, const char *qname, enum dns_type qtype, enum dns_class qclass, int timeout, int *error_) {
int error;
if ((error = dns_res_submit(res, qname, qtype, qclass)))
goto error;
while ((error = dns_res_check(res))) {
if (dns_res_elapsed(res) > timeout)
error = DNS_ETIMEDOUT;
if (error != DNS_EAGAIN)
goto error;
if ((error = dns_res_poll(res, 1)))
goto error;
}
return dns_res_fetch(res, error_);
error:
*error_ = error;
return 0;
} /* dns_res_query() */
const struct dns_stat *dns_res_stat(struct dns_resolver *res) {
return dns_so_stat(&res->so);
} /* dns_res_stat() */
void dns_res_sethints(struct dns_resolver *res, struct dns_hints *hints) {
dns_hints_acquire(hints); /* acquire first in case same hints object */
dns_hints_close(res->hints);
res->hints = hints;
} /* dns_res_sethints() */
void dns_res_enable_search(struct dns_resolver *res, unsigned char enable) {
res->search_enabled = enable;
}
int dns_res_was_asymetric(struct dns_resolver *res){
return res->so.ip_differ;
}
/*
* A D D R I N F O R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct dns_addrinfo {
struct addrinfo hints;
struct dns_resolver *res;
char qname[DNS_D_MAXNAME + 1];
enum dns_type qtype;
unsigned short qport, port;
struct {
unsigned long todo;
int atype;
enum dns_type qtype;
} af;
struct dns_packet *answer;
struct dns_packet *glue;
struct dns_rr_i i, g;
struct dns_rr rr;
char cname[DNS_D_MAXNAME + 1];
char i_cname[DNS_D_MAXNAME + 1], g_cname[DNS_D_MAXNAME + 1];
int state;
int found;
struct dns_stat st;
}; /* struct dns_addrinfo */
#define DNS_AI_AFMAX 32
#define DNS_AI_AF2INDEX(af) (1UL << ((af) - 1))
static int dns_ai_nextaf(struct dns_addrinfo *ai) {
int qtype = 0, atype = 0;
unsigned i;
dns_static_assert(AF_UNSPEC == 0, "AF_UNSPEC constant not 0");
dns_static_assert(AF_INET <= DNS_AI_AFMAX, "AF_INET constant too large");
dns_static_assert(AF_INET6 <= DNS_AI_AFMAX, "AF_INET6 constant too large");
for (i = 0; i < lengthof(ai->res->resconf->family); i++) {
int af = ai->res->resconf->family[i];
if (af == AF_UNSPEC)
break;
if (af < 0 || af > DNS_AI_AFMAX)
continue;
if (!(DNS_AI_AF2INDEX(af) & ai->af.todo))
continue;
switch (af) {
case AF_INET:
atype = AF_INET;
qtype = DNS_T_A;
goto update;
case AF_INET6:
atype = AF_INET6;
qtype = DNS_T_AAAA;
goto update;
}
}
update:
ai->af.atype = atype;
ai->af.qtype = qtype;
if (atype)
ai->af.todo &= ~DNS_AI_AF2INDEX(atype);
return atype;
} /* dns_ai_nextaf() */
static enum dns_type dns_ai_qtype(struct dns_addrinfo *ai) {
return (ai->qtype)? ai->qtype : ai->af.qtype;
} /* dns_ai_qtype() */
static dns_error_t dns_ai_parseport(unsigned short *port, const char *serv, const struct addrinfo *hints) {
const char *cp = serv;
unsigned long n = 0;
while (*cp >= '0' && *cp <= '9' && n < 65536) {
n *= 10;
n += *cp++ - '0';
}
if (*cp == '\0') {
if (cp == serv || n >= 65536)
return DNS_ESERVICE;
*port = n;
return 0;
}
if (hints->ai_flags & AI_NUMERICSERV)
return DNS_ESERVICE;
/* TODO: try getaddrinfo(NULL, serv, { .ai_flags = AI_NUMERICSERV }) */
return DNS_ESERVICE;
} /* dns_ai_parseport() */
struct dns_addrinfo *dns_ai_open(const char *host, const char *serv, enum dns_type qtype, const struct addrinfo *hints, struct dns_resolver *res, int *error_) {
static const struct dns_addrinfo ai_initializer;
struct dns_addrinfo *ai;
int error;
if (res) {
dns_res_acquire(res);
} else if (!(hints->ai_flags & AI_NUMERICHOST)) {
/*
* NOTE: it's assumed that *_error is set from a previous
* API function call, such as dns_res_stub(). Should change
* this semantic, but it's applied elsewhere, too.
*/
return NULL;
}
if (!(ai = malloc(sizeof *ai)))
goto syerr;
*ai = ai_initializer;
ai->hints = *hints;
ai->res = res;
res = NULL;
if (sizeof ai->qname <= dns_strlcpy(ai->qname, host, sizeof ai->qname))
{ error = ENAMETOOLONG; goto error; }
ai->qtype = qtype;
ai->qport = 0;
if (serv && (error = dns_ai_parseport(&ai->qport, serv, hints)))
goto error;
ai->port = ai->qport;
switch (ai->qtype) {
case DNS_T_A:
ai->af.todo = DNS_AI_AF2INDEX(AF_INET);
break;
case DNS_T_AAAA:
ai->af.todo = DNS_AI_AF2INDEX(AF_INET6);
break;
default: /* 0, MX, SRV, etc */
switch (ai->hints.ai_family) {
case AF_UNSPEC:
ai->af.todo = DNS_AI_AF2INDEX(AF_INET) | DNS_AI_AF2INDEX(AF_INET6);
break;
case AF_INET:
ai->af.todo = DNS_AI_AF2INDEX(AF_INET);
break;
case AF_INET6:
ai->af.todo = DNS_AI_AF2INDEX(AF_INET6);
break;
default:
break;
}
}
return ai;
syerr:
error = dns_syerr();
error:
*error_ = error;
dns_ai_close(ai);
dns_res_close(res);
return NULL;
} /* dns_ai_open() */
void dns_ai_close(struct dns_addrinfo *ai) {
if (!ai)
return;
dns_res_close(ai->res);
if (ai->answer != ai->glue)
dns_p_free(ai->glue);
dns_p_free(ai->answer);
free(ai);
} /* dns_ai_close() */
static int dns_ai_setent(struct addrinfo **ent, union dns_any *any, enum dns_type type, struct dns_addrinfo *ai) {
struct sockaddr *saddr;
struct sockaddr_in sin;
struct sockaddr_in6 sin6;
const char *cname;
size_t clen;
switch (type) {
case DNS_T_A:
saddr = memset(&sin, '\0', sizeof sin);
sin.sin_family = AF_INET;
sin.sin_port = htons(ai->port);
memcpy(&sin.sin_addr, any, sizeof sin.sin_addr);
break;
case DNS_T_AAAA:
saddr = memset(&sin6, '\0', sizeof sin6);
sin6.sin6_family = AF_INET6;
sin6.sin6_port = htons(ai->port);
memcpy(&sin6.sin6_addr, any, sizeof sin6.sin6_addr);
break;
default:
return EINVAL;
} /* switch() */
if (ai->hints.ai_flags & AI_CANONNAME) {
cname = (*ai->cname)? ai->cname : ai->qname;
clen = strlen(cname);
} else {
cname = NULL;
clen = 0;
}
if (!(*ent = malloc(sizeof **ent + dns_sa_len(saddr) + ((ai->hints.ai_flags & AI_CANONNAME)? clen + 1 : 0))))
return dns_syerr();
memset(*ent, '\0', sizeof **ent);
(*ent)->ai_family = saddr->sa_family;
(*ent)->ai_socktype = ai->hints.ai_socktype;
(*ent)->ai_protocol = ai->hints.ai_protocol;
(*ent)->ai_addr = memcpy((unsigned char *)*ent + sizeof **ent, saddr, dns_sa_len(saddr));
(*ent)->ai_addrlen = dns_sa_len(saddr);
if (ai->hints.ai_flags & AI_CANONNAME)
(*ent)->ai_canonname = memcpy((unsigned char *)*ent + sizeof **ent + dns_sa_len(saddr), cname, clen + 1);
ai->found++;
return 0;
} /* dns_ai_setent() */
enum dns_ai_state {
DNS_AI_S_INIT,
DNS_AI_S_NEXTAF,
DNS_AI_S_NUMERIC,
DNS_AI_S_SUBMIT,
DNS_AI_S_CHECK,
DNS_AI_S_FETCH,
DNS_AI_S_FOREACH_I,
DNS_AI_S_ITERATE_G,
DNS_AI_S_FOREACH_G,
DNS_AI_S_SUBMIT_G,
DNS_AI_S_CHECK_G,
DNS_AI_S_FETCH_G,
DNS_AI_S_DONE,
}; /* enum dns_ai_state */
#define dns_ai_goto(which) do { ai->state = (which); goto exec; } while (0)
int dns_ai_nextent(struct addrinfo **ent, struct dns_addrinfo *ai) {
struct dns_packet *ans, *glue;
struct dns_rr rr;
char qname[DNS_D_MAXNAME + 1];
union dns_any any;
size_t qlen, clen;
int error;
*ent = 0;
exec:
switch (ai->state) {
case DNS_AI_S_INIT:
ai->state++;
case DNS_AI_S_NEXTAF:
if (!dns_ai_nextaf(ai))
dns_ai_goto(DNS_AI_S_DONE);
ai->state++;
case DNS_AI_S_NUMERIC:
if (1 == dns_inet_pton(AF_INET, ai->qname, &any.a)) {
if (ai->af.atype == AF_INET) {
ai->state = DNS_AI_S_NEXTAF;
return dns_ai_setent(ent, &any, DNS_T_A, ai);
} else {
dns_ai_goto(DNS_AI_S_NEXTAF);
}
}
if (1 == dns_inet_pton(AF_INET6, ai->qname, &any.aaaa)) {
if (ai->af.atype == AF_INET6) {
ai->state = DNS_AI_S_NEXTAF;
return dns_ai_setent(ent, &any, DNS_T_AAAA, ai);
} else {
dns_ai_goto(DNS_AI_S_NEXTAF);
}
}
if (ai->hints.ai_flags & AI_NUMERICHOST)
dns_ai_goto(DNS_AI_S_NEXTAF);
ai->state++;
case DNS_AI_S_SUBMIT:
assert(ai->res);
if ((error = dns_res_submit(ai->res, ai->qname, dns_ai_qtype(ai), DNS_C_IN)))
return error;
ai->state++;
case DNS_AI_S_CHECK:
if ((error = dns_res_check(ai->res)))
return error;
ai->state++;
case DNS_AI_S_FETCH:
if (!(ans = dns_res_fetch_and_study(ai->res, &error)))
return error;
if (ai->glue != ai->answer)
dns_p_free(ai->glue);
ai->glue = dns_p_movptr(&ai->answer, &ans);
/* Search generator may have changed the qname. */
if (!(qlen = dns_d_expand(qname, sizeof qname, 12, ai->answer, &error)))
return error;
else if (qlen >= sizeof qname)
return DNS_EILLEGAL;
if (!dns_d_cname(ai->cname, sizeof ai->cname, qname, qlen, ai->answer, &error))
return error;
dns_strlcpy(ai->i_cname, ai->cname, sizeof ai->i_cname);
dns_rr_i_init(&ai->i, ai->answer);
ai->i.section = DNS_S_AN;
ai->i.name = ai->i_cname;
ai->i.type = dns_ai_qtype(ai);
ai->i.sort = &dns_rr_i_order;
ai->state++;
case DNS_AI_S_FOREACH_I:
if (!dns_rr_grep(&rr, 1, &ai->i, ai->answer, &error))
dns_ai_goto(DNS_AI_S_NEXTAF);
if ((error = dns_any_parse(&any, &rr, ai->answer)))
return error;
ai->port = ai->qport;
switch (rr.type) {
case DNS_T_A:
case DNS_T_AAAA:
return dns_ai_setent(ent, &any, rr.type, ai);
default:
if (!(clen = dns_any_cname(ai->cname, sizeof ai->cname, &any, rr.type)))
dns_ai_goto(DNS_AI_S_FOREACH_I);
/*
* Find the "real" canonical name. Some authorities
* publish aliases where an RFC defines a canonical
* name. We trust that the resolver followed any
* CNAME chains on it's own, regardless of whether
* the "smart" option is enabled.
*/
if (!dns_d_cname(ai->cname, sizeof ai->cname, ai->cname, clen, ai->answer, &error))
return error;
if (rr.type == DNS_T_SRV)
ai->port = any.srv.port;
break;
} /* switch() */
ai->state++;
case DNS_AI_S_ITERATE_G:
dns_strlcpy(ai->g_cname, ai->cname, sizeof ai->g_cname);
dns_rr_i_init(&ai->g, ai->glue);
ai->g.section = DNS_S_ALL & ~DNS_S_QD;
ai->g.name = ai->g_cname;
ai->g.type = ai->af.qtype;
ai->state++;
case DNS_AI_S_FOREACH_G:
if (!dns_rr_grep(&rr, 1, &ai->g, ai->glue, &error)) {
if (dns_rr_i_count(&ai->g) > 0)
dns_ai_goto(DNS_AI_S_FOREACH_I);
else
dns_ai_goto(DNS_AI_S_SUBMIT_G);
}
if ((error = dns_any_parse(&any, &rr, ai->glue)))
return error;
return dns_ai_setent(ent, &any, rr.type, ai);
case DNS_AI_S_SUBMIT_G:
/* skip if already queried */
if (dns_rr_grep(&rr, 1, dns_rr_i_new(ai->glue, .section = DNS_S_QD, .name = ai->g.name, .type = ai->g.type), ai->glue, &error))
dns_ai_goto(DNS_AI_S_FOREACH_I);
if ((error = dns_res_submit(ai->res, ai->g.name, ai->g.type, DNS_C_IN)))
return error;
ai->state++;
case DNS_AI_S_CHECK_G:
if ((error = dns_res_check(ai->res)))
return error;
ai->state++;
case DNS_AI_S_FETCH_G:
if (!(ans = dns_res_fetch_and_study(ai->res, &error)))
return error;
glue = dns_p_merge(ai->glue, DNS_S_ALL, ans, DNS_S_ALL, &error);
dns_p_setptr(&ans, NULL);
if (!glue)
return error;
if (ai->glue != ai->answer)
dns_p_free(ai->glue);
ai->glue = glue;
if (!dns_d_cname(ai->cname, sizeof ai->cname, ai->g.name, strlen(ai->g.name), ai->glue, &error))
dns_ai_goto(DNS_AI_S_FOREACH_I);
dns_ai_goto(DNS_AI_S_ITERATE_G);
case DNS_AI_S_DONE:
if (ai->found) {
return ENOENT; /* TODO: Just return 0 */
} else if (ai->answer) {
switch (dns_p_rcode(ai->answer)) {
case DNS_RC_NOERROR:
/* FALL THROUGH */
case DNS_RC_NXDOMAIN:
return DNS_ENONAME;
default:
return DNS_EFAIL;
}
} else {
return DNS_EFAIL;
}
default:
return EINVAL;
} /* switch() */
} /* dns_ai_nextent() */
time_t dns_ai_elapsed(struct dns_addrinfo *ai) {
return (ai->res)? dns_res_elapsed(ai->res) : 0;
} /* dns_ai_elapsed() */
void dns_ai_clear(struct dns_addrinfo *ai) {
if (ai->res)
dns_res_clear(ai->res);
} /* dns_ai_clear() */
int dns_ai_events(struct dns_addrinfo *ai) {
return (ai->res)? dns_res_events(ai->res) : 0;
} /* dns_ai_events() */
int dns_ai_pollfd(struct dns_addrinfo *ai) {
return (ai->res)? dns_res_pollfd(ai->res) : -1;
} /* dns_ai_pollfd() */
time_t dns_ai_timeout(struct dns_addrinfo *ai) {
return (ai->res)? dns_res_timeout(ai->res) : 0;
} /* dns_ai_timeout() */
int dns_ai_poll(struct dns_addrinfo *ai, int timeout) {
return (ai->res)? dns_res_poll(ai->res, timeout) : 0;
} /* dns_ai_poll() */
size_t dns_ai_print(void *_dst, size_t lim, struct addrinfo *ent, struct dns_addrinfo *ai) {
struct dns_buf dst = DNS_B_INTO(_dst, lim);
char addr[DNS_PP_MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1];
dns_b_puts(&dst, "[ ");
dns_b_puts(&dst, ai->qname);
dns_b_puts(&dst, " IN ");
if (ai->qtype) {
dns_b_puts(&dst, dns_strtype(ai->qtype));
} else if (ent->ai_family == AF_INET) {
dns_b_puts(&dst, dns_strtype(DNS_T_A));
} else if (ent->ai_family == AF_INET6) {
dns_b_puts(&dst, dns_strtype(DNS_T_AAAA));
} else {
dns_b_puts(&dst, "0");
}
dns_b_puts(&dst, " ]\n");
dns_b_puts(&dst, ".ai_family = ");
switch (ent->ai_family) {
case AF_INET:
dns_b_puts(&dst, "AF_INET");
break;
case AF_INET6:
dns_b_puts(&dst, "AF_INET6");
break;
default:
dns_b_fmtju(&dst, ent->ai_family, 0);
break;
}
dns_b_putc(&dst, '\n');
dns_b_puts(&dst, ".ai_socktype = ");
switch (ent->ai_socktype) {
case SOCK_STREAM:
dns_b_puts(&dst, "SOCK_STREAM");
break;
case SOCK_DGRAM:
dns_b_puts(&dst, "SOCK_DGRAM");
break;
default:
dns_b_fmtju(&dst, ent->ai_socktype, 0);
break;
}
dns_b_putc(&dst, '\n');
dns_inet_ntop(dns_sa_family(ent->ai_addr), dns_sa_addr(dns_sa_family(ent->ai_addr), ent->ai_addr, NULL), addr, sizeof addr);
dns_b_puts(&dst, ".ai_addr = [");
dns_b_puts(&dst, addr);
dns_b_puts(&dst, "]:");
dns_b_fmtju(&dst, ntohs(*dns_sa_port(dns_sa_family(ent->ai_addr), ent->ai_addr)), 0);
dns_b_putc(&dst, '\n');
dns_b_puts(&dst, ".ai_canonname = ");
dns_b_puts(&dst, (ent->ai_canonname)? ent->ai_canonname : "[NULL]");
dns_b_putc(&dst, '\n');
return dns_b_strllen(&dst);
} /* dns_ai_print() */
const struct dns_stat *dns_ai_stat(struct dns_addrinfo *ai) {
return (ai->res)? dns_res_stat(ai->res) : &ai->st;
} /* dns_ai_stat() */
/*
* M I S C E L L A N E O U S R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static const struct {
char name[16];
enum dns_section type;
} dns_sections[] = {
{ "QUESTION", DNS_S_QUESTION },
{ "QD", DNS_S_QUESTION },
{ "ANSWER", DNS_S_ANSWER },
{ "AN", DNS_S_ANSWER },
{ "AUTHORITY", DNS_S_AUTHORITY },
{ "NS", DNS_S_AUTHORITY },
{ "ADDITIONAL", DNS_S_ADDITIONAL },
{ "AR", DNS_S_ADDITIONAL },
};
const char *(dns_strsection)(enum dns_section section, void *_dst, size_t lim) {
struct dns_buf dst = DNS_B_INTO(_dst, lim);
unsigned i;
for (i = 0; i < lengthof(dns_sections); i++) {
if (dns_sections[i].type & section) {
dns_b_puts(&dst, dns_sections[i].name);
section &= ~dns_sections[i].type;
if (section)
dns_b_putc(&dst, '|');
}
}
if (section || dst.p == dst.base)
dns_b_fmtju(&dst, (0xffff & section), 0);
return dns_b_tostring(&dst);
} /* dns_strsection() */
enum dns_section dns_isection(const char *src) {
enum dns_section section = 0;
char sbuf[128];
char *name, *next;
unsigned i;
dns_strlcpy(sbuf, src, sizeof sbuf);
next = sbuf;
while ((name = dns_strsep(&next, "|+, \t"))) {
for (i = 0; i < lengthof(dns_sections); i++) {
if (!strcasecmp(dns_sections[i].name, name)) {
section |= dns_sections[i].type;
break;
}
}
}
return section;
} /* dns_isection() */
static const struct {
char name[8];
enum dns_class type;
} dns_classes[] = {
{ "IN", DNS_C_IN },
};
const char *(dns_strclass)(enum dns_class type, void *_dst, size_t lim) {
struct dns_buf dst = DNS_B_INTO(_dst, lim);
unsigned i;
for (i = 0; i < lengthof(dns_classes); i++) {
if (dns_classes[i].type == type) {
dns_b_puts(&dst, dns_classes[i].name);
break;
}
}
if (dst.p == dst.base)
dns_b_fmtju(&dst, (0xffff & type), 0);
return dns_b_tostring(&dst);
} /* dns_strclass() */
enum dns_class dns_iclass(const char *name) {
unsigned i, class;
for (i = 0; i < lengthof(dns_classes); i++) {
if (!strcasecmp(dns_classes[i].name, name))
return dns_classes[i].type;
}
class = 0;
while (dns_isdigit(*name)) {
class *= 10;
class += *name++ - '0';
}
return DNS_PP_MIN(class, 0xffff);
} /* dns_iclass() */
const char *(dns_strtype)(enum dns_type type, void *_dst, size_t lim) {
struct dns_buf dst = DNS_B_INTO(_dst, lim);
unsigned i;
for (i = 0; i < lengthof(dns_rrtypes); i++) {
if (dns_rrtypes[i].type == type) {
dns_b_puts(&dst, dns_rrtypes[i].name);
break;
}
}
if (dst.p == dst.base)
dns_b_fmtju(&dst, (0xffff & type), 0);
return dns_b_tostring(&dst);
} /* dns_strtype() */
enum dns_type dns_itype(const char *name) {
unsigned i, type;
for (i = 0; i < lengthof(dns_rrtypes); i++) {
if (!strcasecmp(dns_rrtypes[i].name, name))
return dns_rrtypes[i].type;
}
type = 0;
while (dns_isdigit(*name)) {
type *= 10;
type += *name++ - '0';
}
return DNS_PP_MIN(type, 0xffff);
} /* dns_itype() */
static char dns_opcodes[16][16] = {
[DNS_OP_QUERY] = "QUERY",
[DNS_OP_IQUERY] = "IQUERY",
[DNS_OP_STATUS] = "STATUS",
[DNS_OP_NOTIFY] = "NOTIFY",
[DNS_OP_UPDATE] = "UPDATE",
};
static const char *dns__strcode(int code, volatile char *dst, size_t lim) {
char _tmp[48] = "";
struct dns_buf tmp;
size_t p;
assert(lim > 0);
dns_b_fmtju(dns_b_into(&tmp, _tmp, DNS_PP_MIN(sizeof _tmp, lim - 1)), code, 0);
/* copy downwards so first byte is copied last (see below) */
p = (size_t)(tmp.p - tmp.base);
dst[p] = '\0';
while (p--)
dst[p] = _tmp[p];
return (const char *)dst;
}
const char *dns_stropcode(enum dns_opcode opcode) {
opcode = (unsigned)opcode % lengthof(dns_opcodes);
if ('\0' == dns_opcodes[opcode][0])
return dns__strcode(opcode, dns_opcodes[opcode], sizeof dns_opcodes[opcode]);
return dns_opcodes[opcode];
} /* dns_stropcode() */
enum dns_opcode dns_iopcode(const char *name) {
unsigned opcode;
for (opcode = 0; opcode < lengthof(dns_opcodes); opcode++) {
if (!strcasecmp(name, dns_opcodes[opcode]))
return opcode;
}
opcode = 0;
while (dns_isdigit(*name)) {
opcode *= 10;
opcode += *name++ - '0';
}
return DNS_PP_MIN(opcode, 0x0f);
} /* dns_iopcode() */
static char dns_rcodes[32][16] = {
[DNS_RC_NOERROR] = "NOERROR",
[DNS_RC_FORMERR] = "FORMERR",
[DNS_RC_SERVFAIL] = "SERVFAIL",
[DNS_RC_NXDOMAIN] = "NXDOMAIN",
[DNS_RC_NOTIMP] = "NOTIMP",
[DNS_RC_REFUSED] = "REFUSED",
[DNS_RC_YXDOMAIN] = "YXDOMAIN",
[DNS_RC_YXRRSET] = "YXRRSET",
[DNS_RC_NXRRSET] = "NXRRSET",
[DNS_RC_NOTAUTH] = "NOTAUTH",
[DNS_RC_NOTZONE] = "NOTZONE",
/* EDNS(0) extended RCODEs ... */
[DNS_RC_BADVERS] = "BADVERS",
};
const char *dns_strrcode(enum dns_rcode rcode) {
rcode = (unsigned)rcode % lengthof(dns_rcodes);
if ('\0' == dns_rcodes[rcode][0])
return dns__strcode(rcode, dns_rcodes[rcode], sizeof dns_rcodes[rcode]);
return dns_rcodes[rcode];
} /* dns_strrcode() */
enum dns_rcode dns_ircode(const char *name) {
unsigned rcode;
for (rcode = 0; rcode < lengthof(dns_rcodes); rcode++) {
if (!strcasecmp(name, dns_rcodes[rcode]))
return rcode;
}
rcode = 0;
while (dns_isdigit(*name)) {
rcode *= 10;
rcode += *name++ - '0';
}
return DNS_PP_MIN(rcode, 0xfff);
} /* dns_ircode() */
/*
* C O M M A N D - L I N E / R E G R E S S I O N R O U T I N E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#if DNS_MAIN
#include
#include
#include
#include
#if _WIN32
#include
#endif
#if !_WIN32
#include
#endif
struct {
struct {
const char *path[8];
unsigned count;
} resconf, nssconf, hosts, cache;
const char *qname;
enum dns_type qtype;
int (*sort)();
int verbose;
} MAIN = {
.sort = &dns_rr_i_packet,
};
static void hexdump(const unsigned char *src, size_t len, FILE *fp) {
static const unsigned char hex[] = "0123456789abcdef";
static const unsigned char tmpl[] = " | |\n";
unsigned char ln[sizeof tmpl];
const unsigned char *sp, *se;
unsigned char *h, *g;
unsigned i, n;
sp = src;
se = sp + len;
while (sp < se) {
memcpy(ln, tmpl, sizeof ln);
h = &ln[2];
g = &ln[53];
for (n = 0; n < 2; n++) {
for (i = 0; i < 8 && se - sp > 0; i++, sp++) {
h[0] = hex[0x0f & (*sp >> 4)];
h[1] = hex[0x0f & (*sp >> 0)];
h += 3;
*g++ = (isgraph(*sp))? *sp : '.';
}
h++;
}
fputs((char *)ln, fp);
}
return /* void */;
} /* hexdump() */
DNS_NORETURN static void panic(const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
#if _WIN32
vfprintf(stderr, fmt, ap);
exit(EXIT_FAILURE);
#else
verrx(EXIT_FAILURE, fmt, ap);
#endif
} /* panic() */
#define panic_(fn, ln, fmt, ...) \
panic(fmt "%0s", (fn), (ln), __VA_ARGS__)
#define panic(...) \
panic_(__func__, __LINE__, "(%s:%d) " __VA_ARGS__, "")
static void *grow(unsigned char *p, size_t size) {
void *tmp;
if (!(tmp = realloc(p, size)))
panic("realloc(%"PRIuZ"): %s", size, dns_strerror(errno));
return tmp;
} /* grow() */
static size_t add(size_t a, size_t b) {
if (~a < b)
panic("%"PRIuZ" + %"PRIuZ": integer overflow", a, b);
return a + b;
} /* add() */
static size_t append(unsigned char **dst, size_t osize, const void *src, size_t len) {
size_t size = add(osize, len);
*dst = grow(*dst, size);
memcpy(*dst + osize, src, len);
return size;
} /* append() */
static size_t slurp(unsigned char **dst, size_t osize, FILE *fp, const char *path) {
size_t size = osize;
unsigned char buf[1024];
size_t count;
while ((count = fread(buf, 1, sizeof buf, fp)))
size = append(dst, size, buf, count);
if (ferror(fp))
panic("%s: %s", path, dns_strerror(errno));
return size;
} /* slurp() */
static struct dns_resolv_conf *resconf(void) {
static struct dns_resolv_conf *resconf;
const char *path;
unsigned i;
int error;
if (resconf)
return resconf;
if (!(resconf = dns_resconf_open(&error)))
panic("dns_resconf_open: %s", dns_strerror(error));
if (!MAIN.resconf.count)
MAIN.resconf.path[MAIN.resconf.count++] = "/etc/resolv.conf";
for (i = 0; i < MAIN.resconf.count; i++) {
path = MAIN.resconf.path[i];
if (0 == strcmp(path, "-"))
error = dns_resconf_loadfile(resconf, stdin);
else
error = dns_resconf_loadpath(resconf, path);
if (error)
panic("%s: %s", path, dns_strerror(error));
}
for (i = 0; i < MAIN.nssconf.count; i++) {
path = MAIN.nssconf.path[i];
if (0 == strcmp(path, "-"))
error = dns_nssconf_loadfile(resconf, stdin);
else
error = dns_nssconf_loadpath(resconf, path);
if (error)
panic("%s: %s", path, dns_strerror(error));
}
if (!MAIN.nssconf.count) {
path = "/etc/nsswitch.conf";
if (!(error = dns_nssconf_loadpath(resconf, path)))
MAIN.nssconf.path[MAIN.nssconf.count++] = path;
else if (error != ENOENT)
panic("%s: %s", path, dns_strerror(error));
}
return resconf;
} /* resconf() */
static struct dns_hosts *hosts(void) {
static struct dns_hosts *hosts;
const char *path;
unsigned i;
int error;
if (hosts)
return hosts;
if (!MAIN.hosts.count) {
MAIN.hosts.path[MAIN.hosts.count++] = "/etc/hosts";
/* Explicitly test dns_hosts_local() */
if (!(hosts = dns_hosts_local(&error)))
panic("%s: %s", "/etc/hosts", dns_strerror(error));
return hosts;
}
if (!(hosts = dns_hosts_open(&error)))
panic("dns_hosts_open: %s", dns_strerror(error));
for (i = 0; i < MAIN.hosts.count; i++) {
path = MAIN.hosts.path[i];
if (0 == strcmp(path, "-"))
error = dns_hosts_loadfile(hosts, stdin);
else
error = dns_hosts_loadpath(hosts, path);
if (error)
panic("%s: %s", path, dns_strerror(error));
}
return hosts;
} /* hosts() */
#if DNS_CACHE
#include "cache.h"
static struct dns_cache *cache(void) {
static struct cache *cache;
const char *path;
unsigned i;
int error;
if (cache)
return cache_resi(cache);
if (!MAIN.cache.count)
return NULL;
if (!(cache = cache_open(&error)))
panic("%s: %s", MAIN.cache.path[0], dns_strerror(error));
for (i = 0; i < MAIN.cache.count; i++) {
path = MAIN.cache.path[i];
if (!strcmp(path, "-")) {
if ((error = cache_loadfile(cache, stdin, NULL, 0)))
panic("%s: %s", path, dns_strerror(error));
} else if ((error = cache_loadpath(cache, path, NULL, 0)))
panic("%s: %s", path, dns_strerror(error));
}
return cache_resi(cache);
} /* cache() */
#else
static struct dns_cache *cache(void) { return NULL; }
#endif
static void print_packet(struct dns_packet *P, FILE *fp) {
dns_p_dump3(P, dns_rr_i_new(P, .sort = MAIN.sort), fp);
if (MAIN.verbose > 2)
hexdump(P->data, P->end, fp);
} /* print_packet() */
static int parse_packet(int argc DNS_NOTUSED, char *argv[] DNS_NOTUSED) {
struct dns_packet *P = dns_p_new(512);
struct dns_packet *Q = dns_p_new(512);
enum dns_section section;
struct dns_rr rr;
int error;
union dns_any any;
char pretty[sizeof any * 2];
size_t len;
P->end = fread(P->data, 1, P->size, stdin);
fputs(";; [HEADER]\n", stdout);
fprintf(stdout, ";; qr : %s(%d)\n", (dns_header(P)->qr)? "RESPONSE" : "QUERY", dns_header(P)->qr);
fprintf(stdout, ";; opcode : %s(%d)\n", dns_stropcode(dns_header(P)->opcode), dns_header(P)->opcode);
fprintf(stdout, ";; aa : %s(%d)\n", (dns_header(P)->aa)? "AUTHORITATIVE" : "NON-AUTHORITATIVE", dns_header(P)->aa);
fprintf(stdout, ";; tc : %s(%d)\n", (dns_header(P)->tc)? "TRUNCATED" : "NOT-TRUNCATED", dns_header(P)->tc);
fprintf(stdout, ";; rd : %s(%d)\n", (dns_header(P)->rd)? "RECURSION-DESIRED" : "RECURSION-NOT-DESIRED", dns_header(P)->rd);
fprintf(stdout, ";; ra : %s(%d)\n", (dns_header(P)->ra)? "RECURSION-ALLOWED" : "RECURSION-NOT-ALLOWED", dns_header(P)->ra);
fprintf(stdout, ";; rcode : %s(%d)\n", dns_strrcode(dns_p_rcode(P)), dns_p_rcode(P));
section = 0;
dns_rr_foreach(&rr, P, .sort = MAIN.sort) {
if (section != rr.section)
fprintf(stdout, "\n;; [%s:%d]\n", dns_strsection(rr.section), dns_p_count(P, rr.section));
if ((len = dns_rr_print(pretty, sizeof pretty, &rr, P, &error)))
fprintf(stdout, "%s\n", pretty);
dns_rr_copy(Q, &rr, P);
section = rr.section;
}
fputs("; ; ; ; ; ; ; ;\n\n", stdout);
section = 0;
#if 0
dns_rr_foreach(&rr, Q, .name = "ns8.yahoo.com.") {
#else
struct dns_rr rrset[32];
struct dns_rr_i *rri = dns_rr_i_new(Q, .name = dns_d_new("ns8.yahoo.com", DNS_D_ANCHOR), .sort = MAIN.sort);
unsigned rrcount = dns_rr_grep(rrset, lengthof(rrset), rri, Q, &error);
for (unsigned i = 0; i < rrcount; i++) {
rr = rrset[i];
#endif
if (section != rr.section)
fprintf(stdout, "\n;; [%s:%d]\n", dns_strsection(rr.section), dns_p_count(Q, rr.section));
if ((len = dns_rr_print(pretty, sizeof pretty, &rr, Q, &error)))
fprintf(stdout, "%s\n", pretty);
section = rr.section;
}
if (MAIN.verbose > 1) {
fprintf(stderr, "orig:%"PRIuZ"\n", P->end);
hexdump(P->data, P->end, stdout);
fprintf(stderr, "copy:%"PRIuZ"\n", Q->end);
hexdump(Q->data, Q->end, stdout);
}
return 0;
} /* parse_packet() */
static int parse_domain(int argc, char *argv[]) {
char *dn;
dn = (argc > 1)? argv[1] : "f.l.google.com";
printf("[%s]\n", dn);
dn = dns_d_new(dn);
do {
puts(dn);
} while (dns_d_cleave(dn, strlen(dn) + 1, dn, strlen(dn)));
return 0;
} /* parse_domain() */
static int trim_domain(int argc, char **argv) {
for (argc--, argv++; argc > 0; argc--, argv++) {
char name[DNS_D_MAXNAME + 1];
dns_d_trim(name, sizeof name, *argv, strlen(*argv), DNS_D_ANCHOR);
puts(name);
}
return 0;
} /* trim_domain() */
static int expand_domain(int argc, char *argv[]) {
unsigned short rp = 0;
unsigned char *src = NULL;
unsigned char *dst;
struct dns_packet *pkt;
size_t lim = 0, len;
int error;
if (argc > 1)
rp = atoi(argv[1]);
len = slurp(&src, 0, stdin, "-");
if (!(pkt = dns_p_make(len, &error)))
panic("malloc(%"PRIuZ"): %s", len, dns_strerror(error));
memcpy(pkt->data, src, len);
pkt->end = len;
lim = 1;
dst = grow(NULL, lim);
while (lim <= (len = dns_d_expand(dst, lim, rp, pkt, &error))) {
lim = add(len, 1);
dst = grow(dst, lim);
}
if (!len)
panic("expand: %s", dns_strerror(error));
fwrite(dst, 1, len, stdout);
fflush(stdout);
free(src);
free(dst);
free(pkt);
return 0;
} /* expand_domain() */
static int show_resconf(int argc DNS_NOTUSED, char *argv[] DNS_NOTUSED) {
unsigned i;
resconf(); /* load it */
fputs("; SOURCES\n", stdout);
for (i = 0; i < MAIN.resconf.count; i++)
fprintf(stdout, "; %s\n", MAIN.resconf.path[i]);
for (i = 0; i < MAIN.nssconf.count; i++)
fprintf(stdout, "; %s\n", MAIN.nssconf.path[i]);
fputs(";\n", stdout);
dns_resconf_dump(resconf(), stdout);
return 0;
} /* show_resconf() */
static int show_nssconf(int argc DNS_NOTUSED, char *argv[] DNS_NOTUSED) {
unsigned i;
resconf();
fputs("# SOURCES\n", stdout);
for (i = 0; i < MAIN.resconf.count; i++)
fprintf(stdout, "# %s\n", MAIN.resconf.path[i]);
for (i = 0; i < MAIN.nssconf.count; i++)
fprintf(stdout, "# %s\n", MAIN.nssconf.path[i]);
fputs("#\n", stdout);
dns_nssconf_dump(resconf(), stdout);
return 0;
} /* show_nssconf() */
static int show_hosts(int argc DNS_NOTUSED, char *argv[] DNS_NOTUSED) {
unsigned i;
hosts();
fputs("# SOURCES\n", stdout);
for (i = 0; i < MAIN.hosts.count; i++)
fprintf(stdout, "# %s\n", MAIN.hosts.path[i]);
fputs("#\n", stdout);
dns_hosts_dump(hosts(), stdout);
return 0;
} /* show_hosts() */
static int query_hosts(int argc, char *argv[]) {
struct dns_packet *Q = dns_p_new(512);
struct dns_packet *A;
char qname[DNS_D_MAXNAME + 1];
size_t qlen;
int error;
if (!MAIN.qname)
MAIN.qname = (argc > 1)? argv[1] : "localhost";
if (!MAIN.qtype)
MAIN.qtype = DNS_T_A;
hosts();
if (MAIN.qtype == DNS_T_PTR && !strstr(MAIN.qname, "arpa")) {
union { struct in_addr a; struct in6_addr a6; } addr;
int af = (strchr(MAIN.qname, ':'))? AF_INET6 : AF_INET;
if ((error = dns_pton(af, MAIN.qname, &addr)))
panic("%s: %s", MAIN.qname, dns_strerror(error));
qlen = dns_ptr_qname(qname, sizeof qname, af, &addr);
} else
qlen = dns_strlcpy(qname, MAIN.qname, sizeof qname);
if ((error = dns_p_push(Q, DNS_S_QD, qname, qlen, MAIN.qtype, DNS_C_IN, 0, 0)))
panic("%s: %s", qname, dns_strerror(error));
if (!(A = dns_hosts_query(hosts(), Q, &error)))
panic("%s: %s", qname, dns_strerror(error));
print_packet(A, stdout);
free(A);
return 0;
} /* query_hosts() */
static int search_list(int argc, char *argv[]) {
const char *qname = (argc > 1)? argv[1] : "f.l.google.com";
unsigned long i = 0;
char name[DNS_D_MAXNAME + 1];
printf("[%s]\n", qname);
while (dns_resconf_search(name, sizeof name, qname, strlen(qname), resconf(), &i))
puts(name);
return 0;
} /* search_list() */
static int permute_set(int argc, char *argv[]) {
unsigned lo, hi, i;
struct dns_k_permutor p;
hi = (--argc > 0)? atoi(argv[argc]) : 8;
lo = (--argc > 0)? atoi(argv[argc]) : 0;
fprintf(stderr, "[%u .. %u]\n", lo, hi);
dns_k_permutor_init(&p, lo, hi);
for (i = lo; i <= hi; i++)
fprintf(stdout, "%u\n", dns_k_permutor_step(&p));
// printf("%u -> %u -> %u\n", i, dns_k_permutor_E(&p, i), dns_k_permutor_D(&p, dns_k_permutor_E(&p, i)));
return 0;
} /* permute_set() */
static int shuffle_16(int argc, char *argv[]) {
unsigned n, r;
if (--argc > 0) {
n = 0xffff & atoi(argv[argc]);
r = (--argc > 0)? (unsigned)atoi(argv[argc]) : dns_random();
fprintf(stdout, "%hu\n", dns_k_shuffle16(n, r));
} else {
r = dns_random();
for (n = 0; n < 65536; n++)
fprintf(stdout, "%hu\n", dns_k_shuffle16(n, r));
}
return 0;
} /* shuffle_16() */
static int dump_random(int argc, char *argv[]) {
unsigned char b[32];
unsigned i, j, n, r;
n = (argc > 1)? atoi(argv[1]) : 32;
while (n) {
i = 0;
do {
r = dns_random();
for (j = 0; j < sizeof r && i < n && i < sizeof b; i++, j++) {
b[i] = 0xff & r;
r >>= 8;
}
} while (i < n && i < sizeof b);
hexdump(b, i, stdout);
n -= i;
}
return 0;
} /* dump_random() */
static int send_query(int argc, char *argv[]) {
struct dns_packet *A, *Q = dns_p_new(512);
char host[INET6_ADDRSTRLEN + 1];
struct sockaddr_storage ss;
struct dns_socket *so;
int error, type;
if (argc > 1) {
ss.ss_family = (strchr(argv[1], ':'))? AF_INET6 : AF_INET;
if ((error = dns_pton(ss.ss_family, argv[1], dns_sa_addr(ss.ss_family, &ss, NULL))))
panic("%s: %s", argv[1], dns_strerror(error));
*dns_sa_port(ss.ss_family, &ss) = htons(53);
} else
memcpy(&ss, &resconf()->nameserver[0], dns_sa_len(&resconf()->nameserver[0]));
if (!dns_inet_ntop(ss.ss_family, dns_sa_addr(ss.ss_family, &ss, NULL), host, sizeof host))
panic("bad host address, or none provided");
if (!MAIN.qname)
MAIN.qname = "ipv6.google.com";
if (!MAIN.qtype)
MAIN.qtype = DNS_T_AAAA;
if ((error = dns_p_push(Q, DNS_S_QD, MAIN.qname, strlen(MAIN.qname), MAIN.qtype, DNS_C_IN, 0, 0)))
panic("dns_p_push: %s", dns_strerror(error));
dns_header(Q)->rd = 1;
if (strstr(argv[0], "udp"))
type = SOCK_DGRAM;
else if (strstr(argv[0], "tcp"))
type = SOCK_STREAM;
else
type = dns_res_tcp2type(resconf()->options.tcp);
fprintf(stderr, "querying %s for %s IN %s\n", host, MAIN.qname, dns_strtype(MAIN.qtype));
if (!(so = dns_so_open((struct sockaddr *)&resconf()->iface, type, dns_opts(), &error)))
panic("dns_so_open: %s", dns_strerror(error));
while (!(A = dns_so_query(so, Q, (struct sockaddr *)&ss, &error))) {
if (error != DNS_EAGAIN)
panic("dns_so_query: %s (%d)", dns_strerror(error), error);
if (dns_so_elapsed(so) > 10)
panic("query timed-out");
dns_so_poll(so, 1);
}
print_packet(A, stdout);
dns_so_close(so);
return 0;
} /* send_query() */
static int print_arpa(int argc, char *argv[]) {
const char *ip = (argc > 1)? argv[1] : "::1";
int af = (strchr(ip, ':'))? AF_INET6 : AF_INET;
union { struct in_addr a4; struct in6_addr a6; } addr;
char host[DNS_D_MAXNAME + 1];
if (1 != dns_inet_pton(af, ip, &addr) || 0 == dns_ptr_qname(host, sizeof host, af, &addr))
panic("%s: invalid address", ip);
fprintf(stdout, "%s\n", host);
return 0;
} /* print_arpa() */
static int show_hints(int argc, char *argv[]) {
struct dns_hints *(*load)(struct dns_resolv_conf *, int *);
const char *which, *how, *who;
struct dns_hints *hints;
int error;
which = (argc > 1)? argv[1] : "local";
how = (argc > 2)? argv[2] : "plain";
who = (argc > 3)? argv[3] : "google.com";
load = (0 == strcmp(which, "local"))
? &dns_hints_local
: &dns_hints_root;
if (!(hints = load(resconf(), &error)))
panic("%s: %s", argv[0], dns_strerror(error));
if (0 == strcmp(how, "plain")) {
dns_hints_dump(hints, stdout);
} else {
struct dns_packet *query, *answer;
query = dns_p_new(512);
if ((error = dns_p_push(query, DNS_S_QUESTION, who, strlen(who), DNS_T_A, DNS_C_IN, 0, 0)))
panic("%s: %s", who, dns_strerror(error));
if (!(answer = dns_hints_query(hints, query, &error)))
panic("%s: %s", who, dns_strerror(error));
print_packet(answer, stdout);
free(answer);
}
dns_hints_close(hints);
return 0;
} /* show_hints() */
static int resolve_query(int argc DNS_NOTUSED, char *argv[]) {
_Bool recurse = !!strstr(argv[0], "recurse");
struct dns_hints *(*hints)() = (recurse)? &dns_hints_root : &dns_hints_local;
struct dns_resolver *R;
struct dns_packet *ans;
const struct dns_stat *st;
int error;
if (!MAIN.qname)
MAIN.qname = "www.google.com";
if (!MAIN.qtype)
MAIN.qtype = DNS_T_A;
resconf()->options.recurse = recurse;
if (!(R = dns_res_open(resconf(), hosts(), dns_hints_mortal(hints(resconf(), &error)), cache(), dns_opts(), &error)))
panic("%s: %s", MAIN.qname, dns_strerror(error));
if ((error = dns_res_submit(R, MAIN.qname, MAIN.qtype, DNS_C_IN)))
panic("%s: %s", MAIN.qname, dns_strerror(error));
while ((error = dns_res_check(R))) {
if (error != DNS_EAGAIN)
panic("dns_res_check: %s (%d)", dns_strerror(error), error);
if (dns_res_elapsed(R) > 30)
panic("query timed-out");
dns_res_poll(R, 1);
}
ans = dns_res_fetch(R, &error);
print_packet(ans, stdout);
free(ans);
st = dns_res_stat(R);
putchar('\n');
printf(";; queries: %"PRIuZ"\n", st->queries);
printf(";; udp sent: %"PRIuZ" in %"PRIuZ" bytes\n", st->udp.sent.count, st->udp.sent.bytes);
printf(";; udp rcvd: %"PRIuZ" in %"PRIuZ" bytes\n", st->udp.rcvd.count, st->udp.rcvd.bytes);
printf(";; tcp sent: %"PRIuZ" in %"PRIuZ" bytes\n", st->tcp.sent.count, st->tcp.sent.bytes);
printf(";; tcp rcvd: %"PRIuZ" in %"PRIuZ" bytes\n", st->tcp.rcvd.count, st->tcp.rcvd.bytes);
dns_res_close(R);
return 0;
} /* resolve_query() */
static int resolve_addrinfo(int argc DNS_NOTUSED, char *argv[]) {
_Bool recurse = !!strstr(argv[0], "recurse");
struct dns_hints *(*hints)() = (recurse)? &dns_hints_root : &dns_hints_local;
struct dns_resolver *res = NULL;
struct dns_addrinfo *ai = NULL;
struct addrinfo ai_hints = { .ai_family = PF_UNSPEC, .ai_socktype = SOCK_STREAM, .ai_flags = AI_CANONNAME };
struct addrinfo *ent;
char pretty[512];
int error;
if (!MAIN.qname)
MAIN.qname = "www.google.com";
/* NB: MAIN.qtype of 0 means obey hints.ai_family */
resconf()->options.recurse = recurse;
if (!(res = dns_res_open(resconf(), hosts(), dns_hints_mortal(hints(resconf(), &error)), cache(), dns_opts(), &error)))
panic("%s: %s", MAIN.qname, dns_strerror(error));
if (!(ai = dns_ai_open(MAIN.qname, "80", MAIN.qtype, &ai_hints, res, &error)))
panic("%s: %s", MAIN.qname, dns_strerror(error));
do {
switch (error = dns_ai_nextent(&ent, ai)) {
case 0:
dns_ai_print(pretty, sizeof pretty, ent, ai);
fputs(pretty, stdout);
free(ent);
break;
case ENOENT:
break;
case DNS_EAGAIN:
if (dns_ai_elapsed(ai) > 30)
panic("query timed-out");
dns_ai_poll(ai, 1);
break;
default:
panic("dns_ai_nextent: %s (%d)", dns_strerror(error), error);
}
} while (error != ENOENT);
dns_res_close(res);
dns_ai_close(ai);
return 0;
} /* resolve_addrinfo() */
static int echo_port(int argc DNS_NOTUSED, char *argv[] DNS_NOTUSED) {
union {
struct sockaddr sa;
struct sockaddr_in sin;
} port;
int fd;
memset(&port, 0, sizeof port);
port.sin.sin_family = AF_INET;
port.sin.sin_port = htons(5354);
port.sin.sin_addr.s_addr = inet_addr("127.0.0.1");
if (-1 == (fd = socket(PF_INET, SOCK_DGRAM, 0)))
panic("socket: %s", strerror(errno));
if (0 != bind(fd, &port.sa, sizeof port.sa))
panic("127.0.0.1:5353: %s", dns_strerror(errno));
for (;;) {
struct dns_packet *pkt = dns_p_new(512);
struct sockaddr_storage ss;
socklen_t slen = sizeof ss;
ssize_t count;
#if defined(MSG_WAITALL) /* MinGW issue */
int rflags = MSG_WAITALL;
#else
int rflags = 0;
#endif
count = recvfrom(fd, (char *)pkt->data, pkt->size, rflags, (struct sockaddr *)&ss, &slen);
if (!count || count < 0)
panic("recvfrom: %s", strerror(errno));
pkt->end = count;
dns_p_dump(pkt, stdout);
(void)sendto(fd, (char *)pkt->data, pkt->end, 0, (struct sockaddr *)&ss, slen);
}
return 0;
} /* echo_port() */
static int isection(int argc, char *argv[]) {
const char *name = (argc > 1)? argv[1] : "";
int type;
type = dns_isection(name);
name = dns_strsection(type);
printf("%s (%d)\n", name, type);
return 0;
} /* isection() */
static int iclass(int argc, char *argv[]) {
const char *name = (argc > 1)? argv[1] : "";
int type;
type = dns_iclass(name);
name = dns_strclass(type);
printf("%s (%d)\n", name, type);
return 0;
} /* iclass() */
static int itype(int argc, char *argv[]) {
const char *name = (argc > 1)? argv[1] : "";
int type;
type = dns_itype(name);
name = dns_strtype(type);
printf("%s (%d)\n", name, type);
return 0;
} /* itype() */
static int iopcode(int argc, char *argv[]) {
const char *name = (argc > 1)? argv[1] : "";
int type;
type = dns_iopcode(name);
name = dns_stropcode(type);
printf("%s (%d)\n", name, type);
return 0;
} /* iopcode() */
static int ircode(int argc, char *argv[]) {
const char *name = (argc > 1)? argv[1] : "";
int type;
type = dns_ircode(name);
name = dns_strrcode(type);
printf("%s (%d)\n", name, type);
return 0;
} /* ircode() */
#define SIZE1(x) { DNS_PP_STRINGIFY(x), sizeof (x) }
#define SIZE2(x, ...) SIZE1(x), SIZE1(__VA_ARGS__)
#define SIZE3(x, ...) SIZE1(x), SIZE2(__VA_ARGS__)
#define SIZE4(x, ...) SIZE1(x), SIZE3(__VA_ARGS__)
#define SIZE(...) DNS_PP_CALL(DNS_PP_XPASTE(SIZE, DNS_PP_NARG(__VA_ARGS__)), __VA_ARGS__)
static int sizes(int argc DNS_NOTUSED, char *argv[] DNS_NOTUSED) {
static const struct { const char *name; size_t size; } type[] = {
SIZE(struct dns_header, struct dns_packet, struct dns_rr, struct dns_rr_i),
SIZE(struct dns_a, struct dns_aaaa, struct dns_mx, struct dns_ns),
SIZE(struct dns_cname, struct dns_soa, struct dns_ptr, struct dns_srv),
SIZE(struct dns_sshfp, struct dns_txt, union dns_any),
SIZE(struct dns_resolv_conf, struct dns_hosts, struct dns_hints, struct dns_hints_i),
SIZE(struct dns_options, struct dns_socket, struct dns_resolver, struct dns_addrinfo),
SIZE(struct dns_cache), SIZE(size_t), SIZE(void *), SIZE(long)
};
unsigned i, max;
for (i = 0, max = 0; i < lengthof(type); i++)
max = DNS_PP_MAX(max, strlen(type[i].name));
for (i = 0; i < lengthof(type); i++)
printf("%*s : %"PRIuZ"\n", max, type[i].name, type[i].size);
return 0;
} /* sizes() */
static const struct { const char *cmd; int (*run)(); const char *help; } cmds[] = {
{ "parse-packet", &parse_packet, "parse binary packet from stdin" },
{ "parse-domain", &parse_domain, "anchor and iteratively cleave domain" },
{ "trim-domain", &trim_domain, "trim and anchor domain name" },
{ "expand-domain", &expand_domain, "expand domain at offset NN in packet from stdin" },
{ "show-resconf", &show_resconf, "show resolv.conf data" },
{ "show-hosts", &show_hosts, "show hosts data" },
{ "show-nssconf", &show_nssconf, "show nsswitch.conf data" },
{ "query-hosts", &query_hosts, "query A, AAAA or PTR in hosts data" },
{ "search-list", &search_list, "generate query search list from domain" },
{ "permute-set", &permute_set, "generate random permutation -> (0 .. N or N .. M)" },
{ "shuffle-16", &shuffle_16, "simple 16-bit permutation" },
{ "dump-random", &dump_random, "generate random bytes" },
{ "send-query", &send_query, "send query to host" },
{ "send-query-udp", &send_query, "send udp query to host" },
{ "send-query-tcp", &send_query, "send tcp query to host" },
{ "print-arpa", &print_arpa, "print arpa. zone name of address" },
{ "show-hints", &show_hints, "print hints: show-hints [local|root] [plain|packet]" },
{ "resolve-stub", &resolve_query, "resolve as stub resolver" },
{ "resolve-recurse", &resolve_query, "resolve as recursive resolver" },
{ "addrinfo-stub", &resolve_addrinfo, "resolve through getaddrinfo clone" },
{ "addrinfo-recurse", &resolve_addrinfo, "resolve through getaddrinfo clone" },
/* { "resolve-nameinfo", &resolve_query, "resolve as recursive resolver" }, */
{ "echo", &echo_port, "server echo mode, for nmap fuzzing" },
{ "isection", &isection, "parse section string" },
{ "iclass", &iclass, "parse class string" },
{ "itype", &itype, "parse type string" },
{ "iopcode", &iopcode, "parse opcode string" },
{ "ircode", &ircode, "parse rcode string" },
{ "sizes", &sizes, "print data structure sizes" },
};
static void print_usage(const char *progname, FILE *fp) {
static const char *usage =
" [OPTIONS] COMMAND [ARGS]\n"
" -c PATH Path to resolv.conf\n"
" -n PATH Path to nsswitch.conf\n"
" -l PATH Path to local hosts\n"
" -z PATH Path to zone cache\n"
" -q QNAME Query name\n"
" -t QTYPE Query type\n"
" -s HOW Sort records\n"
" -v Be more verbose (-vv show packets; -vvv hexdump packets)\n"
" -V Print version info\n"
" -h Print this usage message\n"
"\n";
unsigned i, n, m;
fputs(progname, fp);
fputs(usage, fp);
for (i = 0, m = 0; i < lengthof(cmds); i++) {
if (strlen(cmds[i].cmd) > m)
m = strlen(cmds[i].cmd);
}
for (i = 0; i < lengthof(cmds); i++) {
fprintf(fp, " %s ", cmds[i].cmd);
for (n = strlen(cmds[i].cmd); n < m; n++)
putc(' ', fp);
fputs(cmds[i].help, fp);
putc('\n', fp);
}
fputs("\nReport bugs to William Ahern \n", fp);
} /* print_usage() */
static void print_version(const char *progname, FILE *fp) {
fprintf(fp, "%s (dns.c) %.8X\n", progname, dns_v_rel());
fprintf(fp, "vendor %s\n", dns_vendor());
fprintf(fp, "release %.8X\n", dns_v_rel());
fprintf(fp, "abi %.8X\n", dns_v_abi());
fprintf(fp, "api %.8X\n", dns_v_api());
} /* print_version() */
int main(int argc, char **argv) {
extern int optind;
extern char *optarg;
const char *progname = argv[0];
unsigned i;
int ch;
while (-1 != (ch = getopt(argc, argv, "q:t:c:n:l:z:s:vVh"))) {
switch (ch) {
case 'c':
assert(MAIN.resconf.count < lengthof(MAIN.resconf.path));
MAIN.resconf.path[MAIN.resconf.count++] = optarg;
break;
case 'n':
assert(MAIN.nssconf.count < lengthof(MAIN.nssconf.path));
MAIN.nssconf.path[MAIN.nssconf.count++] = optarg;
break;
case 'l':
assert(MAIN.hosts.count < lengthof(MAIN.hosts.path));
MAIN.hosts.path[MAIN.hosts.count++] = optarg;
break;
case 'z':
assert(MAIN.cache.count < lengthof(MAIN.cache.path));
MAIN.cache.path[MAIN.cache.count++] = optarg;
break;
case 'q':
MAIN.qname = optarg;
break;
case 't':
for (i = 0; i < lengthof(dns_rrtypes); i++) {
if (0 == strcasecmp(dns_rrtypes[i].name, optarg))
{ MAIN.qtype = dns_rrtypes[i].type; break; }
}
if (MAIN.qtype)
break;
for (i = 0; dns_isdigit(optarg[i]); i++) {
MAIN.qtype *= 10;
MAIN.qtype += optarg[i] - '0';
}
if (!MAIN.qtype)
panic("%s: invalid query type", optarg);
break;
case 's':
if (0 == strcasecmp(optarg, "packet"))
MAIN.sort = &dns_rr_i_packet;
else if (0 == strcasecmp(optarg, "shuffle"))
MAIN.sort = &dns_rr_i_shuffle;
else if (0 == strcasecmp(optarg, "order"))
MAIN.sort = &dns_rr_i_order;
else
panic("%s: invalid sort method", optarg);
break;
case 'v':
dns_debug = ++MAIN.verbose;
break;
case 'V':
print_version(progname, stdout);
return 0;
case 'h':
print_usage(progname, stdout);
return 0;
default:
print_usage(progname, stderr);
return EXIT_FAILURE;
} /* switch() */
} /* while() */
argc -= optind;
argv += optind;
for (i = 0; i < lengthof(cmds) && argv[0]; i++) {
if (0 == strcmp(cmds[i].cmd, argv[0]))
return cmds[i].run(argc, argv);
}
print_usage(progname, stderr);
return EXIT_FAILURE;
} /* main() */
#endif /* DNS_MAIN */
/*
* pop file-scoped compiler annotations
*/
#if __clang__
#pragma clang diagnostic pop
#elif DNS_GNUC_PREREQ(4,6,0)
#pragma GCC diagnostic pop
#endif
belle-sip-5.2.0+dfsg/src/dns/dns.h 0000664 0000000 0000000 00000104365 14346131365 0016640 0 ustar 00root root 0000000 0000000 /* ==========================================================================
* dns.h - Recursive, Reentrant DNS Resolver.
* --------------------------------------------------------------------------
* Copyright (c) 2009, 2010, 2012-2015 William Ahern
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to permit
* persons to whom the Software is furnished to do so, subject to the
* following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
* NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
* ==========================================================================
*/
#ifndef DNS_H
#define DNS_H
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include /* size_t offsetof() */
#include /* FILE */
#include