(belle_sip_source_get_user_data(source));
belle_sip_source_set_user_data(source,NULL);
}
/*purpose of this function is to simplify c++ timer integration.
* ex:
* std::string helloworld("Hello world):
* belle_sip_source_cpp_func_t *func = new belle_sip_source_cpp_func_t([helloworld](unsigned int events) {
* std::cout << helloworld << std::endl;
* return BELLE_SIP_STOP;
* });
*create timer
*mTimer = belle_sip_main_loop_create_cpp_timeout( mainloop
* , func
* , 1000
* ,"timer for c++");
*
*/
BELLESIP_EXPORT inline 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)
{
belle_sip_source_t* source = belle_sip_main_loop_create_timeout( ml
, (belle_sip_source_func_t)belle_sip_source_cpp_func
, func
, timeout_value_ms
, timer_name);
belle_sip_source_set_remove_cb(source,belle_sip_source_on_remove);
return source;
}
#endif
#endif
belle-sip-1.6.3/include/belle-sip/message.h 0000664 0000000 0000000 00000016700 13134375224 0020501 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 .
*/
#ifndef BELLE_SIP_MESSAGE_H
#define BELLE_SIP_MESSAGE_H
#include "belle-sip/headers.h"
#define BELLE_SIP_MESSAGE(obj) BELLE_SIP_CAST(obj,belle_sip_message_t)
#define BELLE_SIP_REQUEST(obj) BELLE_SIP_CAST(obj,belle_sip_request_t)
#define BELLE_SIP_RESPONSE(obj) BELLE_SIP_CAST(obj,belle_sip_response_t)
BELLE_SIP_BEGIN_DECLS
BELLESIP_EXPORT belle_sip_message_t* belle_sip_message_parse(const char* raw);
/**
* Parse sip message from a raw buffer
* @param [in] buff buffer to be parsed
* @param [in] buff_length size of the buffer to be parsed
* @param [out] message_length number of bytes read
* @return parsed message
*/
BELLESIP_EXPORT belle_sip_message_t* belle_sip_message_parse_raw (const char* buff, size_t buff_length,size_t* message_length );
BELLESIP_EXPORT int belle_sip_message_is_request(belle_sip_message_t *msg);
BELLESIP_EXPORT belle_sip_request_t* belle_sip_request_new(void);
BELLESIP_EXPORT belle_sip_request_t* belle_sip_request_parse(const char* raw);
BELLESIP_EXPORT belle_sip_request_t* belle_sip_request_create(belle_sip_uri_t *requri, const char* method,
belle_sip_header_call_id_t *callid,
belle_sip_header_cseq_t *cseq,
belle_sip_header_from_t *from,
belle_sip_header_to_t *to,
belle_sip_header_via_t *via,
int max_forwards);
BELLESIP_EXPORT belle_sip_uri_t* belle_sip_request_get_uri(const belle_sip_request_t* request);
BELLESIP_EXPORT void belle_sip_request_set_uri(belle_sip_request_t* request, belle_sip_uri_t* uri);
BELLESIP_EXPORT const char* belle_sip_request_get_method(const belle_sip_request_t* request);
BELLESIP_EXPORT void belle_sip_request_set_method(belle_sip_request_t* request,const char* method);
/**
* Guess the origin of the received sip message from VIA header (thanks to received/rport)
* @param req request to be analyzed
* @ return a newly allocated uri
* */
BELLESIP_EXPORT belle_sip_uri_t* belle_sip_request_extract_origin(const belle_sip_request_t* req);
/**
* Clone all sip headers + body if any
* @param req message to be cloned
* @return newly allocated request
*/
BELLESIP_EXPORT belle_sip_request_t * belle_sip_request_clone_with_body(const belle_sip_request_t *initial_req);
/**
* returns an absolute uri. A header address cannot have both a sip uri and an absolute uri.
*/
BELLESIP_EXPORT belle_generic_uri_t* belle_sip_request_get_absolute_uri(const belle_sip_request_t* req);
/**
* set an absolute uri. A header address cannot have both a sip uri and an absolute uri. This function also to uri to NULL
*/
BELLESIP_EXPORT void belle_sip_request_set_absolute_uri(belle_sip_request_t* req, belle_generic_uri_t* uri);
BELLESIP_EXPORT int belle_sip_message_is_response(const belle_sip_message_t *msg);
BELLESIP_EXPORT belle_sip_header_t *belle_sip_message_get_header(const belle_sip_message_t *msg, const char *header_name);
BELLESIP_EXPORT belle_sip_object_t *_belle_sip_message_get_header_by_type_id(const belle_sip_message_t *message, belle_sip_type_id_t id);
#define belle_sip_message_get_header_by_type(msg,header_type)\
(header_type*)_belle_sip_message_get_header_by_type_id(BELLE_SIP_MESSAGE(msg),BELLE_SIP_TYPE_ID(header_type))
BELLESIP_EXPORT const belle_sip_list_t* belle_sip_message_get_headers(const belle_sip_message_t *message,const char* header_name);
/**
* Get list of all headers present in the message.
* @param message
* @return a newly allocated list of belle_sip_header_t
* */
BELLESIP_EXPORT belle_sip_list_t* belle_sip_message_get_all_headers(const belle_sip_message_t *message);
BELLESIP_EXPORT void belle_sip_message_add_first(belle_sip_message_t *msg, belle_sip_header_t* header);
/**
* add an header to this message
* @param msg
* @param header to add, must be one of header type
*/
BELLESIP_EXPORT void belle_sip_message_add_header(belle_sip_message_t *msg, belle_sip_header_t* header);
BELLESIP_EXPORT void belle_sip_message_add_headers(belle_sip_message_t *message, const belle_sip_list_t *header_list);
BELLESIP_EXPORT void belle_sip_message_set_header(belle_sip_message_t *msg, belle_sip_header_t* header);
BELLESIP_EXPORT void belle_sip_message_remove_first(belle_sip_message_t *msg, const char *header_name);
BELLESIP_EXPORT void belle_sip_message_remove_last(belle_sip_message_t *msg, const char *header_name);
BELLESIP_EXPORT void belle_sip_message_remove_header(belle_sip_message_t *msg, const char *header_name);
BELLESIP_EXPORT void belle_sip_message_remove_header_from_ptr(belle_sip_message_t *msg, belle_sip_header_t* header);
BELLESIP_EXPORT char *belle_sip_message_to_string(belle_sip_message_t *msg);
BELLESIP_EXPORT belle_sip_body_handler_t *belle_sip_message_get_body_handler(const belle_sip_message_t *msg);
BELLESIP_EXPORT void belle_sip_message_set_body_handler(belle_sip_message_t *msg, belle_sip_body_handler_t *body_handler);
BELLESIP_EXPORT const char* belle_sip_message_get_body(belle_sip_message_t *msg);
BELLESIP_EXPORT size_t belle_sip_message_get_body_size(const belle_sip_message_t *msg);
BELLESIP_EXPORT void belle_sip_message_set_body(belle_sip_message_t *msg,const char* body,size_t size);
BELLESIP_EXPORT void belle_sip_message_assign_body(belle_sip_message_t *msg, char* body, size_t size);
BELLESIP_EXPORT int belle_sip_response_get_status_code(const belle_sip_response_t *response);
BELLESIP_EXPORT void belle_sip_response_set_status_code(belle_sip_response_t *response,int status);
BELLESIP_EXPORT const char* belle_sip_response_get_reason_phrase(const belle_sip_response_t *response);
BELLESIP_EXPORT void belle_sip_response_set_reason_phrase(belle_sip_response_t *response,const char* reason_phrase);
BELLESIP_EXPORT belle_sip_response_t *belle_sip_response_new(void);
BELLESIP_EXPORT belle_sip_response_t *belle_sip_response_create_from_request(belle_sip_request_t *req, int status_code);
/**
* This method takes received/rport/via value of the reponse and update the contact IP/port accordingly
* @param response use to extract via/received/rport from top most via.
* @param contact contact to be updated
* @returns 0 if no error
* */
BELLESIP_EXPORT int belle_sip_response_fix_contact(const belle_sip_response_t* response,belle_sip_header_contact_t* contact);
/**
* Check for mandatory headers and parameters.
* If message does not satisfy minimum requirements return FALSE, otherwise return TRUE.
**/
BELLESIP_EXPORT int belle_sip_message_check_headers(const belle_sip_message_t* message);
/**
* check uri components of headers and req uri.
* return 0 if not compliant
* */
BELLESIP_EXPORT int belle_sip_request_check_uris_components(const belle_sip_request_t* request);
BELLE_SIP_END_DECLS
#endif
belle-sip-1.6.3/include/belle-sip/object.h 0000664 0000000 0000000 00000052276 13134375224 0020333 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 .
*/
#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_VPTR(object_type,parent_type,destroy,clone,marshal,unowned) \
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_DEFAULT_BUFSIZE_HINT\
}; \
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_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, that there are created with a ref count of 1, or
* initially unowned, that is 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;
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);
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;
int tostring_bufsize_hint; /*optimization: you can suggest here the typical size for a to_string() result.*/
};
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);
#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)())
/**
* 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);
/**
* 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);
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(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-1.6.3/include/belle-sip/parameters.h 0000664 0000000 0000000 00000005503 13134375224 0021217 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 .
*/
#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-1.6.3/include/belle-sip/provider.h 0000664 0000000 0000000 00000014064 13134375224 0020710 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 .
*/
#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);
/**
* 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);
/**
* 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);
/**
* 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);
/**
* 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);
BELLE_SIP_END_DECLS
#define BELLE_SIP_PROVIDER(obj) BELLE_SIP_CAST(obj,belle_sip_provider_t)
#endif
belle-sip-1.6.3/include/belle-sip/refresher.h 0000664 0000000 0000000 00000011146 13134375224 0021041 0 ustar 00root root 0000000 0000000 /*
belle-sip - SIP (RFC3261) library.
Copyright (C) 2012 Belledonne Communications SARL, 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, 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-1.6.3/include/belle-sip/resolver.h 0000664 0000000 0000000 00000013345 13134375224 0020720 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 .
*/
#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)
/**
* 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 ai_list contains addrinfo elements that must be taken and (possibly later) freed by the callee, using freeaddrinfo().
* These elements are linked by their ai_next field.
**/
typedef void (*belle_sip_resolver_callback_t)(void *data, const char *name, struct addrinfo *ai_list, uint32_t ttl);
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);
/**
* 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-1.6.3/include/belle-sip/sip-uri.h 0000664 0000000 0000000 00000020635 13134375224 0020447 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 .
*/
#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);
/**
* 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);
/**
* 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;
}
};
}
#include
namespace bellesip {
struct UriComparator : public std::binary_function {
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-1.6.3/include/belle-sip/sipstack.h 0000664 0000000 0000000 00000015171 13134375224 0020677 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 .
*/
#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;
BELLE_SIP_BEGIN_DECLS
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);
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);
/**
* 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);
/**
* 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.
**/
BELLESIP_EXPORT void belle_sip_stack_set_inactive_transport_timeout(belle_sip_stack_t *stack, int seconds);
/**
* 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);
BELLE_SIP_END_DECLS
#endif
belle-sip-1.6.3/include/belle-sip/transaction.h 0000664 0000000 0000000 00000011407 13134375224 0021401 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 .
*/
#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);
#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-1.6.3/include/belle-sip/types.h 0000664 0000000 0000000 00000020642 13134375224 0020221 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 .
*/
#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_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_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_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_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_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-1.6.3/include/belle-sip/utils.h 0000664 0000000 0000000 00000011627 13134375224 0020220 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 .
*/
#ifndef BELLE_SIP_UTILS_H
#define BELLE_SIP_UTILS_H
#include
#include
#include
#include
#include "belle-sip/defs.h"
#ifdef BCTBX_LOG_DOMAIN
#undef BCTBX_LOG_DOMAIN
#endif
#ifndef BELLE_SIP_LOG_DOMAIN
#define BELLE_SIP_LOG_DOMAIN "belle-sip"
#endif
#define BCTBX_LOG_DOMAIN BELLE_SIP_LOG_DOMAIN
#include "bctoolbox/logging.h"
#include "bctoolbox/vconnect.h"
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 BctoolboxLogFunc
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
#define belle_sip_set_log_file bctbx_set_log_file
#define belle_sip_set_log_handler bctbx_set_log_handler
#define belle_sip_get_log_handler bctbx_get_log_handler
#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 unsigned char * belle_sip_random_bytes(unsigned char *ret, size_t size);
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);
BELLESIP_EXPORT unsigned int belle_sip_random(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);
/**
* create a directory if it doesn't already exists
*
* @param[in] path The directory to be created
* @return 0 in case of succes, -1 otherwise, note it returns -1 if the directory already exists
*/
BELLESIP_EXPORT int belle_sip_mkdir(const char *path);
BELLE_SIP_END_DECLS
#endif
belle-sip-1.6.3/include/belle-sip/wakelock.h 0000664 0000000 0000000 00000001216 13134375224 0020651 0 ustar 00root root 0000000 0000000 #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-1.6.3/src/ 0000775 0000000 0000000 00000000000 13134375224 0014170 5 ustar 00root root 0000000 0000000 belle-sip-1.6.3/src/CMakeLists.txt 0000664 0000000 0000000 00000021540 13134375224 0016732 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(INCLUDES ${ANTLR3C_INCLUDE_DIRS})
set(LIBS ${ANTLR3C_LIBRARIES})
list(APPEND INCLUDES ${BCTOOLBOX_CORE_INCLUDE_DIR})
list(APPEND LIBS ${BCTOOLBOX_CORE_LIBRARIES})
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(WIN32)
list(APPEND LIBS ws2_32)
endif()
set(SDP_GENERATED_SOURCE_FILES_C
${CMAKE_CURRENT_BINARY_DIR}/grammars/belle_sdpLexer.c
${CMAKE_CURRENT_BINARY_DIR}/grammars/belle_sdpLexer.h
${CMAKE_CURRENT_BINARY_DIR}/grammars/belle_sdpParser.c
${CMAKE_CURRENT_BINARY_DIR}/grammars/belle_sdpParser.h
)
add_custom_command(
OUTPUT ${SDP_GENERATED_SOURCE_FILES_C}
COMMAND ${ANTLR3_COMMAND} -make -Xmultithreaded -Xconversiontimeout 10000 -fo ${CMAKE_CURRENT_BINARY_DIR}/grammars ${CMAKE_CURRENT_SOURCE_DIR}/grammars/belle_sdp.g
DEPENDS grammars/belle_sdp.g
)
set(SIP_MESSAGE_GENERATED_SOURCE_FILES_C
${CMAKE_CURRENT_BINARY_DIR}/grammars/belle_sip_messageLexer.c
${CMAKE_CURRENT_BINARY_DIR}/grammars/belle_sip_messageLexer.h
${CMAKE_CURRENT_BINARY_DIR}/grammars/belle_sip_messageParser.c
${CMAKE_CURRENT_BINARY_DIR}/grammars/belle_sip_messageParser.h
)
add_custom_command(
OUTPUT ${SIP_MESSAGE_GENERATED_SOURCE_FILES_C}
COMMAND ${ANTLR3_COMMAND} -make -Xmultithreaded -Xconversiontimeout 10000 -fo ${CMAKE_CURRENT_BINARY_DIR}/grammars ${CMAKE_CURRENT_SOURCE_DIR}/grammars/belle_sip_message.g
DEPENDS grammars/belle_sip_message.g
)
set_source_files_properties(${SDP_GENERATED_SOURCE_FILES_C} ${SIP_MESSAGE_GENERATED_SOURCE_FILES_C} PROPERTIES GENERATED TRUE)
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()
set(BELLE_SIP_SOURCE_FILES_C
auth_event.c
auth_helper.c
belle_sdp_impl.c
belle_sip_dict.c
belle_sip_headers_impl.c
belle_sip_internal.h
belle_sip_loop.c
belle_sip_object.c
belle_sip_parameters.c
belle_sip_resolver.c
belle_sip_uri_impl.c
belle_sip_utils.c
bodyhandler.c
channel.c
channel.h
clock_gettime.c
clock_gettime.h
dialog.c
dns.c
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}
)
if(ANDROID)
list(APPEND BELLE_SIP_SOURCE_FILES_C wakelock.c)
endif()
set(BELLE_SIP_SOURCE_FILES_CXX
${TUNNEL_SOURCE_FILES_CXX}
)
if(APPLE)
set(BELLE_SIP_SOURCE_FILES_OBJC
backgroundtask.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)
get_source_file_property(DNS_C_COMPILE_FLAGS dns.c COMPILE_FLAGS)
set(DNS_C_COMPILE_FLAGS "${DNS_C_COMPILE_FLAGS} /wd4267") # Disable "possible loss of data" warnings
set(DNS_C_COMPILE_FLAGS "${DNS_C_COMPILE_FLAGS} /wd4804") # Disable "unsafe use of type 'bool' in operation" warnings
set(DNS_C_COMPILE_FLAGS "${DNS_C_COMPILE_FLAGS} /wd4244") # Disable "conversion from 'intmax_t' to 'int', possible loss of data" warnings
set(DNS_C_COMPILE_FLAGS "${DNS_C_COMPILE_FLAGS} /wd4305") # Disable "'initializing': truncation from 'unsigned int' to 'UCHAR'" warnings
set(DNS_C_COMPILE_FLAGS "${DNS_C_COMPILE_FLAGS} /wd4018") # Disable "signed/unsigned mismatch" warnings
set_source_files_properties(dns.c PROPERTIES COMPILE_FLAGS "${DNS_C_COMPILE_FLAGS}")
get_source_file_property(SDP_PARSER_COMPILE_FLAGS grammars/belle_sdpParser.c COMPILE_FLAGS)
set(SDP_PARSER_COMPILE_FLAGS "${SDP_PARSER_COMPILE_FLAGS} /wd4267") # Disable "possible loss of data" warnings
set_source_files_properties(grammars/belle_sdpParser.c PROPERTIES COMPILE_FLAGS "${SDP_PARSER_COMPILE_FLAGS}")
get_source_file_property(SIP_MESSAGE_PARSER_COMPILE_FLAGS grammars/belle_sip_messageParser.c COMPILE_FLAGS)
set(SIP_MESSAGE_PARSER_COMPILE_FLAGS "${SIP_MESSAGE_PARSER_COMPILE_FLAGS} /wd4267") # Disable "possible loss of data" warnings
set_source_files_properties(grammars/belle_sip_messageParser.c PROPERTIES COMPILE_FLAGS "${SIP_MESSAGE_PARSER_COMPILE_FLAGS}")
else()
get_source_file_property(DNS_C_COMPILE_FLAGS dns.c COMPILE_FLAGS)
set(DNS_C_COMPILE_FLAGS "${DNS_C_COMPILE_FLAGS} -Wno-error")
set_source_files_properties(dns.c PROPERTIES COMPILE_FLAGS "${DNS_C_COMPILE_FLAGS}")
get_source_file_property(SIP_MESSAGE_PARSER_COMPILE_FLAGS grammars/belle_sip_messageParser.c COMPILE_FLAGS)
set(SIP_MESSAGE_PARSER_COMPILE_FLAGS "${SIP_MESSAGE_PARSER_COMPILE_FLAGS} -Wno-sign-compare")
set_source_files_properties(grammars/belle_sip_messageParser.c PROPERTIES COMPILE_FLAGS "${SIP_MESSAGE_PARSER_COMPILE_FLAGS}")
endif()
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})
set_target_properties(bellesip-static PROPERTIES OUTPUT_NAME bellesip)
target_include_directories(bellesip-static PUBLIC ${INCLUDES})
target_link_libraries(bellesip-static INTERFACE ${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})
set_target_properties(bellesip PROPERTIES SOVERSION 0)
set_target_properties(bellesip PROPERTIES LINKER_LANGUAGE CXX)
target_include_directories(bellesip PUBLIC ${INCLUDES})
target_link_libraries(bellesip PRIVATE ${LIBS})
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 ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/bellesip.pdb
DESTINATION ${CMAKE_INSTALL_BINDIR}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)
endif()
endif()
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()
belle-sip-1.6.3/src/Makefile.am 0000775 0000000 0000000 00000003622 13134375224 0016232 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-1.6.3/src/auth_event.c 0000664 0000000 0000000 00000013045 13134375224 0016501 0 ustar 00root root 0000000 0000000 /*
auth_info.c 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 .
*/
#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)
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);
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) {
if (event->cert) belle_sip_object_unref(event->cert);
event->cert=value;
if (event->cert) belle_sip_object_ref(event->cert);
}
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...*/
#ifdef __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 __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;
}
belle-sip-1.6.3/src/auth_helper.c 0000664 0000000 0000000 00000025573 13134375224 0016650 0 ustar 00root root 0000000 0000000 /*
auth_helper.c 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 .
*/
#include "belle-sip/auth-helper.h"
#include "belle_sip_internal.h"
#include "md5.h"
#include
#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;
}
int belle_sip_auth_helper_compute_ha1(const char* userid,const char* realm,const char* password, char ha1[33]) {
md5_byte_t out[16];
md5_state_t state;
int di;
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;
}
belle_sip_md5_init(&state);
belle_sip_md5_append(&state,(const md5_byte_t *)userid,(int)strlen(userid));
belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
belle_sip_md5_append(&state,(const md5_byte_t *)realm,(int)strlen(realm));
belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
belle_sip_md5_append(&state,(const md5_byte_t *)password,(int)strlen(password));
belle_sip_md5_finish(&state,out);
for (di = 0; di < 16; ++di)
sprintf(ha1 + di * 2, "%02x", out[di]);
ha1[32]='\0';
return 0;
}
int belle_sip_auth_helper_compute_ha2(const char* method,const char* uri, char ha2[33]) {
md5_byte_t out[16];
md5_state_t state;
int di;
ha2[32]='\0';
/*HA2=MD5(method:uri)*/
belle_sip_md5_init(&state);
belle_sip_md5_append(&state,(const md5_byte_t *)method,(int)strlen(method));
belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
belle_sip_md5_append(&state,(const md5_byte_t *)uri,(int)strlen(uri));
belle_sip_md5_finish(&state,out);
for (di = 0; di < 16; ++di)
sprintf(ha2 + di * 2, "%02x", out[di]);
return 0;
}
int belle_sip_auth_helper_compute_response(const char* ha1,const char* nonce, const char* ha2, char response[33]) {
md5_byte_t out[16];
md5_state_t state;
int di;
response[32]='\0';
belle_sip_md5_init(&state);
belle_sip_md5_append(&state,(const md5_byte_t *)ha1,(int)strlen(ha1));
belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
belle_sip_md5_append(&state,(const md5_byte_t *)nonce,(int)strlen(nonce));
belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
belle_sip_md5_append(&state,(const md5_byte_t *)ha2,(int)strlen(ha2));
belle_sip_md5_finish(&state,out);
/*copy values*/
for (di = 0; di < 16; ++di)
sprintf(response + di * 2, "%02x", out[di]);
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]) {
md5_byte_t out[16];
md5_state_t state;
char nounce_count_as_string[9];
int di;
response[32]='\0';
snprintf(nounce_count_as_string,sizeof(nounce_count_as_string),"%08x",nonce_count);
/*response=MD5(HA1:nonce:nonce_count:cnonce:qop:HA2)*/
belle_sip_md5_init(&state);
belle_sip_md5_append(&state,(const md5_byte_t *)ha1,(int)strlen(ha1));
belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
belle_sip_md5_append(&state,(const md5_byte_t *)nonce,(int)strlen(nonce));
belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
belle_sip_md5_append(&state,(const md5_byte_t *)nounce_count_as_string,(int)strlen(nounce_count_as_string));
belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
belle_sip_md5_append(&state,(const md5_byte_t *)cnonce,(int)strlen(cnonce));
belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
belle_sip_md5_append(&state,(const md5_byte_t *)qop,(int)strlen(qop));
belle_sip_md5_append(&state,(const md5_byte_t *)":",1);
belle_sip_md5_append(&state,(const md5_byte_t *)ha2,(int)strlen(ha2));
belle_sip_md5_finish(&state,out);
/*copy values*/
for (di = 0; di < 16; ++di)
sprintf(response + di * 2, "%02x", out[di]);
return 0;
}
int belle_sip_auth_helper_fill_authorization(belle_sip_header_authorization_t* authorization
,const char* method
,const char* ha1) {
int auth_mode=0;
char* uri;
char ha2[16*2 + 1];
char response[16*2 + 1];
char cnonce[BELLE_SIP_CNONCE_LENGTH + 1];
response[32]=ha2[32]='\0';
if (belle_sip_header_authorization_get_scheme(authorization) != NULL &&
strcmp("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=strcmp("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(method,uri,ha2);
belle_sip_free(uri);
if (auth_mode) {
/*response=MD5(HA1:nonce:nonce_count:cnonce:qop:HA2)*/
belle_sip_auth_helper_compute_response_qop_auth(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);
} else {
/*response=MD5(ha1:nonce:ha2)*/
belle_sip_auth_helper_compute_response(ha1,belle_sip_header_authorization_get_nonce(authorization),ha2,response);
}
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-1.6.3/src/backgroundtask.m 0000664 0000000 0000000 00000007037 13134375224 0017357 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 .
*/
#include "belle_sip_internal.h"
#if TARGET_OS_IPHONE==1
#include
typedef struct fallback_callback_data{
unsigned long task_id;
}fallback_callback_data_t;
static void fallback_callback(void *data){
fallback_callback_data_t *fbd=(fallback_callback_data_t*)data;
belle_sip_end_background_task(fbd->task_id);
belle_sip_free(fbd);
}
unsigned long belle_sip_begin_background_task(const char *name, belle_sip_background_task_end_callback_t cb, void *data){
UIApplication *app=[UIApplication sharedApplication];
UIBackgroundTaskIdentifier bgid = UIBackgroundTaskInvalid;
fallback_callback_data_t *fbd=NULL;
if (cb==NULL){
cb=fallback_callback;
data=fbd=(fallback_callback_data_t*)belle_sip_malloc0(sizeof(fallback_callback_data_t));
}
void (^handler)() = ^{
cb(data);
};
if([app respondsToSelector:@selector(beginBackgroundTaskWithName:expirationHandler:)]){
bgid = [app beginBackgroundTaskWithName:[NSString stringWithUTF8String:name] expirationHandler:handler];
} else {
bgid = [app beginBackgroundTaskWithExpirationHandler:handler];
}
if (bgid==UIBackgroundTaskInvalid){
belle_sip_error("Could not start background task %s.", name);
return 0;
}
// backgroundTimeRemaining is properly set only when running background... but not immediately!
if (app.applicationState != UIApplicationStateBackground || (app.backgroundTimeRemaining == DBL_MAX)) {
belle_sip_message("Background task %s started. Unknown remaining time since application is not fully in background.", name);
} else {
belle_sip_message("Background task %s started. Remaining time %.1f secs", name, app.backgroundTimeRemaining);
}
if (fbd) fbd->task_id=bgid;
return (unsigned long)bgid;
}
void belle_sip_end_background_task(unsigned long id){
UIApplication *app=[UIApplication sharedApplication];
[app endBackgroundTask:(UIBackgroundTaskIdentifier)id];
}
#else
/*mac*/
@import Foundation;
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-1.6.3/src/belle_sdp_impl.c 0000664 0000000 0000000 00000213066 13134375224 0017316 0 ustar 00root root 0000000 0000000 /*
belle-sdp - SIP (RFC4566) 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 .
*/
#include "belle-sip/belle-sip.h"
#include "grammars/belle_sdpParser.h"
#include "grammars/belle_sdpLexer.h"
#include "belle_sip_internal.h"
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 }
};
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_PARSE(attribute)
GET_SET_STRING(belle_sdp_attribute,name);
/***************************************************************************************
* 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;
}
/***************************************************************************************
* 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;
}
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_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_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;
// belle_sip_list_t* attributes;
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;
}
// for(attributes=base_description->attributes;attributes!=NULL;attributes=attributes->next){
// error=belle_sip_object_marshal(BELLE_SIP_OBJECT(attributes->data),buff,buff_size,offset);
// error=belle_sip_snprintf(buff, buff_size, offset, "\r\n");
// }
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;
}
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));
}
void belle_sdp_base_description_add_attribute(belle_sdp_base_description_t* base_description, const belle_sdp_attribute_t* attribute) {
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;
}
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;
}
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[10];
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[10];
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, const 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, const 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_key(belle_sdp_media_description_t* media_description,belle_sdp_key_t* key);*/
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;
}
//BELLE_SDP_PARSE(session_name)
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) {
/*session_description: proto_version CR LF
origin_field
session_name_field
(info CR LF)?
uri_field?
(email CR LF)*
phone_field*
(connection CR LF)?
(bandwidth CR LF)*
time_field
(repeat_time CR LF)?
(zone_adjustments CR LF)?
(key_field CR LF)?
(attribute CR LF)*
media_descriptions;
*/
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));
}
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_sdp_key_t* belle_sdp_session_description_get_key(const belle_sdp_session_description_t* session_description);*/
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, const 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, const 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_key(belle_sdp_session_description_t* session_description, belle_sdp_key_t* key);*/
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)
}
/************************
* time
***********************/
struct _belle_sdp_time {
belle_sip_object_t base;
int start;
int 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,"%i %i",time->start,time->stop);
}
BELLE_SDP_NEW(time,belle_sip_object)
//BELLE_SDP_PARSE(version)
GET_SET_INT(belle_sdp_time,start,int);
GET_SET_INT(belle_sdp_time,stop,int);
/************************
* 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 (int start,int 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;
}
//BELLE_SDP_PARSE(version)
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-1.6.3/src/belle_sip_dict.c 0000664 0000000 0000000 00000007563 13134375224 0017310 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 .
*/
#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-1.6.3/src/belle_sip_headers_impl.c 0000664 0000000 0000000 00000252746 13134375224 0021026 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 .
*/
#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, "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, 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, 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_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;
};
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)))));
}
}
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);
}
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);
}
}
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;
}
/*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 automatic;
unsigned char unknown;
unsigned char pad[1];
};
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;
contact->automatic=orig->automatic;
}
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);
}
void belle_sip_header_contact_set_automatic(belle_sip_header_contact_t *a, int enabled){
a->automatic=enabled;
}
int belle_sip_header_contact_get_automatic(const belle_sip_header_contact_t *a){
return a->automatic;
}
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 inherent 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);
}
/******************************
* 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);
/**************************
* cseq header object inherent 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 inherent 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 inherent 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 inherent 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 inherent 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 inherent 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 inherent 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 inherent 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;
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(authorization,belle_http_header_authorization_t)) {
format="%sqop=\"%s\"";
} else {
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 inherent 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 inherent 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 inherent 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 inherent 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 inherent 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 inherent 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 inherent 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[16] ={0};
char tmp2[16] ={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 inherent 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,",")
/******************************
* 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 inherent 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-1.6.3/src/belle_sip_internal.h 0000664 0000000 0000000 00000124144 13134375224 0020201 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 .
*/
#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
/*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;
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);
#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_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_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_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_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);
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
int 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);\
}
#ifdef HAVE_ANTLR_STRING_STREAM_NEW
#define ANTLR_STREAM_NEW(object_type, value,length) \
antlr3StringStreamNew((pANTLR3_UINT8)value,ANTLR3_ENC_8BIT,(ANTLR3_UINT32)length,(pANTLR3_UINT8)#object_type)
#else
#define ANTLR_STREAM_NEW(object_type, value, length) \
antlr3NewAsciiStringCopyStream((pANTLR3_UINT8)value,(ANTLR3_UINT32)length,NULL)
#endif /*HAVE_ANTLR_STRING_STREAM_NEW*/
#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);
/*calss 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;
};
/*
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 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 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*/
unsigned char dns_srv_enabled;
unsigned char dns_search_enabled;
};
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);
/*
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 char rport_enabled; /*0 if rport should not be set in via header*/
unsigned char nat_helper;
unsigned char unconditional_answer_enabled;
unsigned short unconditional_answer;
};
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);
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);
/*
* SIP and http messages
**/
#define BELLESIP_MULTIPART_BOUNDARY "---------------------------14737809831466499882746641449"
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;
};
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;
};
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);
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;
};
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;
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. */
};
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_is_authorized_transaction(const belle_sip_dialog_t *dialog,const char* method) ;
/*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) { \
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;\
}
#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;
};
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_username(const char* buff) ;
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) ;
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
void belle_sip_multipart_body_handler_progress_cb(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, void *user_data, size_t transfered, size_t expected_total);
/**
* file manipulation
*/
/**
* Parse a directory and return all files in it.
*
* @param[in] path The directory to be parsed
* @param[in] file_type if not NULL return only the file with the given extension, must include the '.', ex:".pem"
* @return a belle_sip list containing all found file or NULL if no file were found or directory doesn't exist. List must be destroyed using belle_sip_list_free_with_data(, belle_sip_free)
*/
belle_sip_list_t *belle_sip_parse_directory(const char *path, const char *file_type);
typedef struct authorization_context authorization_context_t;
BELLESIP_EXPORT void belle_sip_authorization_destroy(authorization_context_t* object);
#endif
belle-sip-1.6.3/src/belle_sip_loop.c 0000664 0000000 0000000 00000046644 13134375224 0017341 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 .
*/
#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;
belle_sip_object_pool_t *pool;
int nsources;
int run;
int in_loop;
bctbx_mutex_t timer_sources_mutex;
};
void belle_sip_main_loop_remove_source(belle_sip_main_loop_t *ml, belle_sip_source_t *source){
bool_t elem_removed = FALSE;
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);
belle_sip_object_unref(source);
elem_removed = TRUE;
}
if (source->it) {
bctbx_mutex_lock(&ml->timer_sources_mutex);
bctbx_map_erase(ml->timer_sources, source->it);
bctbx_iterator_delete(source->it);
bctbx_mutex_unlock(&ml->timer_sources_mutex);
source->it=NULL;
belle_sip_object_unref(source);
elem_removed = TRUE;
}
if (elem_removed) {
source->cancelled=TRUE;
ml->nsources--;
if (source->on_remove)
source->on_remove(source);
}
}
static void belle_sip_main_loop_destroy(belle_sip_main_loop_t *ml){
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->timer_sources_mutex);
}
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->timer_sources_mutex,NULL);
return m;
}
void belle_sip_main_loop_add_source(belle_sip_main_loop_t *ml, belle_sip_source_t *source){
if (source->node.next || source->node.prev){
belle_sip_fatal("Source is already linked somewhere else.");
return;
}
if (source->node.data!=source){
belle_sip_fatal("Insane source passed to belle_sip_main_loop_add_source() !");
return;
}
source->ml=ml;
if (source->timeout>=0){
belle_sip_object_ref(source);
source->expire_ms=belle_sip_time_ms()+source->timeout;
bctbx_mutex_lock(&ml->timer_sources_mutex);
source->it = bctbx_map_insert_and_delete_with_returned_it(ml->timer_sources
, (bctbx_pair_t*)bctbx_pair_ullong_new(source->expire_ms, source));
bctbx_mutex_unlock(&ml->timer_sources_mutex);
}
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++;
}
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;
}
void belle_sip_main_loop_do_later(belle_sip_main_loop_t *ml, belle_sip_callback_t func, void *data){
belle_sip_source_t * s=belle_sip_main_loop_create_timeout(ml,(belle_sip_source_func_t)func,data,0,"defered task");
s->oneshot=TRUE;
belle_sip_object_unref(s);
}
void belle_sip_source_set_timeout(belle_sip_source_t *s, unsigned int value_ms){
if (!s->expired){
belle_sip_main_loop_t *ml = s->ml;
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_mutex_lock(&ml->timer_sources_mutex);
bctbx_map_erase(ml->timer_sources, s->it);
bctbx_iterator_delete(s->it);
s->it = bctbx_map_insert_and_delete_with_returned_it(ml->timer_sources,
(bctbx_pair_t*)bctbx_pair_ullong_new(s->expire_ms, s));
bctbx_mutex_unlock(&ml->timer_sources_mutex);
}
}
s->timeout=value_ms;
}
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 s->timeout;
}
void belle_sip_source_cancel(belle_sip_source_t *s){
s->cancelled=TRUE;
if (s->it) {
bctbx_mutex_lock(&s->ml->timer_sources_mutex);
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->timer_sources_mutex);
}
}
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);
}
static void belle_sip_main_loop_iterate(belle_sip_main_loop_t *ml){
size_t pfd_size = ml->nsources * sizeof(belle_sip_pollfd_t);
belle_sip_pollfd_t *pfd=(belle_sip_pollfd_t*)belle_sip_malloc0(pfd_size);
int i=0;
belle_sip_source_t *s;
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 */
for(elem=ml->fd_sources;elem!=NULL;elem=next) {
next=elem->next;
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;
}
}
}
/*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;
}
/* do the poll */
ret=belle_sip_poll(pfd,i,duration);
if (ret==-1){
goto end;
}
/* Step 2: examine poll results and determine the list of source to be notified */
cur=belle_sip_time_ms();
for(elem=ml->fd_sources;elem!=NULL;elem=elem->next){
unsigned revents=0;
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 */
bctbx_mutex_lock(&ml->timer_sources_mutex); /*iterator chain might be alterated by element insertion*/
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));
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->timer_sources_mutex);
/* Step 4: notify those to be notified */
for(elem=to_be_notified;elem!=NULL;){
s=(belle_sip_source_t*)elem->data;
next=elem->next;
if (!s->cancelled){
if (s->timeout > 0 && 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,revents,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 {
if (s->expired && s->it) {
bctbx_mutex_lock(&ml->timer_sources_mutex);
bctbx_map_erase(ml->timer_sources, s->it);
bctbx_iterator_delete(s->it);
bctbx_mutex_unlock(&ml->timer_sources_mutex);
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;
bctbx_mutex_lock(&ml->timer_sources_mutex);
s->it = bctbx_map_insert_and_delete_with_returned_it(ml->timer_sources,
(bctbx_pair_t*)bctbx_pair_ullong_new(s->expire_ms, s));
bctbx_mutex_unlock(&ml->timer_sources_mutex);
belle_sip_object_ref(s);
}
}
} 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){
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);
}
belle-sip-1.6.3/src/belle_sip_object.c 0000664 0000000 0000000 00000062666 13134375224 0017640 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 .
*/
#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 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);
}
}
static void remove_free_object(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...]",obj->vptr->type_name,obj,obj->ref,content);
belle_sip_free(content);
}
}else belle_sip_warning("No objects leaked.");
}
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);
obj->ref=vptr->initially_unowned ? 0 : 1;
obj->vptr=vptr;
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;
}
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);
}
o->ref++;
return obj;
}
void belle_sip_object_unref(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;
}
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;
}
obj->ref--;
if (obj->ref == 0){
obj->ref = -1;
belle_sip_object_delete(obj);
}
}
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}",obj->vptr->type_name,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_delete(void *ptr){
belle_sip_object_t *obj=BELLE_SIP_OBJECT(ptr);
belle_sip_object_vptr_t *vptr;
belle_sip_object_loose_weak_refs(obj);
remove_free_object(obj);
vptr=obj->vptr;
while(vptr!=NULL){
if (vptr->destroy) vptr->destroy(obj);
vptr=vptr->get_parent();
}
belle_sip_object_data_clear(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(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(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", obj->vptr->type_name);
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(void* _obj) {
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(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_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",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->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(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-1.6.3/src/belle_sip_parameters.c 0000664 0000000 0000000 00000014220 13134375224 0020514 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 .
*/
#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-1.6.3/src/belle_sip_resolver.c 0000664 0000000 0000000 00000125654 13134375224 0020230 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 .
*/
#include "belle_sip_internal.h"
#include "dns.h"
#include
#include
#include
#ifdef __APPLE__
#include "TargetConditionals.h"
#endif
#define DNS_EAGAIN EAGAIN
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 pad;
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*/
};
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){
bctbx_freeaddrinfo(obj->a_results);
obj->a_results=NULL;
}
}
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);
obj->priority=srv->priority;
obj->weight=srv->weight;
obj->port=srv->port;
obj->target=belle_sip_strdup(srv->target);
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_context{
belle_sip_source_t source;
belle_sip_stack_t *stack;
uint32_t min_ttl;
uint8_t notified;
uint8_t cancelled;
uint8_t pad[2];
};
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;
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 USE_GETADDRINFO_FALLBACK
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
};
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;
belle_sip_list_t *srv_results;
belle_sip_resolver_context_t *srv_ctx;
belle_sip_resolver_context_t *a_fallback_ctx;
};
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;
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;
}
/*
* 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)) {
struct addrinfo **ai_list = &ctx->ai_list;
#if USE_GETADDRINFO_FALLBACK
if (ctx->getaddrinfo_ai_list != NULL) ai_list = &ctx->getaddrinfo_ai_list;
#endif
ctx->cb(ctx->cb_data, ctx->name, *ai_list, BELLE_SIP_RESOLVER_CONTEXT(obj)->min_ttl);
*ai_list = NULL;
} else if (ctx->type == DNS_T_SRV) {
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;
results = ai_list_append(results, ctx->a_results);
ctx->a_results = NULL;
ctx->aaaa_results = NULL;
ctx->cb(ctx->cb_data, ctx->name, results, BELLE_SIP_RESOLVER_CONTEXT(obj)->min_ttl);
}
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);
ctx->cb(ctx->cb_data, ctx->name, ctx->final_results, BELLE_SIP_RESOLVER_CONTEXT(obj)->min_ttl);
ctx->final_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);
#ifdef USE_GETADDRINFO_FALLBACK
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);
#ifdef USE_GETADDRINFO_FALLBACK
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 {
#ifdef USE_GETADDRINFO_FALLBACK
if (ctx->getaddrinfo_done) {
return BELLE_SIP_STOP;
} else
#endif
{
belle_sip_message("%s dns_res_check() in progress", __FUNCTION__);
}
}
return BELLE_SIP_CONTINUE;
}
#ifdef USE_GETADDRINFO_FALLBACK
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;
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) {
do {
append_dns_result(ctx, &ctx->getaddrinfo_ai_list, res->ai_addr, (socklen_t)res->ai_addrlen);
res = res->ai_next;
} while (res != 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
belle_sip_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
static int _resolver_send_query(belle_sip_simple_resolver_context_t *ctx) {
int error = 0;
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);
#ifdef 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;
}
static int _resolver_start_query(belle_sip_simple_resolver_context_t *ctx) {
struct dns_options opts;
int error;
struct dns_resolv_conf *conf;
if (!ctx->name) return -1;
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) belle_sip_main_loop_add_source(ctx->base.stack->ml,(belle_sip_source_t*)ctx);
return error;
}
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;
}
}
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. */
#ifdef USE_GETADDRINFO_FALLBACK
if (ctx->getaddrinfo_thread != 0) {
belle_sip_thread_join(ctx->getaddrinfo_thread, NULL);
}
if (ctx->getaddrinfo_source) belle_sip_object_unref(ctx->getaddrinfo_source);
#ifdef _WIN32
if (ctx->ctlevent != (belle_sip_fd_t)-1)
CloseHandle(ctx->ctlevent);
#else
close(ctx->ctlpipe[0]);
close(ctx->ctlpipe[1]);
#endif
#endif
if (ctx->ai_list != NULL) {
bctbx_freeaddrinfo(ctx->ai_list);
ctx->ai_list = NULL;
}
#ifdef USE_GETADDRINFO_FALLBACK
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;
}
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;
}
}
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);
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 process_a_fallback_result(void *data, const char *name, struct addrinfo *ai_list, uint32_t ttl){
belle_sip_combined_resolver_context_t *ctx=(belle_sip_combined_resolver_context_t *)data;
ctx->final_results=ai_list;
belle_sip_resolver_context_notify(BELLE_SIP_RESOLVER_CONTEXT(ctx));
}
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;
unsigned char finished=TRUE;
if (ttl < BELLE_SIP_RESOLVER_CONTEXT(obj)->min_ttl) BELLE_SIP_RESOLVER_CONTEXT(obj)->min_ttl = ttl;
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.");
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->a_results=NULL;
}
belle_sip_list_free_with_data(obj->srv_results,belle_sip_object_unref);
obj->srv_results=NULL;
obj->final_results=final;
belle_sip_resolver_context_notify(BELLE_SIP_RESOLVER_CONTEXT(obj));
}
}
static void process_a_from_srv(void *data, const char *name, struct addrinfo *ai_list, uint32_t ttl){
belle_sip_dns_srv_t *srv=(belle_sip_dns_srv_t*)data;
srv->a_results=ai_list;
srv->a_done=TRUE;
belle_sip_message("A query finished for srv result [%s]",srv->target);
if (ttl < BELLE_SIP_RESOLVER_CONTEXT(srv->root_resolver)->min_ttl) BELLE_SIP_RESOLVER_CONTEXT(srv->root_resolver)->min_ttl = ttl;
combined_resolver_context_check_finished(srv->root_resolver, 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*/
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);
}else{
/*no SRV results, perform A query */
belle_sip_message("No SRV result for [%s], trying A/AAAA.",name);
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);
}
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);
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 resolve to be done */
cb(data, name, res, UINT32_MAX);
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;
ctx->type = (ctx->family == AF_INET6) ? DNS_T_AAAA : DNS_T_A;
#if defined(USE_GETADDRINFO_FALLBACK) && 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 void on_ipv4_results(void *data, const char *name, struct addrinfo *ai_list, uint32_t ttl) {
belle_sip_dual_resolver_context_t *ctx = BELLE_SIP_DUAL_RESOLVER_CONTEXT(data);
ctx->a_results = ai_list;
ctx->a_notified = TRUE;
dual_resolver_context_check_finished(ctx);
}
static void on_ipv6_results(void *data, const char *name, struct addrinfo *ai_list, uint32_t ttl) {
belle_sip_dual_resolver_context_t *ctx = BELLE_SIP_DUAL_RESOLVER_CONTEXT(data);
ctx->aaaa_results = ai_list;
ctx->aaaa_notified = TRUE;
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 resolve to be done */
cb(data, name, res, UINT32_MAX);
}
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;
ctx->name = belle_sip_concat(srv_prefix, name, NULL);
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) {
if (belle_sip_resolver_context_can_be_cancelled(obj)) {
obj->cancelled = TRUE;
BELLE_SIP_OBJECT_VPTR(obj, belle_sip_resolver_context_t)->cancel(obj);
belle_sip_object_unref(obj);
}
}
void belle_sip_resolver_context_notify(belle_sip_resolver_context_t *obj) {
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);
}
}
/*
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-1.6.3/src/belle_sip_uri_impl.c 0000664 0000000 0000000 00000045274 13134375224 0020206 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 .
*/
#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=belle_sip_parameters_get_case_parameter((belle_sip_parameters_t*) uri_a,param); \
b_param=belle_sip_parameters_get_case_parameter((belle_sip_parameters_t*) uri_b,param);\
if (!IS_EQUAL_CASE(a_param,b_param)) 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:
*/
int belle_sip_uri_equals(const belle_sip_uri_t* uri_a,const belle_sip_uri_t* uri_b) {
const belle_sip_list_t * params;
const char* b_param;
const char* a_param;
/*
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_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) {
if ((b_param=belle_sip_parameters_get_parameter((belle_sip_parameters_t*) uri_b,(const char*)params->data)) != NULL) {
if (!IS_EQUAL_CASE(b_param,(const char*)params->data)) 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;
}
/*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 auutomatically 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_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
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-1.6.3/src/belle_sip_utils.c 0000664 0000000 0000000 00000050546 13134375224 0017524 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 .
*/
#define _CRT_RAND_S
#include
#include
#include
#include "belle_sip_internal.h"
#include "bctoolbox/parser.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);
}
#if defined(_WIN32) && !defined(_MSC_VER)
#include
static int belle_sip_wincrypto_random(unsigned int *rand_number){
static HCRYPTPROV hProv=(HCRYPTPROV)-1;
static int initd=0;
if (!initd){
if (!CryptAcquireContext(&hProv,NULL,NULL,PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)){
belle_sip_error("Could not acquire a windows crypto context");
return -1;
}
initd=TRUE;
}
if (hProv==(HCRYPTPROV)-1)
return -1;
if (!CryptGenRandom(hProv,4,(BYTE*)rand_number)){
belle_sip_error("CryptGenRandom() failed.");
return -1;
}
return 0;
}
#endif
unsigned int belle_sip_random(void){
#if defined(__linux) || defined(__APPLE__)
static int fd=-1;
if (fd==-1) fd=open("/dev/urandom",O_RDONLY);
if (fd!=-1){
unsigned int tmp;
if (read(fd,&tmp,4)!=4){
belle_sip_error("Reading /dev/urandom failed.");
}else return tmp;
}else belle_sip_error("Could not open /dev/urandom");
#elif defined(_WIN32)
static int initd=0;
unsigned int ret;
#ifdef _MSC_VER
/*rand_s() is pretty nice and simple function but is not wrapped by mingw.*/
if (rand_s(&ret)==0){
return ret;
}
#else
if (belle_sip_wincrypto_random(&ret)==0){
return ret;
}
#endif
/* Windows's rand() is unsecure but is used as a fallback*/
if (!initd) {
srand((unsigned int)belle_sip_time_ms());
initd=1;
belle_sip_warning("Random generator is using rand(), this is unsecure !");
}
return rand()<<16 | rand();
#endif
/*fallback to UNIX random()*/
#ifndef _WIN32
return (unsigned int) random();
#endif
}
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){
unsigned int val=0;
unsigned int i;
for(i=0;i>6;
}
ret[i]=0;
return ret;
}
/**
* Write random bytes of supplied size.
**/
unsigned char * belle_sip_random_bytes(unsigned char *ret, size_t size){
unsigned int val=0;
unsigned int i;
for(i=0;i>8;
}
return ret;
}
typedef struct bits_reader{
const uint8_t *buffer;
size_t buf_size;
int bit_index;
}bits_reader_t;
static void bits_reader_init(bits_reader_t *reader, const uint8_t *buffer, size_t bufsize){
reader->buffer=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_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) {
char *output_buff=belle_sip_malloc(strlen(buff)+1);
unsigned int i;
unsigned int out_buff_index=0;
for(i=0; buff[i] != '\0'; i++) {
if (buff[i] == '\\') {
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_list_t *belle_sip_parse_directory(const char *path, const char *file_type) {
belle_sip_list_t* file_list = NULL;
#ifdef _WIN32
WIN32_FIND_DATA FileData;
HANDLE hSearch;
BOOL fFinished = FALSE;
char szDirPath[1024];
#ifdef UNICODE
wchar_t wszDirPath[1024];
#endif
if (file_type == NULL) {
file_type = ".*";
}
snprintf(szDirPath, sizeof(szDirPath), "%s\\*%s", path, file_type);
#ifdef UNICODE
mbstowcs(wszDirPath, szDirPath, sizeof(wszDirPath));
hSearch = FindFirstFileExW(wszDirPath, FindExInfoStandard, &FileData, FindExSearchNameMatch, NULL, 0);
#else
hSearch = FindFirstFileExA(szDirPath, FindExInfoStandard, &FileData, FindExSearchNameMatch, NULL, 0);
#endif
if (hSearch == INVALID_HANDLE_VALUE) {
belle_sip_message("No file (*%s) found in [%s] [%d].", file_type, szDirPath, (int)GetLastError());
return NULL;
}
snprintf(szDirPath, sizeof(szDirPath), "%s", path);
while (!fFinished) {
char szFilePath[1024];
#ifdef UNICODE
char filename[512];
wcstombs(filename, FileData.cFileName, sizeof(filename));
snprintf(szFilePath, sizeof(szFilePath), "%s\\%s", szDirPath, filename);
#else
snprintf(szFilePath, sizeof(szFilePath), "%s\\%s", szDirPath, FileData.cFileName);
#endif
file_list = belle_sip_list_append(file_list, belle_sip_strdup(szFilePath));
if (!FindNextFile(hSearch, &FileData)) {
if (GetLastError() == ERROR_NO_MORE_FILES) {
fFinished = TRUE;
}
else {
belle_sip_error("Couldn't find next (*%s) file.", file_type);
fFinished = TRUE;
}
}
}
/* Close the search handle. */
FindClose(hSearch);
#else
DIR *dir;
struct dirent *ent;
if ((dir = opendir(path)) == NULL) {
belle_sip_error("Could't open [%s] directory.", path);
return NULL;
}
/* loop on all directory files */
errno = 0;
ent = readdir(dir);
while (ent != NULL) {
/* filter on file type if given */
if (file_type==NULL
|| (strncmp(ent->d_name+strlen(ent->d_name)-strlen(file_type), file_type, strlen(file_type))==0) ) {
char *name_with_path=belle_sip_strdup_printf("%s/%s",path,ent->d_name);
file_list = belle_sip_list_append(file_list, name_with_path);
}
ent = readdir(dir);
}
if (errno != 0) {
belle_sip_error("Error while reading the [%s] directory: %s.", path, strerror(errno));
}
closedir(dir);
#endif
return file_list;
}
int belle_sip_mkdir(const char *path) {
#ifdef _WIN32
return _mkdir(path);
#else
return mkdir(path, 0700);
#endif
}
belle-sip-1.6.3/src/bodyhandler.c 0000664 0000000 0000000 00000111334 13134375224 0016632 0 ustar 00root root 0000000 0000000 /*
belle-sip - SIP (RFC3261) library.
Copyright (C) 2014 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 .
*/
#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_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){
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_ZLIB_INITIAL_SIZE 2048
void belle_sip_memory_body_handler_apply_encoding(belle_sip_memory_body_handler_t *obj, const char *encoding) {
if ((obj->buffer == NULL) || (obj->encoding_applied == TRUE)) return;
#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) return;
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;
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;
} else
#endif
{
belle_sip_warning("%s: unknown encoding '%s'", __FUNCTION__, encoding);
}
}
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;
}
/*
* 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;
};
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_end_transfer(belle_sip_body_handler_t *base) {
belle_sip_user_body_handler_t *obj = (belle_sip_user_body_handler_t *)base;
if (obj->stop_cb)
obj->stop_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)
obj->recv_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 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_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_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) NULL,
(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;
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;
};
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->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);
}
}
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_end_transfer(belle_sip_body_handler_t *base) {
belle_sip_file_body_handler_t *obj = (belle_sip_file_body_handler_t *)base;
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);
}
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;
}
}
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;
if (obj->file == NULL) return;
if (obj->user_bh && obj->user_bh->recv_cb) {
obj->user_bh->recv_cb((belle_sip_user_body_handler_t*)&(obj->user_bh->base), msg, obj->user_bh->base.user_data, offset, buf, size);
}
ret = bctbx_file_write(obj->file, buf, size, offset);
if (ret == BCTBX_VFS_ERROR) {
bctbx_error("File body handler recv write error at offset %lu", (unsigned long)offset);
}
}
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) {
struct stat statbuf;
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 (stat(obj->filepath, &statbuf) == 0) {
obj->base.expected_size = statbuf.st_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
**/
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){
obj->parts=belle_sip_list_copy_with_data(obj->parts,(void *(*)(void*))belle_sip_object_clone_and_ref);
}
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;
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->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;
offsetSize = strlen(obj_multipart->boundary) + 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 */
memcpy(buffer, "--", 2);
memcpy(buffer + 2, obj_multipart->boundary, boundary_len);
memcpy(buffer + 2 + boundary_len, "\r\n", 2);
offsetSize = boundary_len + 4;
/* 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 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 {
obj->boundary = belle_sip_strdup(BELLESIP_MULTIPART_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(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, belle_sip_multipart_body_handler_progress_cb, 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){
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;
}
void belle_sip_multipart_body_handler_progress_cb(belle_sip_body_handler_t *obj, belle_sip_message_t *msg, void *user_data, size_t transfered, size_t expected_total) {
if (transfered == expected_total) {
/* 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_multipart_body_handler_t *obj_multipart = (belle_sip_multipart_body_handler_t *)obj;
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 *boundary = belle_sip_strdup_printf("--%s", obj_multipart->boundary);
if (strncmp((char *)cursor, boundary, strlen(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(boundary);
return;
}
cursor += strlen(boundary);
do {
if (strncmp((char *)cursor, "\r\n", 2)) {
belle_sip_warning("belle_sip_multipart_body_handler [%p]: no new-line after boundary", obj_multipart);
return;
}
cursor += 2;
end_part_cursor = (uint8_t *)strstr((char *)cursor, boundary);
if (end_part_cursor == NULL) {
belle_sip_warning("belle_sip_multipart_body_handler [%p]: cannot find next boundary", obj_multipart);
return;
} else {
*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(boundary);
}
} while (strcmp((char *)cursor, "--\r\n"));
belle_sip_free(boundary);
}
}
belle-sip-1.6.3/src/channel.c 0000664 0000000 0000000 00000166465 13134375224 0015766 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 .
*/
#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_list) bctbx_freeaddrinfo(obj->peer_list);
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);
}
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*/
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_message_remove_header_from_ptr(msg, ceh);
if (content_type
&& (strcmp(belle_sip_header_content_type_get_type(content_type), "multipart") == 0)) {
const char *unparsed_value = belle_sip_header_get_unparsed_value(BELLE_SIP_HEADER(content_type));
const char *boundary = strstr(unparsed_value, ";boundary=");
if (boundary != NULL) boundary += 10;
if (boundary[0] == '\0') boundary = NULL;
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*/
if ((bh=belle_sip_message_get_body_handler(msg))==NULL){
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 != NULL) {
belle_sip_message_set_body_handler(msg, (bh = (belle_sip_body_handler_t *)belle_sip_memory_body_handler_new(NULL, NULL)));
} else if (content_type
&& (strcmp(belle_sip_header_content_type_get_type(content_type), "multipart") == 0)) {
const char *unparsed_value = belle_sip_header_get_unparsed_value(BELLE_SIP_HEADER(content_type));
const char *boundary = strstr(unparsed_value, ";boundary=");
if (boundary != NULL) boundary += 10;
if (boundary[0] == '\0') boundary = NULL;
belle_sip_message_set_body_handler(msg, (bh = (belle_sip_body_handler_t *)belle_sip_multipart_body_handler_new(belle_sip_multipart_body_handler_progress_cb, NULL, NULL, boundary)));
belle_sip_body_handler_set_size(bh, obj->input_stream.content_length);
} else {
belle_sip_message_set_body_handler(msg,(bh=(belle_sip_body_handler_t*)belle_sip_memory_body_handler_new(NULL,NULL)));
}
}
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(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
* pee_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){
/*to initialize our base class:*/
belle_sip_channel_set_socket(obj,-1,NULL);
/*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->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);
obj->peer_list=obj->current_peer=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 && strcmp(hop->host,obj->peer_name)==0 && (hop->port==obj->peer_port || obj->srv_overrides_port)){
if (hop->cname && obj->peer_cname && strcmp(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*/
/*removing the source (our base class) will decrement the ref count, this why this code needs to be protected by ref/unref.*/
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 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*/
obj->current_peer=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 int 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 ((int)(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",too_long);
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: state %s",obj,belle_sip_channel_state_to_string(state));
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 */
ret=obj->stack->send_error;
} else {
ret=(int)size; /*to silently discard message*/
}
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);
belle_sip_memory_body_handler_apply_encoding(mbh, content_encoding);
} 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);
}
/* 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((msg=channel_pop_outgoing(obj))!=NULL && obj->state==BELLE_SIP_CHANNEL_READY && obj->out_state==OUTPUT_STREAM_IDLE) {
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;
}
static bool_t addrinfo_in_list(const struct addrinfo *ai, const struct addrinfo *list) {
const struct addrinfo *item = list;
bool_t in_list = FALSE;
while (item != NULL) {
if ((ai->ai_family == item->ai_family) && (bctbx_sockaddr_equals(ai->ai_addr, item->ai_addr))) {
in_list = TRUE;
break;
}
item = item->ai_next;
}
return in_list;
}
static void channel_res_done(void *data, const char *name, struct addrinfo *ai_list, uint32_t ttl){
belle_sip_channel_t *obj=(belle_sip_channel_t*)data;
if (obj->resolver_ctx){
belle_sip_object_unref(obj->resolver_ctx);
obj->resolver_ctx=NULL;
}
if (ai_list){
if (!obj->current_peer) {
obj->peer_list=obj->current_peer=ai_list;
channel_set_state(obj,BELLE_SIP_CHANNEL_RES_DONE);
} else {
if (addrinfo_in_list(obj->current_peer, ai_list)) {
belle_sip_message("channel[%p]: DNS resolution returned the currently used address, continue using it", obj);
obj->peer_list = ai_list;
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);
obj->peer_list = obj->current_peer = 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 (!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(obj->dns_ttl_timer, ttl * 1000);
belle_sip_main_loop_add_source(obj->stack->ml, obj->dns_ttl_timer);
}
}else{
belle_sip_error("%s: DNS resolution failed for %s", __FUNCTION__, name);
channel_set_state(obj,BELLE_SIP_CHANNEL_ERROR);
}
}
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->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->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-1.6.3/src/channel.h 0000664 0000000 0000000 00000025646 13134375224 0015766 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 .
*/
#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;
char *peer_name;
int peer_port;
char *local_ip;
int local_port;
char *public_ip;
int public_port;
belle_sip_resolver_context_t* resolver_ctx;
struct addrinfo *peer_list;
struct addrinfo *current_peer;
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 */
int stop_logging_buffer; /*log buffer content only if this is non binary data, and stop it at the first occurence*/
bool_t closed_by_remote; /*If the channel has been remotely closed*/
bool_t dns_ttl_timedout;
};
#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);
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);
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 */
};
#endif
belle-sip-1.6.3/src/clock_gettime.c 0000664 0000000 0000000 00000010722 13134375224 0017147 0 ustar 00root root 0000000 0000000 /*
* 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-1.6.3/src/clock_gettime.h 0000664 0000000 0000000 00000002036 13134375224 0017153 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 .
*/
#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-1.6.3/src/dialog.c 0000664 0000000 0000000 00000133604 13134375224 0015602 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 .
*/
#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_CUSTOM_VPTR_BEGIN(belle_sip_dialog_t)
BELLE_SIP_VPTR_INIT(belle_sip_dialog_t, belle_sip_object_t,TRUE),
(belle_sip_object_destroy_t)belle_sip_dialog_uninit,
NULL,
NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
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);
unsigned int prev_timeout=belle_sip_source_get_timeout(dialog->timer_200Ok);
belle_sip_source_set_timeout(dialog->timer_200Ok,MIN(2*prev_timeout,(unsigned int)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_dialog_stop_200Ok_retrans(dialog);
belle_sip_error("Dialog [%p] was not ACK'd within T1*64 seconds, it is going to be terminated.",dialog);
dialog->state=BELLE_SIP_DIALOG_CONFIRMED;
bye=belle_sip_dialog_create_request(dialog,"BYE");
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));
}
}
}
/*
* 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_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_message("Dialog [%p]: now updated by transaction [%p].",obj, transaction);
if (resp)
code=belle_sip_response_get_status_code(resp);
if (as_uas && code == 491) { /**/
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) belle_sip_object_unref(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*/
if (as_uas) {
belle_sip_header_cseq_t* cseq=belle_sip_message_get_header_by_type(BELLE_SIP_MESSAGE(req),belle_sip_header_cseq_t);
obj->remote_cseq=belle_sip_header_cseq_get_seq_number(cseq);
if (is_invite && code>=200 && code<300)
obj->remote_invite_cseq = belle_sip_header_cseq_get_seq_number(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);
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 || 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;
}
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))) {
return is_retransmition;
} 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 (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 (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);
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);
}
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);
if (strcmp(belle_sip_request_get_method(t->request),"INVITE") == 0){
obj->type = BELLE_SIP_DIALOG_INVITE;
}else if (strcmp(belle_sip_request_get_method(t->request),"SUBSCRIBE") == 0){
obj->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));
}
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_header_cseq_t *cseqh;
belle_sip_request_t *invite=obj->last_out_invite;
belle_sip_request_t *ack;
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);
/*
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;
}
belle_sip_request_t * belle_sip_dialog_create_queued_request(belle_sip_dialog_t *obj, const char *method){
belle_sip_request_t *req;
if (!dialog_can_create_request(obj, method)) return NULL;
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("belle_sip_dialog_create_queued_request([%p]): [%s] requests are forbidden using this method.",obj,method);
return NULL;
}
req=create_request(obj,method,FALSE);
if (req){
req->dialog_queued=TRUE;
}
return req;
}
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++;
}
belle_sip_request_t *belle_sip_dialog_create_request(belle_sip_dialog_t *obj, const char *method){
belle_sip_request_t *req;
if (!dialog_can_create_request(obj, method)) return NULL;
/*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("belle_sip_dialog_create_request(): cannot create [%s] request from dialog [%p] while pending [%s] transaction in state [%s]",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 NULL;
} /*else UPDATE transaction can be send in // */
}
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_header_content_length_t* content_lenth;
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;
content_lenth = belle_sip_message_get_header_by_type(initial_req,belle_sip_header_content_length_t);
/*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*/
if (content_lenth && belle_sip_header_content_length_get_content_length(content_lenth)>0) {
belle_sip_message_set_body(BELLE_SIP_MESSAGE(req),belle_sip_message_get_body(BELLE_SIP_MESSAGE(initial_req)),belle_sip_header_content_length_get_content_length(content_lenth));
}
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
&& strcmp(obj->local_tag,local_tag)==0
&& obj->remote_tag /* handle 180 without to 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){
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){
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)");
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);
}
/* 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_is_authorized_transaction(const belle_sip_dialog_t *dialog,const char* method) {
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)
&& strcmp(last_transaction_request,"SUBSCRIBE")==0 && strcmp(method,"NOTIFY")==0){
/*stupid as it is, you have to accept a NOTIFY for a SUBSCRIBE for which no answer is received yet...*/
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.",dialog);
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-1.6.3/src/dns.c 0000664 0000000 0000000 00000703177 13134375224 0015137 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
#ifdef __ANDROID__
#include
#endif
#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;
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
int dns_resconf_loadfromresolv(struct dns_resolv_conf *resconf) {
struct __res_state res;
union res_sockaddr_union addresses[3];
int i,error;
if ((error = res_ninit(&res))) {
return error;
}
error=res_getservers(&res,addresses,3);
if (error>0){
for (i = 0; inameserver[i],&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->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={0};
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*/
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 ((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-1.6.3/src/dns.h 0000664 0000000 0000000 00000105113 13134375224 0015126 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 /* strlen(3) */
#include /* time_t */
#if _WIN32
#include
#include
#else
#include /* BYTE_ORDER BIG_ENDIAN _BIG_ENDIAN */
#include /* socklen_t */
#include /* struct socket */
#include /* POLLIN POLLOUT */
#include /* struct in_addr struct in6_addr */
#include /* struct addrinfo */
#endif
/*
* V I S I B I L I T Y
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef DNS_PUBLIC
#define DNS_PUBLIC
#endif
/*
* V E R S I O N
*
* Vendor: Entity for which versions numbers are relevant. (If forking
* change DNS_VENDOR to avoid confusion.)
*
* Three versions:
*
* REL Official "release"--bug fixes, new features, etc.
* ABI Changes to existing object sizes or parameter types.
* API Changes that might effect application source.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define DNS_VENDOR "william@25thandClement.com"
#define DNS_V_REL 0x20160608
#define DNS_V_ABI 0x20160608
#define DNS_V_API 0x20160608
DNS_PUBLIC const char *dns_vendor(void);
DNS_PUBLIC int dns_v_rel(void);
DNS_PUBLIC int dns_v_abi(void);
DNS_PUBLIC int dns_v_api(void);
/*
* E R R O R S
*
* Errors and exceptions are always returned through an int. This should
* hopefully make integration easier in the majority of circumstances, and
* also cut down on useless compiler warnings.
*
* System and library errors are returned together. POSIX guarantees that
* all system errors are positive integers. Library errors are always
* negative integers in the range DNS_EBASE to DNS_ELAST, with the high bits
* set to the three magic ASCII characters "dns".
*
* dns_strerror() returns static English string descriptions of all known
* errors, and punts the remainder to strerror(3).
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define DNS_EBASE -(('d' << 24) | ('n' << 16) | ('s' << 8) | 64)
#define dns_error_t int /* for documentation only */
enum dns_errno {
DNS_ENOBUFS = DNS_EBASE,
DNS_EILLEGAL,
DNS_EORDER,
DNS_ESECTION,
DNS_EUNKNOWN,
DNS_EADDRESS,
DNS_ENOQUERY,
DNS_ENOANSWER,
DNS_EFETCHED,
DNS_ESERVICE, /* EAI_SERVICE */
DNS_ENONAME, /* EAI_NONAME */
DNS_EFAIL, /* EAI_FAIL */
DNS_ELAST,
}; /* dns_errno */
DNS_PUBLIC const char *dns_strerror(dns_error_t);
DNS_PUBLIC int *dns_debug_p(void);
#define dns_debug (*dns_debug_p()) /* was extern int dns_debug before 20160523 API */
/*
* C O M P I L E R A N N O T A T I O N S
*
* GCC with -Wextra, and clang by default, complain about overrides in
* initializer lists. Overriding previous member initializers is well
* defined behavior in C. dns.c relies on this behavior to define default,
* overrideable member values when instantiating configuration objects.
*
* dns_quietinit() guards a compound literal expression with pragmas to
* silence these shrill warnings. This alleviates the burden of requiring
* third-party projects to adjust their compiler flags.
*
* NOTE: If you take the address of the compound literal, take the address
* of the transformed expression, otherwise the compound literal lifetime is
* tied to the scope of the GCC statement expression.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#if defined __clang__
#define DNS_PRAGMA_PUSH _Pragma("clang diagnostic push")
#define DNS_PRAGMA_QUIET _Pragma("clang diagnostic ignored \"-Winitializer-overrides\"")
#define DNS_PRAGMA_POP _Pragma("clang diagnostic pop")
#define dns_quietinit(...) \
DNS_PRAGMA_PUSH DNS_PRAGMA_QUIET __VA_ARGS__ DNS_PRAGMA_POP
#elif (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) || __GNUC__ > 4
#define DNS_PRAGMA_PUSH _Pragma("GCC diagnostic push")
#define DNS_PRAGMA_QUIET _Pragma("GCC diagnostic ignored \"-Woverride-init\"")
#define DNS_PRAGMA_POP _Pragma("GCC diagnostic pop")
/* GCC parses the _Pragma operator less elegantly than clang. */
#define dns_quietinit(...) \
__extension__ ({ DNS_PRAGMA_PUSH DNS_PRAGMA_QUIET __VA_ARGS__; DNS_PRAGMA_POP })
#else
#define DNS_PRAGMA_PUSH
#define DNS_PRAGMA_QUIET
#define DNS_PRAGMA_POP
#define dns_quietinit(...) __VA_ARGS__
#endif
#if defined __GNUC__
#define DNS_PRAGMA_EXTENSION __extension__
#else
#define DNS_PRAGMA_EXTENSION
#endif
/*
* E V E N T S I N T E R F A C E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#if defined(POLLIN)
#define DNS_POLLIN POLLIN
#else
#define DNS_POLLIN 1
#endif
#if defined(POLLOUT)
#define DNS_POLLOUT POLLOUT
#else
#define DNS_POLLOUT 2
#endif
/*
* See Application Interface below for configuring libevent bitmasks instead
* of poll(2) bitmasks.
*/
#define DNS_EVREAD 2
#define DNS_EVWRITE 4
#define DNS_POLL2EV(set) \
(((set) & DNS_POLLIN)? DNS_EVREAD : 0) | (((set) & DNS_POLLOUT)? DNS_EVWRITE : 0)
#define DNS_EV2POLL(set) \
(((set) & DNS_EVREAD)? DNS_POLLIN : 0) | (((set) & DNS_EVWRITE)? DNS_POLLOUT : 0)
/*
* E N U M E R A T I O N I N T E R F A C E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
enum dns_section {
DNS_S_QD = 0x01,
#define DNS_S_QUESTION DNS_S_QD
DNS_S_AN = 0x02,
#define DNS_S_ANSWER DNS_S_AN
DNS_S_NS = 0x04,
#define DNS_S_AUTHORITY DNS_S_NS
DNS_S_AR = 0x08,
#define DNS_S_ADDITIONAL DNS_S_AR
DNS_S_ALL = 0x0f
}; /* enum dns_section */
enum dns_class {
DNS_C_IN = 1,
DNS_C_ANY = 255
}; /* enum dns_class */
enum dns_type {
DNS_T_A = 1,
DNS_T_NS = 2,
DNS_T_CNAME = 5,
DNS_T_SOA = 6,
DNS_T_PTR = 12,
DNS_T_MX = 15,
DNS_T_TXT = 16,
DNS_T_AAAA = 28,
DNS_T_SRV = 33,
DNS_T_OPT = 41,
DNS_T_SSHFP = 44,
DNS_T_SPF = 99,
DNS_T_AXFR = 252,
DNS_T_ALL = 255
}; /* enum dns_type */
enum dns_opcode {
DNS_OP_QUERY = 0,
DNS_OP_IQUERY = 1,
DNS_OP_STATUS = 2,
DNS_OP_NOTIFY = 4,
DNS_OP_UPDATE = 5,
}; /* dns_opcode */
enum dns_rcode {
DNS_RC_NOERROR = 0,
DNS_RC_FORMERR = 1,
DNS_RC_SERVFAIL = 2,
DNS_RC_NXDOMAIN = 3,
DNS_RC_NOTIMP = 4,
DNS_RC_REFUSED = 5,
DNS_RC_YXDOMAIN = 6,
DNS_RC_YXRRSET = 7,
DNS_RC_NXRRSET = 8,
DNS_RC_NOTAUTH = 9,
DNS_RC_NOTZONE = 10,
/* EDNS(0) extended RCODEs */
DNS_RC_BADVERS = 16,
}; /* dns_rcode */
/*
* NOTE: These string functions need a small buffer in case the literal
* integer value needs to be printed and returned. UNLESS this buffer is
* SPECIFIED, the returned string has ONLY BLOCK SCOPE.
*/
#define DNS_STRMAXLEN 47 /* "QUESTION|ANSWER|AUTHORITY|ADDITIONAL" */
DNS_PUBLIC const char *dns_strsection(enum dns_section, void *, size_t);
#define dns_strsection3(a, b, c) \
dns_strsection((a), (b), (c))
#define dns_strsection1(a) dns_strsection((a), (char [DNS_STRMAXLEN + 1]){ 0 }, DNS_STRMAXLEN + 1)
#define dns_strsection(...) DNS_PP_CALL(DNS_PP_XPASTE(dns_strsection, DNS_PP_NARG(__VA_ARGS__)), __VA_ARGS__)
DNS_PUBLIC enum dns_section dns_isection(const char *);
DNS_PUBLIC const char *dns_strclass(enum dns_class, void *, size_t);
#define dns_strclass3(a, b, c) dns_strclass((a), (b), (c))
#define dns_strclass1(a) dns_strclass((a), (char [DNS_STRMAXLEN + 1]){ 0 }, DNS_STRMAXLEN + 1)
#define dns_strclass(...) DNS_PP_CALL(DNS_PP_XPASTE(dns_strclass, DNS_PP_NARG(__VA_ARGS__)), __VA_ARGS__)
DNS_PUBLIC enum dns_class dns_iclass(const char *);
DNS_PUBLIC const char *dns_strtype(enum dns_type, void *, size_t);
#define dns_strtype3(a, b, c) dns_strtype((a), (b), (c))
#define dns_strtype1(a) dns_strtype((a), (char [DNS_STRMAXLEN + 1]){ 0 }, DNS_STRMAXLEN + 1)
#define dns_strtype(...) DNS_PP_CALL(DNS_PP_XPASTE(dns_strtype, DNS_PP_NARG(__VA_ARGS__)), __VA_ARGS__)
DNS_PUBLIC enum dns_type dns_itype(const char *);
DNS_PUBLIC const char *dns_stropcode(enum dns_opcode);
DNS_PUBLIC enum dns_opcode dns_iopcode(const char *);
DNS_PUBLIC const char *dns_strrcode(enum dns_rcode);
DNS_PUBLIC enum dns_rcode dns_ircode(const char *);
/*
* A T O M I C I N T E R F A C E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
typedef unsigned long dns_atomic_t;
typedef unsigned long dns_refcount_t; /* must be same value type as dns_atomic_t */
/*
* C R Y P T O I N T E R F A C E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
typedef unsigned dns_random_f(void);
DNS_PUBLIC dns_random_f **dns_random_p(void);
#define dns_random (*dns_random_p()) /* was extern unsigned (*dns_random)(void) before 20160523 API */
/*
* P A C K E T I N T E R F A C E
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct dns_header {
unsigned qid:16;
#if (defined BYTE_ORDER && BYTE_ORDER == BIG_ENDIAN) || (defined __sun && defined _BIG_ENDIAN)
unsigned qr:1;
unsigned opcode:4;
unsigned aa:1;
unsigned tc:1;
unsigned rd:1;
unsigned ra:1;
unsigned unused:3;
unsigned rcode:4;
#else
unsigned rd:1;
unsigned tc:1;
unsigned aa:1;
unsigned opcode:4;
unsigned qr:1;
unsigned rcode:4;
unsigned unused:3;
unsigned ra:1;
#endif
unsigned qdcount:16;
unsigned ancount:16;
unsigned nscount:16;
unsigned arcount:16;
}; /* struct dns_header */
#define dns_header(p) (&(p)->header)
#ifndef DNS_P_QBUFSIZ
#define DNS_P_QBUFSIZ dns_p_calcsize(256 + 4)
#endif
#ifndef DNS_P_DICTSIZE
#define DNS_P_DICTSIZE 16
#endif
struct dns_packet {
unsigned short dict[DNS_P_DICTSIZE];
struct dns_p_memo {
struct dns_s_memo {
unsigned short base, end;
} qd, an, ns, ar;
struct {
unsigned short p;
unsigned short maxudp;
unsigned ttl;
} opt;
} memo;
struct { struct dns_packet *cqe_next, *cqe_prev; } cqe;
size_t size, end;
int:16; /* tcp padding */
DNS_PRAGMA_EXTENSION union {
struct dns_header header;
unsigned char data[1];
};
}; /* struct dns_packet */
#define dns_p_calcsize(n) (offsetof(struct dns_packet, data) + DNS_PP_MAX(12, (n)))
#define dns_p_sizeof(P) dns_p_calcsize((P)->end)
/** takes size of maximum desired payload */
#define dns_p_new(n) (dns_p_init((struct dns_packet *)&(union { unsigned char b[dns_p_calcsize((n))]; struct dns_packet p; }){ { 0 } }, dns_p_calcsize((n))))
/** takes size of entire packet structure as allocated */
DNS_PUBLIC struct dns_packet *dns_p_init(struct dns_packet *, size_t);
/** takes size of maximum desired payload */
DNS_PUBLIC struct dns_packet *dns_p_make(size_t, int *);
DNS_PUBLIC int dns_p_grow(struct dns_packet **);
DNS_PUBLIC struct dns_packet *dns_p_copy(struct dns_packet *, const struct dns_packet *);
#define dns_p_opcode(P) (dns_header(P)->opcode)
DNS_PUBLIC enum dns_rcode dns_p_rcode(struct dns_packet *);
DNS_PUBLIC unsigned dns_p_count(struct dns_packet *, enum dns_section);
DNS_PUBLIC int dns_p_push(struct dns_packet *, enum dns_section, const void *, size_t, enum dns_type, enum dns_class, unsigned, const void *);
DNS_PUBLIC void dns_p_dictadd(struct dns_packet *, unsigned short);
DNS_PUBLIC struct dns_packet *dns_p_merge(struct dns_packet *, enum dns_section, struct dns_packet *, enum dns_section, int *);
DNS_PUBLIC void dns_p_dump(struct dns_packet *, FILE *);
DNS_PUBLIC int dns_p_study(struct dns_packet *);
/*
* D O M A I N N A M E I N T E R F A C E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define DNS_D_MAXLABEL 63 /* + 1 '\0' */
#define DNS_D_MAXNAME 255 /* + 1 '\0' */
#define DNS_D_ANCHOR 1 /* anchor domain w/ root "." */
#define DNS_D_CLEAVE 2 /* cleave sub-domain */
#define DNS_D_TRIM 4 /* remove superfluous dots */
#define dns_d_new3(a, b, f) dns_d_init(&(char[DNS_D_MAXNAME + 1]){ 0 }, DNS_D_MAXNAME + 1, (a), (b), (f))
#define dns_d_new2(a, f) dns_d_new3((a), strlen((a)), (f))
#define dns_d_new1(a) dns_d_new3((a), strlen((a)), DNS_D_ANCHOR)
#define dns_d_new(...) DNS_PP_CALL(DNS_PP_XPASTE(dns_d_new, DNS_PP_NARG(__VA_ARGS__)), __VA_ARGS__)
DNS_PUBLIC char *dns_d_init(void *, size_t, const void *, size_t, int);
DNS_PUBLIC size_t dns_d_anchor(void *, size_t, const void *, size_t);
DNS_PUBLIC size_t dns_d_cleave(void *, size_t, const void *, size_t);
DNS_PUBLIC size_t dns_d_comp(void *, size_t, const void *, size_t, struct dns_packet *, int *);
DNS_PUBLIC size_t dns_d_expand(void *, size_t, unsigned short, struct dns_packet *, int *);
DNS_PUBLIC unsigned short dns_d_skip(unsigned short, struct dns_packet *);
DNS_PUBLIC int dns_d_push(struct dns_packet *, const void *, size_t);
DNS_PUBLIC size_t dns_d_cname(void *, size_t, const void *, size_t, struct dns_packet *, int *error);
/*
* R E S O U R C E R E C O R D I N T E R F A C E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct dns_rr {
enum dns_section section;
struct {
unsigned short p;
unsigned short len;
} dn;
enum dns_type type;
enum dns_class class;
unsigned ttl;
struct {
unsigned short p;
unsigned short len;
} rd;
}; /* struct dns_rr */
DNS_PUBLIC int dns_rr_copy(struct dns_packet *, struct dns_rr *, struct dns_packet *);
DNS_PUBLIC int dns_rr_parse(struct dns_rr *, unsigned short, struct dns_packet *);
DNS_PUBLIC unsigned short dns_rr_skip(unsigned short, struct dns_packet *);
DNS_PUBLIC int dns_rr_cmp(struct dns_rr *, struct dns_packet *, struct dns_rr *, struct dns_packet *);
DNS_PUBLIC size_t dns_rr_print(void *, size_t, struct dns_rr *, struct dns_packet *, int *);
#define dns_rr_i_new(P, ...) \
dns_rr_i_init(&dns_quietinit((struct dns_rr_i){ 0, __VA_ARGS__ }), (P))
struct dns_rr_i {
enum dns_section section;
const void *name;
enum dns_type type;
enum dns_class class;
const void *data;
int follow;
int (*sort)(struct dns_rr *, struct dns_rr *, struct dns_rr_i *, struct dns_packet *);
unsigned args[2];
struct {
unsigned short next;
unsigned short count;
unsigned exec;
unsigned regs[2];
} state, saved;
}; /* struct dns_rr_i */
DNS_PUBLIC int dns_rr_i_packet(struct dns_rr *, struct dns_rr *, struct dns_rr_i *, struct dns_packet *);
DNS_PUBLIC int dns_rr_i_order(struct dns_rr *, struct dns_rr *, struct dns_rr_i *, struct dns_packet *);
DNS_PUBLIC int dns_rr_i_shuffle(struct dns_rr *, struct dns_rr *, struct dns_rr_i *, struct dns_packet *);
DNS_PUBLIC struct dns_rr_i *dns_rr_i_init(struct dns_rr_i *, struct dns_packet *);
#define dns_rr_i_save(i) ((i)->saved = (i)->state)
#define dns_rr_i_rewind(i) ((i)->state = (i)->saved)
#define dns_rr_i_count(i) ((i)->state.count)
DNS_PUBLIC unsigned dns_rr_grep(struct dns_rr *, unsigned, struct dns_rr_i *, struct dns_packet *, int *);
#define dns_rr_foreach(rr, P, ...) \
for (struct dns_rr_i DNS_PP_XPASTE(i, __LINE__) = *dns_rr_i_new((P), __VA_ARGS__); dns_rr_grep((rr), 1, &DNS_PP_XPASTE(i, __LINE__), (P), &(int){ 0 }); )
/*
* A R E S O U R C E R E C O R D
*/
struct dns_a {
struct in_addr addr;
}; /* struct dns_a */
DNS_PUBLIC int dns_a_parse(struct dns_a *, struct dns_rr *, struct dns_packet *);
DNS_PUBLIC int dns_a_push(struct dns_packet *, struct dns_a *);
DNS_PUBLIC int dns_a_cmp(const struct dns_a *, const struct dns_a *);
DNS_PUBLIC size_t dns_a_print(void *, size_t, struct dns_a *);
DNS_PUBLIC size_t dns_a_arpa(void *, size_t, const struct dns_a *);
/*
* AAAA R E S O U R C E R E C O R D
*/
struct dns_aaaa {
struct in6_addr addr;
}; /* struct dns_aaaa */
DNS_PUBLIC int dns_aaaa_parse(struct dns_aaaa *, struct dns_rr *, struct dns_packet *);
DNS_PUBLIC int dns_aaaa_push(struct dns_packet *, struct dns_aaaa *);
DNS_PUBLIC int dns_aaaa_cmp(const struct dns_aaaa *, const struct dns_aaaa *);
DNS_PUBLIC size_t dns_aaaa_print(void *, size_t, struct dns_aaaa *);
DNS_PUBLIC size_t dns_aaaa_arpa(void *, size_t, const struct dns_aaaa *);
/*
* MX R E S O U R C E R E C O R D
*/
struct dns_mx {
unsigned short preference;
char host[DNS_D_MAXNAME + 1];
}; /* struct dns_mx */
DNS_PUBLIC int dns_mx_parse(struct dns_mx *, struct dns_rr *, struct dns_packet *);
DNS_PUBLIC int dns_mx_push(struct dns_packet *, struct dns_mx *);
DNS_PUBLIC int dns_mx_cmp(const struct dns_mx *, const struct dns_mx *);
DNS_PUBLIC size_t dns_mx_print(void *, size_t, struct dns_mx *);
DNS_PUBLIC size_t dns_mx_cname(void *, size_t, struct dns_mx *);
/*
* NS R E S O U R C E R E C O R D
*/
struct dns_ns {
char host[DNS_D_MAXNAME + 1];
}; /* struct dns_ns */
DNS_PUBLIC int dns_ns_parse(struct dns_ns *, struct dns_rr *, struct dns_packet *);
DNS_PUBLIC int dns_ns_push(struct dns_packet *, struct dns_ns *);
DNS_PUBLIC int dns_ns_cmp(const struct dns_ns *, const struct dns_ns *);
DNS_PUBLIC size_t dns_ns_print(void *, size_t, struct dns_ns *);
DNS_PUBLIC size_t dns_ns_cname(void *, size_t, struct dns_ns *);
/*
* CNAME R E S O U R C E R E C O R D
*/
struct dns_cname {
char host[DNS_D_MAXNAME + 1];
}; /* struct dns_cname */
DNS_PUBLIC int dns_cname_parse(struct dns_cname *, struct dns_rr *, struct dns_packet *);
DNS_PUBLIC int dns_cname_push(struct dns_packet *, struct dns_cname *);
DNS_PUBLIC int dns_cname_cmp(const struct dns_cname *, const struct dns_cname *);
DNS_PUBLIC size_t dns_cname_print(void *, size_t, struct dns_cname *);
DNS_PUBLIC size_t dns_cname_cname(void *, size_t, struct dns_cname *);
/*
* SOA R E S O U R C E R E C O R D
*/
struct dns_soa {
char mname[DNS_D_MAXNAME + 1];
char rname[DNS_D_MAXNAME + 1];
unsigned serial, refresh, retry, expire, minimum;
}; /* struct dns_soa */
DNS_PUBLIC int dns_soa_parse(struct dns_soa *, struct dns_rr *, struct dns_packet *);
DNS_PUBLIC int dns_soa_push(struct dns_packet *, struct dns_soa *);
DNS_PUBLIC int dns_soa_cmp(const struct dns_soa *, const struct dns_soa *);
DNS_PUBLIC size_t dns_soa_print(void *, size_t, struct dns_soa *);
/*
* PTR R E S O U R C E R E C O R D
*/
struct dns_ptr {
char host[DNS_D_MAXNAME + 1];
}; /* struct dns_ptr */
DNS_PUBLIC int dns_ptr_parse(struct dns_ptr *, struct dns_rr *, struct dns_packet *);
DNS_PUBLIC int dns_ptr_push(struct dns_packet *, struct dns_ptr *);
DNS_PUBLIC int dns_ptr_cmp(const struct dns_ptr *, const struct dns_ptr *);
DNS_PUBLIC size_t dns_ptr_print(void *, size_t, struct dns_ptr *);
DNS_PUBLIC size_t dns_ptr_cname(void *, size_t, struct dns_ptr *);
DNS_PUBLIC size_t dns_ptr_qname(void *, size_t, int, void *);
/*
* SRV R E S O U R C E R E C O R D
*/
struct dns_srv {
unsigned short priority;
unsigned short weight;
unsigned short port;
char target[DNS_D_MAXNAME + 1];
}; /* struct dns_srv */
DNS_PUBLIC int dns_srv_parse(struct dns_srv *, struct dns_rr *, struct dns_packet *);
DNS_PUBLIC int dns_srv_push(struct dns_packet *, struct dns_srv *);
DNS_PUBLIC int dns_srv_cmp(const struct dns_srv *, const struct dns_srv *);
DNS_PUBLIC size_t dns_srv_print(void *, size_t, struct dns_srv *);
DNS_PUBLIC size_t dns_srv_cname(void *, size_t, struct dns_srv *);
/*
* OPT R E S O U R C E R E C O R D
*/
#ifndef DNS_OPT_MINDATA
#define DNS_OPT_MINDATA 256
#endif
#define DNS_OPT_DNSSEC 0x8000
struct dns_opt {
enum dns_rcode rcode;
unsigned char version;
unsigned short flags;
union {
unsigned short maxsize; /* deprecated as confusing */
unsigned short maxudp; /* maximum UDP payload size */
};
size_t size, len;
unsigned char data[DNS_OPT_MINDATA];
}; /* struct dns_opt */
#define DNS_OPT_INIT(opt) { .size = sizeof (*opt) - offsetof(struct dns_opt, data) }
DNS_PUBLIC struct dns_opt *dns_opt_init(struct dns_opt *, size_t);
DNS_PUBLIC int dns_opt_parse(struct dns_opt *, struct dns_rr *, struct dns_packet *);
DNS_PUBLIC int dns_opt_push(struct dns_packet *, struct dns_opt *);
DNS_PUBLIC int dns_opt_cmp(const struct dns_opt *, const struct dns_opt *);
DNS_PUBLIC size_t dns_opt_print(void *, size_t, struct dns_opt *);
DNS_PUBLIC unsigned int dns_opt_ttl(const struct dns_opt *);
DNS_PUBLIC unsigned short dns_opt_class(const struct dns_opt *);
DNS_PUBLIC dns_error_t dns_opt_data_push(struct dns_opt *, unsigned char, unsigned short, const void *);
/*
* SSHFP R E S O U R C E R E C O R D
*/
struct dns_sshfp {
enum dns_sshfp_key {
DNS_SSHFP_RSA = 1,
DNS_SSHFP_DSA = 2,
} algo;
enum dns_sshfp_digest {
DNS_SSHFP_SHA1 = 1,
} type;
union {
unsigned char sha1[20];
} digest;
}; /* struct dns_sshfp */
DNS_PUBLIC int dns_sshfp_parse(struct dns_sshfp *, struct dns_rr *, struct dns_packet *);
DNS_PUBLIC int dns_sshfp_push(struct dns_packet *, struct dns_sshfp *);
DNS_PUBLIC int dns_sshfp_cmp(const struct dns_sshfp *, const struct dns_sshfp *);
DNS_PUBLIC size_t dns_sshfp_print(void *, size_t, struct dns_sshfp *);
/*
* TXT R E S O U R C E R E C O R D
*/
#ifndef DNS_TXT_MINDATA
#define DNS_TXT_MINDATA 1024
#endif
struct dns_txt {
size_t size, len;
unsigned char data[DNS_TXT_MINDATA];
}; /* struct dns_txt */
DNS_PUBLIC struct dns_txt *dns_txt_init(struct dns_txt *, size_t);
DNS_PUBLIC int dns_txt_parse(struct dns_txt *, struct dns_rr *, struct dns_packet *);
DNS_PUBLIC int dns_txt_push(struct dns_packet *, struct dns_txt *);
DNS_PUBLIC int dns_txt_cmp(const struct dns_txt *, const struct dns_txt *);
DNS_PUBLIC size_t dns_txt_print(void *, size_t, struct dns_txt *);
/*
* ANY R E S O U R C E R E C O R D
*/
union dns_any {
struct dns_a a;
struct dns_aaaa aaaa;
struct dns_mx mx;
struct dns_ns ns;
struct dns_cname cname;
struct dns_soa soa;
struct dns_ptr ptr;
struct dns_srv srv;
struct dns_opt opt;
struct dns_sshfp sshfp;
struct dns_txt txt, spf, rdata;
}; /* union dns_any */
#define DNS_ANY_INIT(any) { .rdata = { .size = sizeof *(any) - offsetof(struct dns_txt, data) } }
DNS_PUBLIC union dns_any *dns_any_init(union dns_any *, size_t);
DNS_PUBLIC int dns_any_parse(union dns_any *, struct dns_rr *, struct dns_packet *);
DNS_PUBLIC int dns_any_push(struct dns_packet *, union dns_any *, enum dns_type);
DNS_PUBLIC int dns_any_cmp(const union dns_any *, enum dns_type, const union dns_any *, enum dns_type);
DNS_PUBLIC size_t dns_any_print(void *, size_t, union dns_any *, enum dns_type);
DNS_PUBLIC size_t dns_any_cname(void *, size_t, union dns_any *, enum dns_type);
/*
* H O S T S I N T E R F A C E
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct dns_hosts;
DNS_PUBLIC struct dns_hosts *dns_hosts_open(int *);
DNS_PUBLIC void dns_hosts_close(struct dns_hosts *);
DNS_PUBLIC dns_refcount_t dns_hosts_acquire(struct dns_hosts *);
DNS_PUBLIC dns_refcount_t dns_hosts_release(struct dns_hosts *);
DNS_PUBLIC struct dns_hosts *dns_hosts_mortal(struct dns_hosts *);
DNS_PUBLIC struct dns_hosts *dns_hosts_local(int *);
DNS_PUBLIC int dns_hosts_loadfile(struct dns_hosts *, FILE *);
DNS_PUBLIC int dns_hosts_loadpath(struct dns_hosts *, const char *);
DNS_PUBLIC int dns_hosts_dump(struct dns_hosts *, FILE *);
DNS_PUBLIC int dns_hosts_insert(struct dns_hosts *, int, const void *, const void *, _Bool);
DNS_PUBLIC struct dns_packet *dns_hosts_query(struct dns_hosts *, struct dns_packet *, int *);
/*
* R E S O L V . C O N F I N T E R F A C E
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct dns_resolv_conf {
struct sockaddr_storage nameserver[3];
char search[4][DNS_D_MAXNAME + 1];
/* (f)ile, (b)ind, (c)ache */
char lookup[4 * (1 + (4 * 2))];
/* getaddrinfo family by preference order ("inet4", "inet6") */
int family[3];
struct {
_Bool edns0;
unsigned ndots;
unsigned timeout;
unsigned attempts;
_Bool rotate;
_Bool recurse;
_Bool smart;
enum {
DNS_RESCONF_TCP_ENABLE,
DNS_RESCONF_TCP_ONLY,
DNS_RESCONF_TCP_DISABLE,
} tcp;
} options;
struct sockaddr_storage iface;
struct { /* PRIVATE */
dns_atomic_t refcount;
} _;
}; /* struct dns_resolv_conf */
DNS_PUBLIC struct dns_resolv_conf *dns_resconf_open(int *);
DNS_PUBLIC void dns_resconf_close(struct dns_resolv_conf *);
DNS_PUBLIC dns_refcount_t dns_resconf_acquire(struct dns_resolv_conf *);
DNS_PUBLIC dns_refcount_t dns_resconf_release(struct dns_resolv_conf *);
DNS_PUBLIC struct dns_resolv_conf *dns_resconf_mortal(struct dns_resolv_conf *);
DNS_PUBLIC struct dns_resolv_conf *dns_resconf_local(int *);
DNS_PUBLIC struct dns_resolv_conf *dns_resconf_root(int *);
DNS_PUBLIC int dns_resconf_pton(struct sockaddr_storage *, const char *);
DNS_PUBLIC int dns_resconf_loadfile(struct dns_resolv_conf *, FILE *);
DNS_PUBLIC int dns_resconf_loadpath(struct dns_resolv_conf *, const char *);
#ifdef USE_FIXED_NAMESERVERS
int dns_resconf_load_fixed_nameservers(struct dns_resolv_conf *resconf);
#endif /* USE_FIXED_NAMESERVERS */
#ifdef USE_STRUCT_RES_STATE_NAMESERVERS
int dns_resconf_load_struct_res_state_nameservers(struct dns_resolv_conf *resconf);
#endif /* USE_STRUCT_RES_STATE_NAMESERVERS */
#ifdef _WIN32
DNS_PUBLIC int dns_resconf_loadwin(struct dns_resolv_conf *);
#endif
#ifdef __ANDROID__
DNS_PUBLIC int dns_resconf_loadandroid(struct dns_resolv_conf *resconf);
#endif
#ifdef HAVE_RESINIT
DNS_PUBLIC int dns_resconf_loadfromresolv(struct dns_resolv_conf *resconf);
#endif /*HAVE_RESINIT*/
DNS_PUBLIC int dns_nssconf_loadfile(struct dns_resolv_conf *, FILE *);
DNS_PUBLIC int dns_nssconf_loadpath(struct dns_resolv_conf *, const char *);
DNS_PUBLIC int dns_resconf_pton(struct sockaddr_storage *ss, const char *src);
DNS_PUBLIC int dns_resconf_dump(struct dns_resolv_conf *, FILE *);
DNS_PUBLIC int dns_nssconf_dump(struct dns_resolv_conf *, FILE *);
DNS_PUBLIC int dns_resconf_setiface(struct dns_resolv_conf *, const char *, unsigned short);
typedef unsigned long dns_resconf_i_t;
DNS_PUBLIC size_t dns_resconf_search(void *, size_t, const void *, size_t, struct dns_resolv_conf *, dns_resconf_i_t *);
/*
* H I N T S E R V E R I N T E R F A C E
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct dns_hints;
DNS_PUBLIC struct dns_hints *dns_hints_open(struct dns_resolv_conf *, int *);
DNS_PUBLIC void dns_hints_close(struct dns_hints *);
DNS_PUBLIC dns_refcount_t dns_hints_acquire(struct dns_hints *);
DNS_PUBLIC dns_refcount_t dns_hints_release(struct dns_hints *);
DNS_PUBLIC struct dns_hints *dns_hints_mortal(struct dns_hints *);
DNS_PUBLIC int dns_hints_insert(struct dns_hints *, const char *, const struct sockaddr *, unsigned);
DNS_PUBLIC unsigned dns_hints_insert_resconf(struct dns_hints *, const char *, const struct dns_resolv_conf *, int *);
DNS_PUBLIC struct dns_hints *dns_hints_local(struct dns_resolv_conf *, int *);
DNS_PUBLIC struct dns_hints *dns_hints_root(struct dns_resolv_conf *, int *);
DNS_PUBLIC struct dns_packet *dns_hints_query(struct dns_hints *, struct dns_packet *, int *);
DNS_PUBLIC int dns_hints_dump(struct dns_hints *, FILE *);
struct dns_hints_i {
const char *zone;
struct {
unsigned next;
unsigned seed;
} state;
}; /* struct dns_hints_i */
#define dns_hints_i_new(...) (&(struct dns_hints_i){ __VA_ARGS__ })
DNS_PUBLIC unsigned dns_hints_grep(struct sockaddr **, socklen_t *, unsigned, struct dns_hints_i *, struct dns_hints *);
/*
* C A C H E I N T E R F A C E
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct dns_cache {
void *state;
dns_refcount_t (*acquire)(struct dns_cache *);
dns_refcount_t (*release)(struct dns_cache *);
struct dns_packet *(*query)(struct dns_packet *, struct dns_cache *, int *);
int (*submit)(struct dns_packet *, struct dns_cache *);
int (*check)(struct dns_cache *);
struct dns_packet *(*fetch)(struct dns_cache *, int *);
int (*pollfd)(struct dns_cache *);
short (*events)(struct dns_cache *);
void (*clear)(struct dns_cache *);
union {
long i;
void *p;
} arg[3];
struct { /* PRIVATE */
dns_atomic_t refcount;
} _;
}; /* struct dns_cache */
DNS_PUBLIC struct dns_cache *dns_cache_init(struct dns_cache *);
DNS_PUBLIC void dns_cache_close(struct dns_cache *);
/*
* A P P L I C A T I O N I N T E R F A C E
*
* Options to change the behavior of the API. Applies across all the
* different components.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define DNS_OPTS_INITIALIZER_ { 0, 0 }, 0
#define DNS_OPTS_INITIALIZER { DNS_OPTS_INITIALIZER_ }
#define DNS_OPTS_INIT(...) { DNS_OPTS_INITIALIZER_, __VA_ARGS__ }
#define dns_opts(...) (&dns_quietinit((struct dns_options)DNS_OPTS_INIT(__VA_ARGS__)))
struct dns_options {
/*
* If the callback closes *fd, it must set it to -1. Otherwise, the
* descriptor is queued and lazily closed at object destruction or
* by an explicit call to _clear(). This allows safe use of
* kqueue(2), epoll(2), et al -style persistent events.
*/
struct {
void *arg;
int (*cb)(int *fd, void *arg);
} closefd;
/* bitmask for _events() routines */
enum dns_events {
DNS_SYSPOLL,
DNS_LIBEVENT,
} events;
int udp_uses_connect;
}; /* struct dns_options */
/*
* S T A T S I N T E R F A C E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct dns_stat {
size_t queries;
struct {
struct {
size_t count, bytes;
} sent, rcvd;
} udp, tcp;
}; /* struct dns_stat */
/*
* S O C K E T I N T E R F A C E
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct dns_socket;
DNS_PUBLIC struct dns_socket *dns_so_open(const struct sockaddr *, int, const struct dns_options *, int *error);
DNS_PUBLIC void dns_so_close(struct dns_socket *);
DNS_PUBLIC void dns_so_reset(struct dns_socket *);
DNS_PUBLIC unsigned short dns_so_mkqid(struct dns_socket *so);
DNS_PUBLIC struct dns_packet *dns_so_query(struct dns_socket *, struct dns_packet *, struct sockaddr *, int *);
DNS_PUBLIC int dns_so_submit(struct dns_socket *, struct dns_packet *, struct sockaddr *);
DNS_PUBLIC int dns_so_check(struct dns_socket *);
DNS_PUBLIC struct dns_packet *dns_so_fetch(struct dns_socket *, int *);
DNS_PUBLIC time_t dns_so_elapsed(struct dns_socket *);
DNS_PUBLIC void dns_so_clear(struct dns_socket *);
DNS_PUBLIC int dns_so_events(struct dns_socket *);
DNS_PUBLIC int dns_so_pollfd(struct dns_socket *);
DNS_PUBLIC int dns_so_poll(struct dns_socket *, int);
DNS_PUBLIC const struct dns_stat *dns_so_stat(struct dns_socket *);
/*
* R E S O L V E R I N T E R F A C E
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct dns_resolver;
DNS_PUBLIC struct dns_resolver *dns_res_open(struct dns_resolv_conf *, struct dns_hosts *hosts, struct dns_hints *, struct dns_cache *, const struct dns_options *, int *);
DNS_PUBLIC struct dns_resolver *dns_res_stub(const struct dns_options *, int *);
DNS_PUBLIC void dns_res_reset(struct dns_resolver *);
DNS_PUBLIC void dns_res_close(struct dns_resolver *);
DNS_PUBLIC dns_refcount_t dns_res_acquire(struct dns_resolver *);
DNS_PUBLIC dns_refcount_t dns_res_release(struct dns_resolver *);
DNS_PUBLIC struct dns_resolver *dns_res_mortal(struct dns_resolver *);
DNS_PUBLIC int dns_res_submit(struct dns_resolver *, const char *, enum dns_type, enum dns_class);
DNS_PUBLIC int dns_res_submit2(struct dns_resolver *, const char *, size_t, enum dns_type, enum dns_class);
DNS_PUBLIC int dns_res_check(struct dns_resolver *);
DNS_PUBLIC struct dns_packet *dns_res_fetch(struct dns_resolver *, int *);
DNS_PUBLIC time_t dns_res_elapsed(struct dns_resolver *);
DNS_PUBLIC void dns_res_clear(struct dns_resolver *);
DNS_PUBLIC int dns_res_events(struct dns_resolver *);
DNS_PUBLIC int dns_res_pollfd(struct dns_resolver *);
DNS_PUBLIC time_t dns_res_timeout(struct dns_resolver *);
DNS_PUBLIC int dns_res_poll(struct dns_resolver *, int);
DNS_PUBLIC struct dns_packet *dns_res_query(struct dns_resolver *, const char *, enum dns_type, enum dns_class, int, int *);
DNS_PUBLIC const struct dns_stat *dns_res_stat(struct dns_resolver *);
DNS_PUBLIC void dns_res_sethints(struct dns_resolver *, struct dns_hints *);
DNS_PUBLIC void dns_res_enable_search(struct dns_resolver *, unsigned char enable);
DNS_PUBLIC int dns_res_was_asymetric(struct dns_resolver *);
/*
* A D D R I N F O I N T E R F A C E
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct dns_addrinfo;
DNS_PUBLIC struct dns_addrinfo *dns_ai_open(const char *, const char *, enum dns_type, const struct addrinfo *, struct dns_resolver *, int *);
DNS_PUBLIC void dns_ai_close(struct dns_addrinfo *);
DNS_PUBLIC int dns_ai_nextent(struct addrinfo **, struct dns_addrinfo *);
DNS_PUBLIC size_t dns_ai_print(void *, size_t, struct addrinfo *, struct dns_addrinfo *);
DNS_PUBLIC time_t dns_ai_elapsed(struct dns_addrinfo *);
DNS_PUBLIC void dns_ai_clear(struct dns_addrinfo *);
DNS_PUBLIC int dns_ai_events(struct dns_addrinfo *);
DNS_PUBLIC int dns_ai_pollfd(struct dns_addrinfo *);
DNS_PUBLIC time_t dns_ai_timeout(struct dns_addrinfo *);
DNS_PUBLIC int dns_ai_poll(struct dns_addrinfo *, int);
DNS_PUBLIC const struct dns_stat *dns_ai_stat(struct dns_addrinfo *);
/*
* U T I L I T Y I N T E R F A C E S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
DNS_PUBLIC size_t dns_strlcpy(char *, const char *, size_t);
DNS_PUBLIC size_t dns_strlcat(char *, const char *, size_t);
/*
* M A C R O M A G I C S
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define DNS_PP_MIN(a, b) (((a) < (b))? (a) : (b))
#define DNS_PP_MAX(a, b) (((a) > (b))? (a) : (b))
#define DNS_PP_NARG_(a, b, c, d, e, f, g, h, i, j, k, N,...) N
#define DNS_PP_NARG(...) DNS_PP_NARG_(__VA_ARGS__, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#define DNS_PP_CALL(F, ...) F(__VA_ARGS__)
#define DNS_PP_PASTE(x, y) x##y
#define DNS_PP_XPASTE(x, y) DNS_PP_PASTE(x, y)
#define DNS_PP_STRINGIFY_(s) #s
#define DNS_PP_STRINGIFY(s) DNS_PP_STRINGIFY_(s)
#define DNS_PP_D1 0
#define DNS_PP_D2 1
#define DNS_PP_D3 2
#define DNS_PP_D4 3
#define DNS_PP_D5 4
#define DNS_PP_D6 5
#define DNS_PP_D7 6
#define DNS_PP_D8 7
#define DNS_PP_D9 8
#define DNS_PP_D10 9
#define DNS_PP_D11 10
#define DNS_PP_DEC(N) DNS_PP_XPASTE(DNS_PP_D, N)
#endif /* DNS_H */
belle-sip-1.6.3/src/generic-uri.c 0000664 0000000 0000000 00000010745 13134375224 0016554 0 ustar 00root root 0000000 0000000 /*
belle-sip - SIP (RFC3261) library.
Copyright (C) 2013 Belledonne Communications SARL, 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, see .
*/
#include "grammars/belle_sip_messageLexer.h"
#include "grammars/belle_sip_messageParser.h"
#include "belle-sip/generic-uri.h"
#include "belle_sip_internal.h"
struct _belle_generic_uri {
belle_sip_object_t object;
char* scheme;
char* user;
char* user_password;
char* host;
int port;
char* path;
char* query;
char* opaque_part;
};
void belle_generic_uri_init(belle_generic_uri_t *uri) {
uri->port=-1;
}
static void belle_generic_uri_destroy(belle_generic_uri_t* uri) {
DESTROY_STRING(uri,scheme)
DESTROY_STRING(uri,user)
DESTROY_STRING(uri,user_password)
DESTROY_STRING(uri,host)
DESTROY_STRING(uri,path)
DESTROY_STRING(uri,query)
DESTROY_STRING(uri,opaque_part)
}
static void belle_generic_uri_clone(belle_generic_uri_t* uri, const belle_generic_uri_t *orig){
CLONE_STRING(belle_generic_uri,scheme,uri,orig)
CLONE_STRING(belle_generic_uri,user,uri,orig)
CLONE_STRING(belle_generic_uri,user_password,uri,orig)
CLONE_STRING(belle_generic_uri,host,uri,orig)
uri->port=orig->port;
CLONE_STRING(belle_generic_uri,path,uri,orig)
CLONE_STRING(belle_generic_uri,query,uri,orig)
CLONE_STRING(belle_generic_uri,opaque_part,uri,orig)
}
belle_sip_error_code belle_generic_uri_marshal(const belle_generic_uri_t* uri, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=BELLE_SIP_OK;
if (uri->scheme) {
error=belle_sip_snprintf(buff,buff_size,offset,"%s:",uri->scheme);
if (error!=BELLE_SIP_OK) return error;
}
if (uri->opaque_part) {
error=belle_sip_snprintf(buff,buff_size,offset,"%s",uri->opaque_part);
if (error!=BELLE_SIP_OK) return error;
} else {
if (uri->host) {
error=belle_sip_snprintf(buff,buff_size,offset,"//");
if (error!=BELLE_SIP_OK) return error;
}
if (uri->user) {
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;
}
if (uri->port>0) {
error=belle_sip_snprintf(buff,buff_size,offset,":%i",uri->port);
if (error!=BELLE_SIP_OK) return error;
}
if (uri->path) {
char* escaped_path=belle_generic_uri_to_escaped_path(uri->path);
error=belle_sip_snprintf(buff,buff_size,offset,"%s",escaped_path);
belle_sip_free(escaped_path);
if (error!=BELLE_SIP_OK) return error;
}
if (uri->query) {
char* escaped_query=belle_generic_uri_to_escaped_query(uri->query);
error=belle_sip_snprintf(buff,buff_size,offset,"?%s",escaped_query);
belle_sip_free(escaped_query);
if (error!=BELLE_SIP_OK) return error;
}
}
return BELLE_SIP_OK;
}
GET_SET_STRING(belle_generic_uri,scheme);
GET_SET_STRING(belle_generic_uri,user);
GET_SET_STRING(belle_generic_uri,user_password);
GET_SET_STRING(belle_generic_uri,host);
GET_SET_STRING(belle_generic_uri,path);
GET_SET_STRING(belle_generic_uri,query);
GET_SET_STRING(belle_generic_uri,opaque_part);
GET_SET_INT(belle_generic_uri,port,int)
BELLE_NEW(belle_generic_uri,belle_sip_object)
BELLE_PARSE(belle_sip_messageParser,belle_,generic_uri)
char* belle_generic_uri_to_string(belle_generic_uri_t* uri) {
return belle_sip_object_to_string(uri);
}
belle-sip-1.6.3/src/grammars/ 0000775 0000000 0000000 00000000000 13134375224 0016001 5 ustar 00root root 0000000 0000000 belle-sip-1.6.3/src/grammars/.gitignore 0000664 0000000 0000000 00000000021 13134375224 0017762 0 ustar 00root root 0000000 0000000 *.c
*.h
*.tokens
belle-sip-1.6.3/src/grammars/Makefile.am 0000775 0000000 0000000 00000002143 13134375224 0020040 0 ustar 00root root 0000000 0000000
noinst_LTLIBRARIES=libbellesip_generated.la
libbellesip_generated_la_CFLAGS=$(LIBBELLESIP_CFLAGS) $(ANTLR_CFLAGS) $(STRICT_OPTIONS) $(STRICT_OPTIONS_CC) $(LESS_STRICT_OPTIONS)
nodist_libbellesip_generated_la_SOURCES= \
belle_sip_messageParser.c belle_sip_messageParser.h \
belle_sip_messageLexer.c belle_sip_messageLexer.h \
belle_sdpParser.c belle_sdpParser.h \
belle_sdpLexer.c belle_sdpLexer.h
$(builddir)/belle_sip_messageParser.c $(builddir)/belle_sip_messageParser.h \
$(builddir)/belle_sip_messageLexer.c $(builddir)/belle_sip_messageLexer.h : belle_sip_message.g
$(ANTLR) -make -Xmultithreaded -Xconversiontimeout 10000 -fo $(builddir) $(srcdir)/belle_sip_message.g
$(builddir)/belle_sdpLexer.c \
$(builddir)/belle_sdpParser.c \
$(builddir)/belle_sdpLexer.h \
$(builddir)/belle_sdpParser.h : $(srcdir)/belle_sdp.g
$(ANTLR) -make -Xmultithreaded -Xconversiontimeout 10000 -fo $(builddir) $<
AM_CPPFLAGS=-I$(top_srcdir)/include -I$(top_srcdir)/src
EXTRA_DIST= belle_sdp.g belle_sip_message.g
CLEANFILES=$(nodist_libbellesip_generated_la_SOURCES) *.tokens
.NOTPARALLEL:
belle-sip-1.6.3/src/grammars/belle_sdp.g 0000664 0000000 0000000 00000060550 13134375224 0020110 0 ustar 00root root 0000000 0000000 /*
belle-sdp - SDP (RFC4566) 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 .
*/
grammar belle_sdp;
options {
language = C;
output=AST;
}
@lexer::header {
/*
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 .
*/
#pragma GCC diagnostic ignored "-Wparentheses"
#pragma GCC diagnostic ignored "-Wunused"
#ifdef __clang__
#pragma GCC diagnostic ignored "-Wtautological-compare"
#endif
#ifndef __clang__
#pragma GCC diagnostic ignored "-Wunused-variable"
#endif
}
@parser::header {
/*
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 .
*/
#pragma GCC diagnostic ignored "-Wparentheses"
#pragma GCC diagnostic ignored "-Wunused"
#ifndef __clang__
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
}
@rulecatch
{
if (HASEXCEPTION())
{
// This is ugly. We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
// catch them.
//PREPORTERROR();
EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
}
}
@includes {
#include "belle-sip/defs.h"
#include "belle-sip/types.h"
#include "belle-sip/belle-sdp.h"
#include "parserutils.h"
}
session_description returns [belle_sdp_session_description_t* ret]
scope { belle_sdp_session_description_t* current; }
@init {$session_description::current = belle_sdp_session_description_new(); $ret=$session_description::current; }
: version CR LF
origin {belle_sdp_session_description_set_origin($session_description::current,$origin.ret);}CR LF
session_name CR LF
(info CR LF)?
(uri_field CR LF)?
(email CR LF)*
phone_field*
(connection {belle_sdp_session_description_set_connection($session_description::current,$connection.ret);} CR LF)?
(bandwidth {belle_sdp_session_description_add_bandwidth($session_description::current,$bandwidth.ret);} CR LF)*
time_field CR LF
(repeat_time CR LF)*
(zone_adjustments CR LF)?
(key_field CR LF)?
(attribute {belle_sdp_session_description_add_attribute($session_description::current,$attribute.ret);} CR LF)*
(media_description {belle_sdp_session_description_add_media_description($session_description::current,$media_description.ret);}) *;
catch [ANTLR3_MISMATCHED_TOKEN_EXCEPTION]
{
ANTLR3_LOG_EXCEPTION();
belle_sip_object_unref($session_description::current);
$ret=NULL;
}
version: {IS_TOKEN(v)}?alpha_num EQUAL v=DIGIT+ {belle_sdp_version_t* version =belle_sdp_version_new();
belle_sdp_version_set_version(version,atoi((const char*)$v.text->chars));
belle_sdp_session_description_set_version($session_description::current,version);};
// ;this memo describes version 0
origin returns [belle_sdp_origin_t* ret]
scope { belle_sdp_origin_t* current; }
@init {$origin::current = belle_sdp_origin_new(); $ret=$origin::current; }
: {IS_TOKEN(o)}?alpha_num EQUAL username {belle_sdp_origin_set_username($origin::current,(const char*)$username.text->chars);}
SPACE sess_id {if ($sess_id.text->chars) belle_sdp_origin_set_session_id($origin::current,strtoul((const char*)$sess_id.text->chars,NULL,10));}
SPACE sess_version {if ($sess_version.text->chars) belle_sdp_origin_set_session_version($origin::current,strtoul((const char*)$sess_version.text->chars,NULL,10));}
SPACE nettype {belle_sdp_origin_set_network_type($origin::current,(const char*)$nettype.text->chars);}
SPACE addrtype {belle_sdp_origin_set_address_type($origin::current,(const char*)$addrtype.text->chars);}
SPACE addr {belle_sdp_origin_set_address($origin::current,(const char*)$addr.text->chars);} ;
catch [ANTLR3_MISMATCHED_TOKEN_EXCEPTION]
{
ANTLR3_LOG_EXCEPTION();
belle_sip_object_unref($origin::current);
$ret=NULL;
}
session_name: {IS_TOKEN(s)}? alpha_num EQUAL text {belle_sdp_session_name_t* session_name =belle_sdp_session_name_new();
belle_sdp_session_name_set_value(session_name,(const char*)$text.text->chars);
belle_sdp_session_description_set_session_name($session_description::current,session_name);};
info returns [belle_sdp_info_t* ret]
scope { belle_sdp_info_t* current; }
@init {$info::current = belle_sdp_info_new(); $ret=$info::current; }
: {IS_TOKEN(i)}? alpha_num EQUAL info_value {belle_sdp_info_set_value($info::current,(const char*) $info_value.text->chars);} ;
info_value options { greedy = false; }: ~(CR|LF)*;
uri_field: {IS_TOKEN(u)}?alpha_num EQUAL uri ;
email returns [belle_sdp_email_t* ret]
scope { belle_sdp_email_t* current; }
@init {$email::current = belle_sdp_email_new(); $ret=$email::current; }
: {IS_TOKEN(e)}?alpha_num EQUAL email_address {belle_sdp_email_set_value($email::current,(const char*)$email_address.text->chars);};
phone_field: {IS_TOKEN(p)}?alpha_num EQUAL phone_number CR LF;
connection returns [belle_sdp_connection_t* ret]
scope { belle_sdp_connection_t* current; }
@init {$connection::current = belle_sdp_connection_new(); $ret=$connection::current; }
: {IS_TOKEN(c)}?alpha_num EQUAL nettype { belle_sdp_connection_set_network_type($connection::current,(const char*)$nettype.text->chars);}
SPACE addrtype{ belle_sdp_connection_set_address_type($connection::current,(const char*)$addrtype.text->chars);}
SPACE connection_address
;
//;a connection field must be present
//;in every media description or at the
//;session-level
catch [ANTLR3_MISMATCHED_TOKEN_EXCEPTION]
{
ANTLR3_LOG_EXCEPTION();
belle_sip_object_unref($ret);
$ret=NULL;
}
bandwidth returns [belle_sdp_bandwidth_t* ret]
scope { belle_sdp_bandwidth_t* current; }
@init {$bandwidth::current = belle_sdp_bandwidth_new(); $ret=$bandwidth::current; }
: {IS_TOKEN(b)}?alpha_num EQUAL bwtype {belle_sdp_bandwidth_set_type($bandwidth::current,(const char*)$bwtype.text->chars); }
COLON bandwidth_value {belle_sdp_bandwidth_set_value($bandwidth::current,atoi((const char*)$bandwidth_value.text->chars));};
catch [ANTLR3_MISMATCHED_TOKEN_EXCEPTION]
{
ANTLR3_LOG_EXCEPTION();
belle_sip_object_unref($ret);
$ret=NULL;
}
time_field: {IS_TOKEN(t)}?alpha_num EQUAL
start_time
SPACE
stop_time {belle_sdp_time_description_t* time_description =belle_sdp_time_description_new();
belle_sdp_time_t* time_value =belle_sdp_time_new();
belle_sip_list_t* time_description_list;
belle_sdp_time_set_start(time_value,atoi((const char*)$start_time.text->chars));
belle_sdp_time_set_stop(time_value,atoi((const char*)$stop_time.text->chars));
belle_sdp_time_description_set_time(time_description,time_value);
time_description_list = belle_sip_list_append(NULL,time_description);
belle_sdp_session_description_set_time_descriptions($session_description::current,time_description_list);};
repeat_time: {IS_TOKEN(r)}?alpha_num EQUAL repeat_interval (SPACE typed_time)+;
zone_adjustments: {IS_TOKEN(z)}? alpha_num EQUAL sdp_time SPACE '-'? typed_time
(SPACE sdp_time SPACE '-'? typed_time)*;
key_field: {IS_TOKEN(k)}?alpha_num EQUAL key_value ;
key_value options { greedy = false; }: (~(CR|LF))*;
//key_type: {IS_TOKEN(prompt)}? alpha_num* /*'prompt'*/ |
// {IS_TOKEN(clear)}? alpha_num* /*'clear'*/ COLON key_data |
// {IS_TOKEN(base64)}? alpha_num* /*'base64*/ COLON key_data |
// {IS_TOKEN(base64)}? alpha_num* /*'uri*/ COLON uri;
//
//key_data: email_safe;
attribute returns [belle_sdp_attribute_t* ret]
scope {int has_value;}
@init {$ret=NULL;}
: {IS_TOKEN(a)}?alpha_num EQUAL attribute_content{$ret=$attribute_content.ret;};
catch [ANTLR3_MISMATCHED_TOKEN_EXCEPTION]
{
ANTLR3_LOG_EXCEPTION();
if ($ret) belle_sip_object_unref($ret);
$ret=NULL;
}
attribute_content returns [belle_sdp_attribute_t* ret]
@init {$ret=NULL; }
: attribute_name (COLON val=attribute_value {$ret=belle_sdp_attribute_create((const char*)$attribute_name.text->chars,(const char*)$attribute_value.text->chars);})?
{
if (!val.tree) $ret=belle_sdp_attribute_create((const char*)$attribute_name.text->chars,NULL);
};
rtcp_xr_attribute returns [belle_sdp_rtcp_xr_attribute_t* ret]
scope { belle_sdp_rtcp_xr_attribute_t* current; }
@init { $rtcp_xr_attribute::current = belle_sdp_rtcp_xr_attribute_new();$ret = $rtcp_xr_attribute::current;}
: {IS_TOKEN(a)}?alpha_num EQUAL {IS_TOKEN(rtcp-xr)}? attribute_name /*'rtcp-xr'*/ (COLON rtcp_xr_attribute_value (SPACE rtcp_xr_attribute_value)*)?;
catch [ANTLR3_MISMATCHED_TOKEN_EXCEPTION]
{
ANTLR3_LOG_EXCEPTION();
belle_sip_object_unref($ret);
$ret=NULL;
}
rtcp_xr_attribute_value :
(pkt_loss_rle)=> pkt_loss_rle
| (pkt_dup_rle)=> pkt_dup_rle
| (pkt_rcpt_times)=> pkt_rcpt_times
| (rcvr_rtt)=> rcvr_rtt
| (stat_summary)=> stat_summary
| (voip_metrics)=> voip_metrics;
pkt_loss_rle :
{IS_TOKEN(pkt-loss-rle)}? rtcp_xr_attribute_name /*'pkt-loss-rle'*/ (EQUAL rtcp_xr_max_size)? ;
pkt_dup_rle :
{IS_TOKEN(pkt-dup-rle)}? rtcp_xr_attribute_name /*'pkt-dup-rle'*/ (EQUAL rtcp_xr_max_size)? ;
pkt_rcpt_times :
{IS_TOKEN(pkt-rcpt-times)}? rtcp_xr_attribute_name /*'pkt-rcpt-times'*/ (EQUAL rtcp_xr_max_size)? ;
rcvr_rtt :
{IS_TOKEN(rcvr-rtt)}? rtcp_xr_attribute_name /*'rcvr-rtt'*/ EQUAL {IS_TOKEN(all) || IS_TOKEN(sender)}? rtcp_xr_rcvr_rtt_mode (COLON val=rtcp_xr_max_size)? {
belle_sdp_rtcp_xr_attribute_set_rcvr_rtt_mode($rtcp_xr_attribute::current,(const char*)$rtcp_xr_rcvr_rtt_mode.text->chars);
if (val.tree) belle_sdp_rtcp_xr_attribute_set_rcvr_rtt_max_size($rtcp_xr_attribute::current,atoi((const char*)$rtcp_xr_max_size.text->chars));
};
stat_summary :
{IS_TOKEN(stat-summary)}? rtcp_xr_attribute_name /*'stat-summary'*/ {
belle_sdp_rtcp_xr_attribute_set_stat_summary($rtcp_xr_attribute::current,1);
} (EQUAL rtcp_xr_stat_summary_flag (COMMA rtcp_xr_stat_summary_flag)*)?;
voip_metrics :
{IS_TOKEN(voip-metrics)}? rtcp_xr_attribute_name /*'voip-metrics'*/ {
belle_sdp_rtcp_xr_attribute_set_voip_metrics($rtcp_xr_attribute::current,1);
};
rtcp_xr_stat_summary_flag :
{IS_TOKEN(loss) || IS_TOKEN(dup) || IS_TOKEN(jitt) || IS_TOKEN(TTL) || IS_TOKEN(HL)}?rtcp_xr_stat_summary_flag_value {
belle_sdp_rtcp_xr_attribute_add_stat_summary_flag($rtcp_xr_attribute::current,(const char*)$rtcp_xr_stat_summary_flag_value.text->chars);
};
rtcp_xr_max_size : DIGIT+;
rtcp_fb_attribute returns [belle_sdp_rtcp_fb_attribute_t* ret]
scope { belle_sdp_rtcp_fb_attribute_t* current; }
@init { $rtcp_fb_attribute::current = belle_sdp_rtcp_fb_attribute_new();$ret = $rtcp_fb_attribute::current;}
: {IS_TOKEN(a)}?alpha_num EQUAL {IS_TOKEN(rtcp-fb)}? attribute_name /*'rtcp-fb'*/ COLON rtcp_fb_pt SPACE rtcp_fb_val;
catch [ANTLR3_MISMATCHED_TOKEN_EXCEPTION]
{
ANTLR3_LOG_EXCEPTION();
belle_sip_object_unref($ret);
$ret=NULL;
}
rtcp_fb_pt: STAR {
belle_sdp_rtcp_fb_attribute_set_id($rtcp_fb_attribute::current,-1);
} | integer {
belle_sdp_rtcp_fb_attribute_set_id($rtcp_fb_attribute::current,atoi((const char*)$integer.text->chars));
};
rtcp_fb_val :
(rtcp_fb_ack_val)=>rtcp_fb_ack_val
| (rtcp_fb_nack_val)=>rtcp_fb_nack_val
| (rtcp_fb_trr_int_val)=>rtcp_fb_trr_int_val
| (rtcp_fb_ccm_val)=>rtcp_fb_ccm_val
| (rtcp_fb_id_val)=>rtcp_fb_id_val;
rtcp_fb_ack_val:
{IS_TOKEN(ack)}? rtcp_fb_attribute_name /*'ack'*/ (SPACE rtcp_fb_ack_param)? {
belle_sdp_rtcp_fb_attribute_set_type($rtcp_fb_attribute::current,BELLE_SDP_RTCP_FB_ACK);
};
rtcp_fb_nack_val:
{IS_TOKEN(nack)}? rtcp_fb_attribute_name /*'nack'*/ (SPACE rtcp_fb_nack_param)? {
belle_sdp_rtcp_fb_attribute_set_type($rtcp_fb_attribute::current,BELLE_SDP_RTCP_FB_NACK);
};
rtcp_fb_trr_int_val:
{IS_TOKEN(trr-int)}? rtcp_fb_attribute_name /*'trr-int'*/ SPACE integer {
belle_sdp_rtcp_fb_attribute_set_type($rtcp_fb_attribute::current,BELLE_SDP_RTCP_FB_TRR_INT);
belle_sdp_rtcp_fb_attribute_set_trr_int($rtcp_fb_attribute::current,(uint16_t)atoi((const char*)$integer.text->chars));
};
rtcp_fb_ccm_val:
{IS_TOKEN(ccm)}? rtcp_fb_attribute_name /*'ccm'*/ (SPACE rtcp_fb_ccm_param)? { /* TODO: rtcp_fb_ccm_param should be mandatory */
belle_sdp_rtcp_fb_attribute_set_type($rtcp_fb_attribute::current,BELLE_SDP_RTCP_FB_CCM);
};
rtcp_fb_id_val:
rtcp_fb_attribute_name (SPACE rtcp_fb_param)?;
rtcp_fb_param:
(rtcp_fb_app_param)=>rtcp_fb_app_param
| (rtcp_fb_token_param)=>rtcp_fb_token_param;
rtcp_fb_ack_param:
(rtcp_fb_rpsi_param)=>rtcp_fb_rpsi_param
| (rtcp_fb_app_param)=>rtcp_fb_app_param
| (rtcp_fb_token_param)=>rtcp_fb_token_param;
rtcp_fb_nack_param:
(rtcp_fb_pli_param)=>rtcp_fb_pli_param
| (rtcp_fb_sli_param)=>rtcp_fb_sli_param
| (rtcp_fb_rpsi_param)=>rtcp_fb_rpsi_param
| (rtcp_fb_app_param)=>rtcp_fb_app_param
| (rtcp_fb_token_param)=>rtcp_fb_token_param;
rtcp_fb_pli_param:
{IS_TOKEN(pli)}? rtcp_fb_attribute_name /*'pli'*/ {
belle_sdp_rtcp_fb_attribute_set_param($rtcp_fb_attribute::current,BELLE_SDP_RTCP_FB_PLI);
};
rtcp_fb_sli_param:
{IS_TOKEN(sli)}? rtcp_fb_attribute_name /*'sli'*/ {
belle_sdp_rtcp_fb_attribute_set_param($rtcp_fb_attribute::current,BELLE_SDP_RTCP_FB_SLI);
};
rtcp_fb_rpsi_param:
{IS_TOKEN(rpsi)}? rtcp_fb_attribute_name /*'rpsi'*/ {
belle_sdp_rtcp_fb_attribute_set_param($rtcp_fb_attribute::current,BELLE_SDP_RTCP_FB_RPSI);
};
rtcp_fb_app_param:
{IS_TOKEN(app)}? rtcp_fb_attribute_name /*'app'*/ (SPACE byte_string) {
belle_sdp_rtcp_fb_attribute_set_param($rtcp_fb_attribute::current,BELLE_SDP_RTCP_FB_APP);
};
rtcp_fb_ccm_param:
(rtcp_fb_fir_param)=>rtcp_fb_fir_param
| (rtcp_fb_tmmbr_param)=>rtcp_fb_tmmbr_param
| (rtcp_fb_token_param)=>rtcp_fb_token_param;
rtcp_fb_fir_param:
{IS_TOKEN(fir)}? rtcp_fb_attribute_name /*'fir'*/ {
belle_sdp_rtcp_fb_attribute_set_param($rtcp_fb_attribute::current,BELLE_SDP_RTCP_FB_FIR);
};
rtcp_fb_tmmbr_param:
{IS_TOKEN(tmmbr)}? rtcp_fb_attribute_name /*'tmmbr'*/ (SPACE rtcp_fb_tmmbr_smaxpr_param)? {
belle_sdp_rtcp_fb_attribute_set_param($rtcp_fb_attribute::current,BELLE_SDP_RTCP_FB_TMMBR);
};
rtcp_fb_tmmbr_smaxpr_param:
{IS_TOKEN(smaxpr)}? rtcp_fb_attribute_name /*'smaxpr'*/ EQUAL val=rtcp_fb_tmmbr_smaxpr {
if (val.tree) belle_sdp_rtcp_fb_attribute_set_smaxpr($rtcp_fb_attribute::current,atoi((const char*)$rtcp_fb_tmmbr_smaxpr.text->chars));
};
rtcp_fb_tmmbr_smaxpr : DIGIT+;
rtcp_fb_token_param:
rtcp_fb_attribute_name (SPACE byte_string)?;
media_description returns [belle_sdp_media_description_t* ret]
scope { belle_sdp_media_description_t* current; }
@init {$media_description::current = belle_sdp_media_description_new(); $ret=$media_description::current; }
: media CR LF {belle_sdp_media_description_set_media($media_description::current,$media.ret);}
(info {belle_sdp_media_description_set_info($media_description::current,$info.ret);} CR LF)?
(connection { belle_sdp_media_description_set_connection($media_description::current,$connection.ret);} CR LF)?
(bandwidth {belle_sdp_media_description_add_bandwidth($media_description::current,$bandwidth.ret);} CR LF)*
(key_field CR LF)?
(attribute {if ($attribute.ret)belle_sdp_media_description_add_attribute($media_description::current,$attribute.ret);} CR LF)*;
catch [ANTLR3_MISMATCHED_TOKEN_EXCEPTION]
{
ANTLR3_LOG_EXCEPTION();
belle_sip_object_unref($ret);
$ret=NULL;
}
media returns [belle_sdp_media_t* ret]
scope { belle_sdp_media_t* current; }
@init {$media::current = belle_sdp_media_new(); $ret=$media::current; }
: {IS_TOKEN(m)}?alpha_num EQUAL
media_value {belle_sdp_media_set_media_type($media::current,(const char*)$media_value.text->chars);}
SPACE port {belle_sdp_media_set_media_port($media::current,atoi((const char*)$port.text->chars));}
(SLASH integer{belle_sdp_media_set_port_count($media::current,atoi((const char*)$integer.text->chars));})?
SPACE proto {belle_sdp_media_set_protocol($media::current,(const char*)$proto.text->chars);}
(SPACE fmt)+;
catch [ANTLR3_MISMATCHED_TOKEN_EXCEPTION]
{
ANTLR3_LOG_EXCEPTION();
belle_sip_object_unref($ret);
$ret=NULL;
}
media_value: alpha_num+;
// ;typically "audio", "video", "application"
// ;or "data"
fmt
scope { int is_number; }
@init { $fmt::is_number=0;}: ((DIGIT+)=>(DIGIT+){$fmt::is_number=1;} | token )
{belle_sdp_media_set_media_formats($media::current
,belle_sip_list_append(belle_sdp_media_get_media_formats($media::current)
,(void*)($fmt::is_number?(void*)(intptr_t)atoi((const char*)$fmt.text->chars):$fmt.text->chars)));};
//;typically an RTP payload type for audio
//;and video media
proto options { greedy = false; }: ~(SPACE|CR|LF)*;
//;typically "RTP/AVP" or "udp" for IP4
port: DIGIT+;
// ;should in the range "1024" to "65535" inclusive
// ;for UDP based media
attribute_name: token;
attribute_value options { greedy = false; }: ~(CR|LF)*;
rtcp_xr_attribute_name: word;
rtcp_xr_rcvr_rtt_mode: word;
rtcp_xr_stat_summary_flag_value: word;
rtcp_fb_attribute_name: word;
sess_id: DIGIT+;
// ;should be unique for this originating username/host
sess_version: DIGIT+;
//;0 is a new session
connection_address:
/*multicast_address
|*/addr {belle_sdp_connection_set_address($connection::current,(const char*)$addr.text->chars);} multicast_part?;
multicast_address: unicast_address '/' ttl;
// (decimal_uchar DOT decimal_uchar DOT decimal_uchar DOT) decimal_uchar '/' ttl ( '/' integer )?;
//;multicast addresses may be in the range
//;224.0.0.0 to 239.255.255.255
ttl: decimal_uchar;
start_time: DIGIT+ ;
stop_time: DIGIT+ ;
sdp_time: DIGIT+;
// ;sufficient for 2 more centuries
repeat_interval: typed_time;
typed_time: DIGIT* fixed_len_time_unit?;
fixed_len_time_unit: {IS_TOKEN(d)}? alpha_num
| {IS_TOKEN(h)}? alpha_num
| {IS_TOKEN(m)}? alpha_num
| {IS_TOKEN(s)}? alpha_num;
bwtype: alpha_num+;
bandwidth_value: DIGIT+;
username: email_safe;
//;pretty wide definition, but doesn't include SPACE
email_address options { greedy = false; }: ~(CR|LF)* ; //| email '(' email_safe ')' |
//email_safe '<' email '>';
uri: text ;//defined in RFC1630
phone_number: phone;/*(phone '(') => (phone '(') email_safe ')'
| (phone) => phone
| email_safe LQUOTE phone RQUOTE;*/
phone: text;//'+' DIGIT*POS_DIGIT (SPACE | '-' | DIGIT)*;
//;there must be a SPACE or hyphen between the
//;international code and the rest of the number.
nettype: alpha_num+;//'IN';
// ;list to be extended
addrtype: alpha_num+ ; //'IP4' | 'IP6';
//;list to be extended
addr: unicast_address ;
multicast_part: (SLASH num+=integer {
if (strcmp( belle_sdp_connection_get_address_type($connection::current),"IP6")==0)
belle_sdp_connection_set_range($connection::current,atoi((const char*)$integer.text->chars));
else if ($num->count ==1)
belle_sdp_connection_set_ttl($connection::current,atoi((const char*)$integer.text->chars));
else if ($num->count ==2)
belle_sdp_connection_set_range($connection::current,atoi((const char*)$integer.text->chars));
})+;
fqdn : ( domainlabel DOT )* toplabel DOT? ;
domainlabel : alpha_num | (alpha_num ( alpha_num | DASH )* alpha_num) ;
toplabel : alpha | (alpha ( alpha_num | DASH )* alpha_num) ;
unicast_address : (alpha_num | DOT | COLON| DASH)*; /*might be better defined*/
/* ipv4_address
|ipv6_address
|fqdn*/
ipv4_address : decimal_uchar DOT decimal_uchar DOT decimal_uchar DOT decimal_uchar ;
ipv6_address : (hexpart)=>hexpart ( COLON ipv4_address )? ;
hexpart : hexseq | hexseq COLON COLON hexseq? | COLON COLON hexseq? ;
hexseq : hex4 ( COLON hex4)* ;
hex4 : hexdigit+; /* hexdigit hexdigit hexdigit ;*/
text : ~(CR|LF)* ;
//default is to interpret this as IS0-10646 UTF8
//ISO 8859-1 requires a "a=charset:ISO-8859-1"
//session-level attribute to be used
byte_string options { greedy = false; }: (OCTET)* ;
//any byte except NUL, CR or LF
decimal_uchar: integer;// (d+=DIGIT+ {$d !=NULL && $d->count<=3}?)
integer: DIGIT+;
email_safe : ~(SPACE)*;
token : (alpha_num | '!' | '#' | '$' |'&'| '%'| '\'' | '*' |'+' | DASH | DOT | '^' | '_' | '`' | '{' | '|' | '}' | '~')+;
alpha_num: (alpha | DIGIT) ;
hexdigit: (HEX_CHAR | DIGIT) ;
word: (alpha | DASH)+;
alpha: COMMON_CHAR | HEX_CHAR;
DIGIT: ZERO | POS_DIGIT;
fragment ZERO: '0';
fragment POS_DIGIT : '1'..'9';
//ALPHA: 'a'..'z'|'A'..'Z';
COMMON_CHAR
: 'g'..'z' | 'G'..'Z' ;
HEX_CHAR: 'a'..'f' |'A'..'F';
SPACE: ' ';
//CRLF : CR LF { USER1 = (int)(ctx->pLexer->input->currentLine - ctx->pLexer->input->data);};
LQUOTE: '<';
RQUOTE: '>';
CR:'\r';
LF:'\n';
DOT: '.';
EQUAL: '=';
COLON: ':';
SLASH: '/';
DASH: '-';
COMMA: ',';
STAR: '*';
OCTET : .;
belle-sip-1.6.3/src/grammars/belle_sip_message.g 0000664 0000000 0000000 00000244013 13134375224 0021617 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 .
*/
grammar belle_sip_message;
options {
language = C;
}
@parser::header {
/*
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 .
*/
#pragma GCC diagnostic ignored "-Wparentheses"
#pragma GCC diagnostic ignored "-Wunused"
#ifndef __clang__
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
}
@lexer::header {
/*
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 .
*/
#pragma GCC diagnostic ignored "-Wparentheses"
#pragma GCC diagnostic ignored "-Wunused"
}
@includes {
#include "belle-sip/defs.h"
#include "belle-sip/types.h"
#include "belle-sip/message.h"
#include "belle-sip/http-message.h"
#include "parserutils.h"
BELLESIP_EXPORT void belle_sip_header_address_set_quoted_displayname(belle_sip_header_address_t* address,const char* value);
}
@rulecatch
{
if (HASEXCEPTION())
{
// This is ugly. We set the exception type to ANTLR3_RECOGNITION_EXCEPTION so we can always
// catch them.
//PREPORTERROR();
EXCEPTION->type = ANTLR3_RECOGNITION_EXCEPTION;
}
}
message returns [belle_sip_message_t* ret]
scope { size_t message_length; }
@init {$ret=NULL;}
: message_raw[&($message::message_length)] {$ret=$message_raw.ret;};
message_raw [size_t* length] returns [belle_sip_message_t* ret]
scope { size_t* message_length; }
@init {$message_raw::message_length=length;$ret=NULL;}
: common_request {$ret = $common_request.ret;}
| common_response {$ret = $common_response.ret;} ;
request returns [belle_sip_request_t* ret=NULL]
:common_request {$ret=BELLE_SIP_REQUEST($common_request.ret);};
common_request returns [belle_sip_message_t* ret]
scope { belle_sip_message_t* current; }
@init {$ret=$common_request::current=NULL; }
: ( ( ~(CRLF)* sip_version CRLF) => request_line {$ret=$common_request::current=BELLE_SIP_MESSAGE($request_line.ret);}
| ( ~(CRLF)* http_version CRLF) => http_request_line{$ret=$common_request::current=BELLE_SIP_MESSAGE($http_request_line.ret);})
message_header[BELLE_SIP_MESSAGE($common_request::current)]+ last_crlf=CRLF {*($message_raw::message_length)=$last_crlf->user1;} /*message_body ?*/ ;
request_line returns [belle_sip_request_t* ret=NULL]
scope { belle_sip_request_t* current; }
@init {$request_line::current = belle_sip_request_new(); $ret=$request_line::current; }
: method {belle_sip_request_set_method($request_line::current,(const char*)($method.text->chars));}
SP
( uri {belle_sip_request_set_uri($request_line::current,$uri.ret);}
|
generic_uri {belle_sip_request_set_absolute_uri($request_line::current,$generic_uri.ret);}
)
SP
sip_version
CRLF ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($request_line::current);
$ret=NULL;
}
sip_version
: {IS_TOKEN(SIP/)}? generic_version; // 'SIP/' DIGIT '.' DIGIT;
generic_version: alpha+ SLASH DIGIT DOT DIGIT;
message_header [belle_sip_message_t* message]
: (/*accept
// | accept_encoding
// | accept_language
// | alert_info
// | allow
// | authentication_info
// | authorization
// | header_call_id {belle_sip_message_add_header(message,BELLE_SIP_HEADER($header_call_id.ret));}/*
// | call_info
// | header_contact {belle_sip_message_add_header(message,BELLE_SIP_HEADER($header_contact.ret));}
// | content_disposition
// | content_encoding
// | content_language*/
// | header_content_length {belle_sip_message_add_header(message,BELLE_SIP_HEADER($header_content_length.ret));}
// | header_content_type {belle_sip_message_add_header(message,BELLE_SIP_HEADER($header_content_type.ret));}
// | header_cseq {belle_sip_message_add_header(message,BELLE_SIP_HEADER($header_cseq.ret));}/*
// | date
// | error_info
// | expires*/
// | header_from {belle_sip_message_add_header(message,BELLE_SIP_HEADER($header_from.ret));}/*
// | in_reply_to
// | max_forwards
// | mime_version
// | min_expires
// | organization
// | priority
// | proxy_authenticate
// | proxy_authorization
// | proxy_require*/
// | header_record_route {belle_sip_message_add_header(message,BELLE_SIP_HEADER($header_record_route.ret));}/*
// | reply_to
// | require
// | retry_after*/
// | header_route {belle_sip_message_add_header(message,BELLE_SIP_HEADER($header_route.ret));}/*
// | server
// | subject
// | supported
// | timestamp*/
// | header_to {belle_sip_message_add_header(message,BELLE_SIP_HEADER($header_to.ret));}/*
// | header_diversion {belle_sip_message_add_header(message,BELLE_SIP_HEADER($header_diversion.ret));}/*
// | unsupported
// | user_agent*/
// | header_via {belle_sip_message_add_header(message,BELLE_SIP_HEADER($header_via.ret));}/*
// | warning
// | www_authenticate*/
header_extension_base[(BELLE_SIP_OBJECT_IS_INSTANCE_OF($message,belle_http_request_t) ||BELLE_SIP_OBJECT_IS_INSTANCE_OF($message,belle_http_response_t)) ] {
belle_sip_header_t* lheader = BELLE_SIP_HEADER($header_extension_base.ret);
do {
if (lheader == NULL) break; /*sanity check*/
belle_sip_message_add_header(message,lheader);
}
while((lheader=belle_sip_header_get_next(lheader)) != NULL); }
) CRLF
;
/*
invitem
: 'INVITE' ; //INVITE in caps
ackm : 'ACK'; //ACK in caps
optionsm: 'OPTION'; //OPTIONS in caps
byem : 'BYE' ; //BYE in caps
cancelm : 'CANCEL' ; //CANCEL in caps
registerm
: 'REGISTER' ; //REGISTER in caps
optionm : 'OPTION';
*/
method : /* invitem | ackm | optionm | byem | cancelm | registerm |*/extension_method ;
extension_method
: token;
common_response returns [belle_sip_message_t* ret=NULL]
: ( (sip_version ~(CRLF)* CRLF) => status_line {$ret=BELLE_SIP_MESSAGE($status_line.ret);}
| (http_version ~(CRLF)* CRLF) => http_status_line{$ret=BELLE_SIP_MESSAGE($http_status_line.ret);})
(message_header[BELLE_SIP_MESSAGE($ret)]+ last_crlf=CRLF {*($message_raw::message_length)=$last_crlf->user1;} /*message_body*/)? ;
response returns [belle_sip_response_t* ret=NULL]
: common_response {$ret=BELLE_SIP_RESPONSE($common_response.ret);} ;
status_line returns [belle_sip_response_t* ret=NULL]
scope { belle_sip_response_t* current; }
@init {$ret = belle_sip_response_new(); }
: sip_version
SP status_code {belle_sip_response_set_status_code($ret,atoi((char*)$status_code.text->chars));}
SP reason_phrase {belle_sip_response_set_reason_phrase($ret,(char*)$reason_phrase.text->chars);}
CRLF ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref( $ret);
$ret=NULL;
}
status_code
: extension_code;
extension_code
: DIGIT DIGIT DIGIT;
reason_phrase
: ~(CRLF)*;
//****************http**********************/
/*Request-Line = Method SP Request-URI SP HTTP-Version CRLF*/
http_request returns [belle_http_request_t* ret=NULL]
:common_request {$ret=BELLE_HTTP_REQUEST($common_request.ret);};
http_request_line returns [belle_http_request_t *ret=NULL]
scope { belle_http_request_t* current; }
@init {$http_request_line::current = belle_http_request_new(); $ret=$http_request_line::current; }
: method {belle_http_request_set_method($http_request_line::current,(const char*)($method.text->chars));}
SP
(generic_uri)=>generic_uri {belle_http_request_set_uri($http_request_line::current,$generic_uri.ret);}
SP
http_version CRLF;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($http_request_line::current);
$ret=NULL;
}
http_version: {IS_TOKEN(HTTP/)}? generic_version;
http_response returns [belle_http_response_t* ret=NULL]
: common_response {$ret=BELLE_HTTP_RESPONSE($common_response.ret);} ;
http_status_line returns [belle_http_response_t* ret]
@init {$ret = belle_http_response_new(); }
: http_version
SP status_code {belle_http_response_set_status_code($ret,atoi((char*)$status_code.text->chars));}
SP reason_phrase {belle_http_response_set_reason_phrase($ret,(char*)$reason_phrase.text->chars);}
CRLF ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref( $ret);
$ret=NULL;
}
/*
absoluteURI = scheme ":" ( hier_part | opaque_part )
hier_part = ( net_path | abs_path ) [ "?" query ]
net_path = "//" authority [ abs_path ]
abs_path = "/" path_segments
*/
/*comma, semicolon, or question
mark*/
opaque_part_for_from_to_contact_addr_spec
: uric_no_slash_for_from_to_contact_addr_spec uric_for_from_to_contact_addr_spec*;
opaque_part
: uric_no_slash uric*;
uric_no_slash_for_from_to_contact_addr_spec
: unreserved | escaped | COLON | AT| AND | EQUAL | PLUS | DOLLARD;
uric_no_slash
:COMMA | SEMI | QMARK | uric_no_slash_for_from_to_contact_addr_spec ;
scheme: alpha ( alphanum | PLUS | DASH | DOT )*;
/*remove hiearachy part because complex to handle the :comma, semicolon, or question
markexception see rfc3261 section 20.10 Contact*/
generic_uri_for_from_to_contact_addr_spec returns [belle_generic_uri_t* ret=NULL]
scope { belle_generic_uri_t* current; }
@init { $generic_uri_for_from_to_contact_addr_spec::current = $ret = belle_generic_uri_new(); }
: scheme {belle_generic_uri_set_scheme($generic_uri_for_from_to_contact_addr_spec::current,(const char*)$scheme.text->chars);}
COLON opaque_part_for_from_to_contact_addr_spec {belle_generic_uri_set_opaque_part($generic_uri_for_from_to_contact_addr_spec::current,(const char*)$opaque_part_for_from_to_contact_addr_spec.text->chars) ;} ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($generic_uri::current);
$ret=NULL;
}
generic_uri returns [belle_generic_uri_t* ret=NULL]
scope { belle_generic_uri_t* current; }
@init { $generic_uri::current = $ret = belle_generic_uri_new(); }
: hier_part[$generic_uri::current]
| (scheme {belle_generic_uri_set_scheme($generic_uri::current,(const char*)$scheme.text->chars);}
COLON (opaque_part {belle_generic_uri_set_opaque_part($generic_uri::current,(const char*)$opaque_part.text->chars) ;}
| hier_part[$generic_uri::current]) ) ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($generic_uri::current);
$ret=NULL;
}
hier_part[belle_generic_uri_t* uri] returns [belle_generic_uri_t* ret=NULL]
: (
(SLASH SLASH path_segments[NULL])=>( SLASH SLASH path_segments[uri])
|
(SLASH SLASH authority[NULL] (path_segments[NULL])?)=>( SLASH SLASH authority[uri] (path_segments[uri])?)
|
( path_segments[uri]) )
(QMARK query
{
char* unescaped_query;
unescaped_query=belle_sip_to_unescaped_string((const char *)$query.text->chars);
belle_generic_uri_set_query(uri,(const char*)unescaped_query);
belle_sip_free(unescaped_query);
}) ?;
path_segments[belle_generic_uri_t* uri]
: SLASH (segment ( SLASH segment )*)
{
char* unescaped_path;
unescaped_path=belle_sip_to_unescaped_string((const char *)$path_segments.text->chars);
belle_generic_uri_set_path(uri,(const char*)unescaped_path);
belle_sip_free(unescaped_path);
};
segment: pchar* ( SEMI param )*;
param: pchar*;
pchar: unreserved | escaped | COLON | AT | AND | EQUAL | PLUS | DOLLARD | COMMA;
query: uric+;
uric: reserved | unreserved | escaped;
uric_for_from_to_contact_addr_spec: reserved_for_from_to_contact_addr_spec | unreserved | escaped;
authority[belle_generic_uri_t* uri]
:
((authority_userinfo[NULL]) =>authority_userinfo[uri] )? authority_hostport[uri]
/*| authority_hostport[uri]*/ ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
}
authority_userinfo[belle_generic_uri_t* uri]
scope { belle_generic_uri_t* current; }
@init {$authority_userinfo::current=uri;}
: authority_user ( COLON authority_password )? AT ;
authority_user : ( unreserved | escaped | user_unreserved )+ {
char* unescaped_username;
unescaped_username=belle_sip_to_unescaped_string((const char *)$text->chars);
belle_generic_uri_set_user($authority_userinfo::current,unescaped_username);
belle_sip_free(unescaped_username);
};
authority_password : ( unreserved | escaped | AND | EQUAL | PLUS | DOLLARD | COMMA )* {
char* unescaped_userpasswd;
const char* source = (const char*)$text->chars;
if( source != NULL ){
unescaped_userpasswd=belle_sip_to_unescaped_string((const char *)source);
belle_generic_uri_set_user_password($authority_userinfo::current,unescaped_userpasswd);
belle_sip_free(unescaped_userpasswd);
}
};
authority_hostport[belle_generic_uri_t* uri]
scope { belle_generic_uri_t* current; }
@init {$authority_hostport::current=uri;}
: host ( COLON port {belle_generic_uri_set_port($authority_hostport::current,$port.ret);})? {belle_generic_uri_set_host($authority_hostport::current,$host.ret);};
//****************http end**********************/
//****************SIP**********************/
generic_param [belle_sip_parameters_t* object] returns [belle_sip_param_pair_t* ret=NULL]
scope{int is_value; char* gen_value_string;}
@init { $generic_param::is_value=0; $generic_param::gen_value_string=NULL;}
: token ( equal gen_value {$generic_param::gen_value_string=(char*)($gen_value.text->chars);} )? {
if (object == NULL) {
$ret=belle_sip_param_pair_new((const char*)($token.text->chars)
,$generic_param::gen_value_string);
} else {
belle_sip_parameters_set_parameter(object
,(const char*)($token.text->chars)
,$generic_param::gen_value_string);
$ret=NULL;
}
};
gen_value
: token | quoted_string;
quoted_string
options { greedy = false; }
: DQUOTE (~(DQUOTE | BSLASH) | (BSLASH .))* DQUOTE ;
/*
accept_encoding
: 'Accept-Encoding' HCOLON ( encoding (COMMA encoding)* );
encoding
: codings (SEMI accept_param)*;
codings
: content_coding | '*';
content_coding : token;
accept_language
: 'Accept-Language' HCOLON
( language (COMMA language)* )?;
language
: language_range (SEMI accept_param)*;
language_range
: ( ( alpha alpha alpha alpha alpha alpha alpha alpha ( '-' alpha alpha alpha alpha alpha alpha alpha alpha )* ) | '*' );
alert_info
: 'Alert-Info' HCOLON alert_param (COMMA alert_param)*;
alert_param
: LAQUOT absoluteURI RAQUOT ( SEMI generic_param )*;
absoluteURI
: token ':' token;
*/
header_allow returns [belle_sip_header_allow_t* ret]
scope { belle_sip_header_allow_t* current; }
@init {$header_allow::current = belle_sip_header_allow_new(); $ret=$header_allow::current; }
: {IS_TOKEN(Allow)}? token /*'Allow'*/ hcolon methods {belle_sip_header_allow_set_method($header_allow::current,(const char*)($methods.text->chars));} ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_allow::current);
$ret=NULL;
}
methods : /*LWS?*/ method (comma method)*;
authorization_token: {IS_TOKEN(Authorization)}? token;
digest_token: {IS_TOKEN(Digest)}? token;
header_authorization returns [belle_sip_header_authorization_t* ret]
scope { belle_sip_header_authorization_t* current; }
@init {$header_authorization::current = belle_sip_header_authorization_new(); $ret=$header_authorization::current; }
: authorization_token /*'Authorization'*/ hcolon credentials[$header_authorization::current];
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_authorization::current);
$ret=NULL;
}
credentials [belle_sip_header_authorization_t* header_authorization_base]
: (digest_token /*'Digest'*/ {belle_sip_header_authorization_set_scheme(header_authorization_base,"Digest");}
lws digest_response[header_authorization_base])
| other_response[header_authorization_base];
digest_response [belle_sip_header_authorization_t* header_authorization_base]
: dig_resp[header_authorization_base] (comma dig_resp[header_authorization_base])*;
dig_resp [belle_sip_header_authorization_t* header_authorization_base]
: username { belle_sip_header_authorization_set_username(header_authorization_base,$username.ret);
belle_sip_free($username.ret);
}
| realm { belle_sip_header_authorization_set_realm(header_authorization_base,(char*)$realm.ret);
belle_sip_free($realm.ret);
}
| nonce { belle_sip_header_authorization_set_nonce(header_authorization_base,(char*)$nonce.ret);
belle_sip_free($nonce.ret);
}
| digest_uri[header_authorization_base]
| dresponse { belle_sip_header_authorization_set_response(header_authorization_base,(char*)$dresponse.ret);
belle_sip_free($dresponse.ret);
}
| algorithm {
belle_sip_header_authorization_set_algorithm(header_authorization_base,(char*)$algorithm.ret);
}
| cnonce{
belle_sip_header_authorization_set_cnonce(header_authorization_base,(char*)$cnonce.ret);
belle_sip_free($cnonce.ret);
}
| opaque {
belle_sip_header_authorization_set_opaque(header_authorization_base,(char*)$opaque.ret);
belle_sip_free($opaque.ret);
}
| message_qop{
belle_sip_header_authorization_set_qop(header_authorization_base,$message_qop.ret);
}
| nonce_count{
belle_sip_header_authorization_set_nonce_count(header_authorization_base,atoi((char*)$nonce_count.ret));
}
| auth_param[header_authorization_base]
;
username_token: {IS_TOKEN(username)}? token;
username returns [char* ret=NULL]
: username_token /*'username'*/ equal username_value {
$ret = _belle_sip_str_dup_and_unquote_string((char*)$username_value.text->chars);
};
username_value : quoted_string;
uri_token: {IS_TOKEN(uri)}? token;
digest_uri [belle_sip_header_authorization_t* header_authorization_base]
: uri_token /*'uri'*/ equal DQUOTE uri DQUOTE
{belle_sip_header_authorization_set_uri(header_authorization_base,$uri.ret);
};
/*
digest_uri_value : rquest_uri ;
rquest_uri
: uri;
*/
// Equal to request-uri as specified by HTTP/1.1
message_qop returns [const char* ret=NULL]
: {IS_TOKEN(qop)}? token/*'qop'*/ equal qop_value {$ret = (const char*)$qop_value.text->chars;};
qop_value
: token;
cnonce returns [char* ret=NULL]
: {IS_TOKEN(cnonce)}? token /*'cnonce'*/ equal cnonce_value {
$ret = _belle_sip_str_dup_and_unquote_string((char*)$cnonce_value.text->chars);
};
cnonce_value
: nonce_value;
nonce_count returns [const char* ret=NULL]
: {IS_TOKEN(nc)}? token /*'nc'*/ equal nc_value {$ret=(char*)$nc_value.text->chars;};
nc_value
: huit_lhex;
dresponse returns [char* ret=NULL]
: {IS_TOKEN(response)}? token /*'response'*/ equal request_digest{
$ret = _belle_sip_str_dup_and_unquote_string((char*)$request_digest.text->chars);
};
request_digest
: quoted_string ;/*sp_laquot_sp huit_lhex huit_lhex huit_lhex huit_lhex sp_raquot_sp;
*/
huit_lhex
: hexdigit+;
auth_param [belle_sip_header_authorization_t* header_authorization_base]
: auth_param_name equal
auth_param_value {belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS(header_authorization_base)
,(char*)$auth_param_name.text->chars
,(char*)$auth_param_value.text->chars);
}
;
auth_param_value : token | quoted_string ;
auth_param_name
: token;
other_response [belle_sip_header_authorization_t* header_authorization_base]
: auth_scheme {belle_sip_header_authorization_set_scheme(header_authorization_base,(const char*)$auth_scheme.text->chars);}
lws auth_param[header_authorization_base]
(comma auth_param[header_authorization_base])*;
auth_scheme
: token;
/*
authentication_info : 'Authentication-Info' HCOLON ainfo
(COMMA ainfo)*;
ainfo
: nextnonce | message_qop
| response_auth | cnonce
| nonce_count;
nextnonce
: 'nextnonce' EQUAL nonce_value;
*/
nonce_value : quoted_string;
/*
response_auth
: 'rspauth' EQUAL response_digest;
response_digest
: LDQUOT hexdigit* RDQUOT;
*/
/*callid header*/
call_id_token: {IS_HEADER_NAMED(Call-ID,i)}? token;
header_call_id returns [belle_sip_header_call_id_t* ret=NULL]
scope { belle_sip_header_call_id_t* current; }
@init {$header_call_id::current = belle_sip_header_call_id_new(); $ret=$header_call_id::current; }
: call_id_token /*( 'Call-ID' | 'i' )*/ hcolon call_id{belle_sip_header_call_id_set_call_id($header_call_id::current,(const char*) $call_id.text->chars); };
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_call_id::current);
$ret=NULL;
}
call_id
: word ( AT word )? ;
/*
call_info
: 'Call-Info' HCOLON info (COMMA info)*;
info
: LAQUOT absoluteURI RAQUOT ( SEMI info_param)*;
info_param
: ( 'purpose' EQUAL ( 'icon' | 'info'
| 'card' | token ) ) | generic_param;
*/
/* contact header */
contact_token: {IS_HEADER_NAMED(Contact,m)}? token;
header_contact returns [belle_sip_header_contact_t* ret]
scope { belle_sip_header_contact_t* current; belle_sip_header_contact_t* first; }
@init { $header_contact::current =NULL; $header_contact::first =NULL; $ret=NULL; }
: (contact_token /*'Contact'*/ /*| 'm'*/ ) sp_tab_colon
( (lws? STAR) { $header_contact::current = belle_sip_header_contact_new();
belle_sip_header_contact_set_wildcard($header_contact::current,1);}
| (contact_param ( COMMA contact_param)*)) {$ret = $header_contact::first; };
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
$ret = $header_contact::first;
if ($ret) belle_sip_object_unref($ret);
$ret=NULL;
}
contact_param
scope { belle_sip_header_contact_t* prev;}
@init { if ($header_contact::current == NULL) {
$header_contact::current = belle_sip_header_contact_new();
$header_contact::first = $header_contact::current;
$contact_param::prev=NULL;
} else {
$contact_param::prev=$header_contact::current;
belle_sip_header_set_next(BELLE_SIP_HEADER($header_contact::current),(belle_sip_header_t*)belle_sip_header_contact_new());
$header_contact::current = (belle_sip_header_contact_t*)belle_sip_header_get_next(BELLE_SIP_HEADER($header_contact::current));
}
}
: ( name_addr[BELLE_SIP_HEADER_ADDRESS($header_contact::current)]
| paramless_addr_spec[BELLE_SIP_HEADER_ADDRESS($header_contact::current)]) (SEMI lws? contact_params lws?)*;
header_address returns [belle_sip_header_address_t* ret]
@init { $ret=NULL; }
: header_address_base[belle_sip_header_address_new()] {$ret=$header_address_base.ret;};
header_address_base[belle_sip_header_address_t* obj] returns [belle_sip_header_address_t* ret]
@init { $ret=obj; }
: ( name_addr_with_generic_uri[BELLE_SIP_HEADER_ADDRESS($ret)]
| addr_spec_with_generic_uri[BELLE_SIP_HEADER_ADDRESS($ret)]) { if (!belle_sip_header_address_get_uri($ret) && !belle_sip_header_address_get_absolute_uri(($ret))) {
belle_sip_object_unref($ret);
$ret=NULL;
}
};
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_debug("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
if ($ret) belle_sip_object_unref($ret);
$ret=NULL;
}
fast_header_address returns [belle_sip_header_address_t* ret]
@init { $ret=belle_sip_header_address_new(); }
: ( fast_name_addr_with_generic_uri[BELLE_SIP_HEADER_ADDRESS($ret)]
| fast_addr_spec_with_generic_uri[BELLE_SIP_HEADER_ADDRESS($ret)]) { if (!belle_sip_header_address_get_uri($ret) && !belle_sip_header_address_get_absolute_uri(($ret))) {
belle_sip_object_unref($ret);
$ret=NULL;
}
};
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_debug("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
if ($ret) belle_sip_object_unref($ret);
$ret=NULL;
}
name_addr[belle_sip_header_address_t* object]
: (lws? display_name[object])? sp_laquot addr_spec[object] raquot_sp;
name_addr_with_generic_uri[belle_sip_header_address_t* object]
: (lws? display_name[object])? sp_laquot addr_spec_with_generic_uri[object] raquot_sp;
fast_name_addr_with_generic_uri[belle_sip_header_address_t* object]
: (lws? display_name[object])? sp_laquot fast_addr_spec_with_generic_uri[object] raquot_sp;
addr_spec[belle_sip_header_address_t* object]
: lws? uri {belle_sip_header_address_set_uri(object,$uri.ret);} lws?;//| absoluteURI;
addr_spec_with_generic_uri[belle_sip_header_address_t* object]
: lws? ( uri {belle_sip_header_address_set_uri(object,$uri.ret);}
|
generic_uri { if ( strcasecmp(belle_generic_uri_get_scheme($generic_uri.ret),"sip") != 0
&& strcasecmp(belle_generic_uri_get_scheme($generic_uri.ret),"sips") != 0 ) {
belle_sip_header_address_set_absolute_uri(object,$generic_uri.ret);
} else {
belle_sip_message("Cannot parse a sip/sips uri as a generic uri");
belle_sip_object_unref($generic_uri.ret);
}}
) lws?;
fast_addr_spec_with_generic_uri[belle_sip_header_address_t* object]
: lws? ( fast_uri {belle_sip_header_address_set_uri(object,$fast_uri.ret);}
|
generic_uri { if ( strcasecmp(belle_generic_uri_get_scheme($generic_uri.ret),"sip") != 0
&& strcasecmp(belle_generic_uri_get_scheme($generic_uri.ret),"sips") != 0 ) {
belle_sip_header_address_set_absolute_uri(object,$generic_uri.ret);
} else {
belle_sip_message("Cannot parse a sip/sips uri as a generic uri");
belle_sip_object_unref($generic_uri.ret);
}}
) lws?;
paramless_addr_spec[belle_sip_header_address_t* object]
: lws? paramless_uri {belle_sip_header_address_set_uri(object,$paramless_uri.ret);} lws? ;//| absoluteURI;
paramless_addr_spec_with_generic_uri[belle_sip_header_address_t* object]
: lws? ( paramless_uri {belle_sip_header_address_set_uri(object,$paramless_uri.ret);}
|
generic_uri_for_from_to_contact_addr_spec{belle_sip_header_address_set_absolute_uri(object,$generic_uri_for_from_to_contact_addr_spec.ret);}
) lws? ;
display_name_tokens
:token (lws token)* ;
display_name[belle_sip_header_address_t* object]
: display_name_tokens {belle_sip_header_address_set_displayname(object,(const char*)($display_name_tokens.text->chars));}
| quoted_string
{
char* unescaped_char = belle_sip_string_to_backslash_less_unescaped_string((const char*)($quoted_string.text->chars));
belle_sip_header_address_set_quoted_displayname(object,(const char*)unescaped_char);
belle_sip_free(unescaped_char);
}
;
contact_params
: /*c_p_q | c_p_expires
|*/ contact_extension;
/*c_p_q
: 'q' EQUAL qvalue;
c_p_expires
: 'expires' EQUAL delta_seconds;*/
contact_extension
: generic_param [BELLE_SIP_PARAMETERS($header_contact::current)];
delta_seconds
: DIGIT+;
/*
content_disposition
: 'Content-Disposition' HCOLON
disp_type ( SEMI disp_param )*;
disp_type : 'render' | 'session' | 'icon' | 'alert'
| disp_extension_token;
disp_param
: handling_param | generic_param;
handling_param
: 'handling' EQUAL
( 'optional' | 'required'
| other_handling );
other_handling
: token;
disp_extension_token
: token;
content_encoding
: ( 'Content-Encoding' | 'e' ) HCOLON
content_coding (COMMA content_coding)*;
content_language
: 'Content-Language' HCOLON
language_tag (COMMA language_tag)*;
language_tag
: primary_tag ( '-' subtag )*;
primary_tag
: huit_alpha;
subtag
: huit_alpha;
huit_alpha
: alpha+;
;
*/
/*content_length_token : {strcmp("Content-Length",(const char*)(INPUT->toStringTT(INPUT,LT(1),LT(14)))->chars) == 0}? token;*/
content_length_token : {IS_HEADER_NAMED(Content-Length,l)}? token;
header_content_length returns [belle_sip_header_content_length_t* ret]
scope { belle_sip_header_content_length_t* current; }
@init {$header_content_length::current = belle_sip_header_content_length_new(); $ret=$header_content_length::current; }
: content_length_token /*( 'Content-Length' | 'l' )*/
hcolon
content_length {belle_sip_header_content_length_set_content_length($header_content_length::current,atoi((const char*)$content_length.text->chars));};
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_content_length::current);
$ret=NULL;
}
content_length:DIGIT+;
content_type_token : {IS_HEADER_NAMED(Content-Type,c)}? token;
header_content_type returns [belle_sip_header_content_type_t* ret=NULL]
scope { belle_sip_header_content_type_t* current;}
@init { $header_content_type::current = belle_sip_header_content_type_new();$ret=$header_content_type::current; }
: content_type_token/* ( 'Content-Type' | 'c' )*/ hcolon media_type;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_content_type::current);
$ret=NULL;
}
media_type
: m_type {belle_sip_header_content_type_set_type($header_content_type::current,(const char*)$m_type.text->chars);}
slash
m_subtype {belle_sip_header_content_type_set_subtype($header_content_type::current,(const char*)$m_subtype.text->chars);}
(semi type_param)? (semi generic_param [BELLE_SIP_PARAMETERS($header_content_type::current)])*;
m_type
: token;
type_param: {IS_TOKEN(type)}? token equal type_param_value;
type_param_value : m_type slash m_subtype {belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS($header_content_type::current)
,"type"
,(const char*)$type_param_value.text->chars);};
/* discrete_type | composite_type;
discrete_type
: 'text' | 'image' | 'audio' | 'video'
| 'application' | extension_token;
composite_type
: 'message' | 'multipart' | extension_token;
extension_token
: ietf_token | x_token;
ietf_token
: token;
x_token
: 'x-' token;*/
m_subtype : token ;/* extension_token | iana_token;
iana_token
: token;
m_parameter
: m_attribute EQUAL m_value;
m_attribute
: token;
m_value
: token | quoted_string;
*/
cseq_token : {IS_TOKEN(CSeq)}? token;
header_cseq returns [belle_sip_header_cseq_t* ret]
scope { belle_sip_header_cseq_t* current; }
@init { $header_cseq::current = belle_sip_header_cseq_new();$ret = $header_cseq::current; }
: cseq_token
hcolon
seq_number {belle_sip_header_cseq_set_seq_number($header_cseq::current,atoi((const char*)$seq_number.text->chars));}
lws
method {belle_sip_header_cseq_set_method($header_cseq::current,(const char*)$method.text->chars);} ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_cseq::current);
$ret=NULL;
}
seq_number:DIGIT+;
/*Date header*/
date_token: {IS_TOKEN(Date)}? token;
header_date returns [belle_sip_header_date_t* ret]
scope { belle_sip_header_date_t* current; }
@init {$header_date::current = belle_sip_header_date_new(); $ret=$header_date::current; }
: date_token /*( 'Date' )*/ hcolon sip_date{belle_sip_header_date_set_date($header_date::current,(const char*) $sip_date.text->chars); };
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_date::current);
$ret=NULL;
}
date
: sip_date;
sip_date
: /*wkday*/alpha alpha alpha COMMA SP /*date1*/DIGIT DIGIT SP alpha alpha alpha SP DIGIT DIGIT DIGIT DIGIT SP /*time*/DIGIT DIGIT COLON DIGIT DIGIT COLON DIGIT DIGIT SP /*GMTT*/alpha alpha alpha;
/*
// 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"
error_info
: 'Error-Info' HCOLON error_uri (COMMA error_uri)*;
error_uri
: LAQUOT absoluteURI RAQUOT ( SEMI generic_param )*;
*/
header_expires returns [belle_sip_header_expires_t* ret]
scope { belle_sip_header_expires_t* current; }
@init { $header_expires::current = belle_sip_header_expires_new();$ret = $header_expires::current; }
: {IS_TOKEN(Expires)}? token /*'Expires'*/ hcolon delta_seconds {belle_sip_header_expires_set_expires($header_expires::current,atoi((const char *)$delta_seconds.text->chars));};
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_expires::current);
$ret=NULL;
}
from_token: {IS_HEADER_NAMED(From,f)}? token;
header_from returns [belle_sip_header_from_t* ret]
scope { belle_sip_header_from_t* current; }
@init { $header_from::current = belle_sip_header_from_new();$ret = $header_from::current; }
: from_token/* ( 'From' | 'f' )*/ sp_tab_colon from_spec ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_from::current);
$ret=NULL;
}
from_spec
: ( name_addr_with_generic_uri[BELLE_SIP_HEADER_ADDRESS($header_from::current)] | paramless_addr_spec_with_generic_uri[BELLE_SIP_HEADER_ADDRESS($header_from::current)] )
( SEMI lws? from_param lws?)*;
from_param
: /*tag_param |*/ generic_param [BELLE_SIP_PARAMETERS($header_from::current)];
/*
tag_param
: 'tag' EQUAL token;
*/
/*
in_reply_to
: 'In-Reply-To' HCOLON callid (COMMA callid);
*/
header_max_forwards returns [belle_sip_header_max_forwards_t* ret]
scope { belle_sip_header_max_forwards_t* current; }
@init { $header_max_forwards::current = belle_sip_header_max_forwards_new();$ret = $header_max_forwards::current; }
: {IS_TOKEN(Max-Forwards)}? token /*'Max-Forwards'*/ hcolon
max_forwards {belle_sip_header_max_forwards_set_max_forwards($header_max_forwards::current,atoi((const char*)$max_forwards.text->chars));};
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_max_forwards::current);
$ret=NULL;
}
max_forwards:DIGIT+;
/*
mime_version
: 'MIME-Version' HCOLON DIGIT+ '.' DIGIT+;
min_expires
: 'Min-Expires' HCOLON delta_seconds;
organization
: 'Organization' HCOLON (text_utf8_trim)?;
text_utf8_trim
:
;
priority
: 'Priority' HCOLON priority_value;
priority_value
: 'emergency' | 'urgent' | 'normal'
| 'non-urgent' | other_priority;
other_priority
: token;
*/
header_proxy_authenticate returns [belle_sip_header_proxy_authenticate_t* ret]
scope { belle_sip_header_proxy_authenticate_t* current; }
@init { $header_proxy_authenticate::current = belle_sip_header_proxy_authenticate_new();$ret = $header_proxy_authenticate::current; }
: {IS_TOKEN(Proxy-Authenticate)}? token /*'Proxy-Authenticate'*/
hcolon challenge[BELLE_SIP_HEADER_WWW_AUTHENTICATE($header_proxy_authenticate::current)];
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_proxy_authenticate::current);
$ret=NULL;
}
challenge [belle_sip_header_www_authenticate_t* www_authenticate]
: ({IS_TOKEN(Digest)}? token /*'Digest'*/ {belle_sip_header_www_authenticate_set_scheme(www_authenticate,"Digest");}
lws digest_cln[www_authenticate] (comma digest_cln[www_authenticate])*)
| other_challenge [www_authenticate];
other_challenge [belle_sip_header_www_authenticate_t* www_authenticate]
: auth_scheme {belle_sip_header_www_authenticate_set_scheme(www_authenticate,(char*)$auth_scheme.text->chars);}
lws auth_param[(belle_sip_header_authorization_t*)www_authenticate]
(comma auth_param[(belle_sip_header_authorization_t*)www_authenticate])*;
digest_cln [belle_sip_header_www_authenticate_t* www_authenticate]
:
realm {belle_sip_header_www_authenticate_set_realm(www_authenticate,(char*)$realm.ret);
belle_sip_free($realm.ret);}
| nonce {belle_sip_header_www_authenticate_set_nonce(www_authenticate,(char*)$nonce.ret);
belle_sip_free($nonce.ret);}
| algorithm {belle_sip_header_www_authenticate_set_algorithm(www_authenticate,$algorithm.ret);}
| opaque {belle_sip_header_www_authenticate_set_opaque(www_authenticate,$opaque.ret);
belle_sip_free($opaque.ret);}
| qop_opts {belle_sip_header_www_authenticate_set_qop(www_authenticate,$qop_opts.ret);
/*belle_sip_free($qop_opts.ret);*/}
| domain {belle_sip_header_www_authenticate_set_domain(www_authenticate,$domain.ret);
belle_sip_free($domain.ret);}
| stale { if (strcmp("true",$stale.ret)==0) {
belle_sip_header_www_authenticate_set_stale(www_authenticate,1);
}
}
| auth_param[(belle_sip_header_authorization_t*)www_authenticate];
/* the cast above is very BAD, but auth_param works on fields common to the two structures*/
realm returns [char* ret=NULL]
: {IS_TOKEN(realm)}? token /*'realm'*/ equal realm_value {
$ret = _belle_sip_str_dup_and_unquote_string((char*)$realm_value.text->chars);
};
realm_value
: quoted_string ;
domain returns [char* ret=NULL]
: {IS_TOKEN(domain)}? token /*'domain'*/ equal quoted_string {
$ret = _belle_sip_str_dup_and_unquote_string((char*)$quoted_string.text->chars);};
/* LDQUOT uri
( SP+ uri )* RDQUOT;
uri
: absoluteURI | '/'.;
*/
nonce returns [char* ret=NULL]
: {IS_TOKEN(nonce)}? token /*'nonce'*/ equal nonce_value{
$ret = _belle_sip_str_dup_and_unquote_string((char*)$nonce_value.text->chars);
};
opaque returns [char* ret=NULL]
: {IS_TOKEN(opaque)}? token /*'opaque'*/ equal quoted_string{
$ret = _belle_sip_str_dup_and_unquote_string((char*)$quoted_string.text->chars);
};
stale returns [const char* ret=NULL]
: {IS_TOKEN(stale)}? token /*'stale'*/ equal stale_value {$ret=(char*)$stale_value.text->chars;} /* ( 'true' | 'false' )*/;
stale_value:token;
algorithm returns [const char* ret=NULL]
: {IS_TOKEN(algorithm)}? token /*'algorithm'*/ equal /* ( 'MD5' | 'MD5-sess'
|*/ alg_value=token {$ret=(char*)$alg_value.text->chars;}/*)*/
;
qop_opts returns [belle_sip_list_t* ret=NULL]
scope { belle_sip_list_t* list; }
@init{$qop_opts::list=NULL;}
: {IS_TOKEN(qop)}? token /*'qop'*/ equal
/*ldquot*/DQUOTE
qop_opts_value
(COMMA qop_opts_value)*
/*rdquot*/DQUOTE {$ret=$qop_opts::list;} ;
qop_opts_value
: lws? token lws? {$qop_opts::list=belle_sip_list_append($qop_opts::list,belle_sip_strdup((const char*)$token.text->chars));};
header_proxy_authorization returns [belle_sip_header_proxy_authorization_t* ret=NULL]
scope { belle_sip_header_proxy_authorization_t* current; }
@init { $header_proxy_authorization::current = belle_sip_header_proxy_authorization_new();$ret = $header_proxy_authorization::current; }
: {IS_TOKEN(Proxy-Authorization)}? token /*'Proxy-Authorization'*/ hcolon credentials[(belle_sip_header_authorization_t*)$header_proxy_authorization::current];
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_proxy_authorization::current);
$ret=NULL;
}
/*
proxy_require
: 'Proxy-Require' HCOLON option_tag
(COMMA option_tag)*;
option_tag
: token;
*/
/*FIXME service-route = recorde-route = route, too many copy/past*/
service_route_token: {IS_TOKEN(Service-Route)}? token;
header_service_route returns [belle_sip_header_service_route_t* ret=NULL]
scope { belle_sip_header_service_route_t* current; belle_sip_header_service_route_t* first;}
@init { $header_service_route::current = NULL;$header_service_route::first =NULL;}
: service_route_token /*'Service-Route'*/ sp_tab_colon srv_route (COMMA srv_route)* {$ret = $header_service_route::first;};
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
$ret = $header_service_route::first;
if ($ret) belle_sip_object_unref($ret);
$ret=NULL;
}
srv_route
scope { belle_sip_header_service_route_t* prev;}
@init { if ($header_service_route::current == NULL) {
$header_service_route::first = $header_service_route::current = belle_sip_header_service_route_new();
$srv_route::prev=NULL;
} else {
belle_sip_header_t* header = BELLE_SIP_HEADER($header_service_route::current);
$srv_route::prev=$header_service_route::current;
belle_sip_header_set_next(header,(belle_sip_header_t*)($header_service_route::current = belle_sip_header_service_route_new()));
}
}
: name_addr[BELLE_SIP_HEADER_ADDRESS($header_service_route::current)] ( SEMI lws? sr_param lws?)*;
sr_param
: generic_param[BELLE_SIP_PARAMETERS($header_service_route::current)];
record_route_token: {IS_TOKEN(Record-Route)}? token;
header_record_route returns [belle_sip_header_record_route_t* ret=NULL]
scope { belle_sip_header_record_route_t* current; belle_sip_header_record_route_t* first;}
@init { $header_record_route::current = NULL;$header_record_route::first =NULL;}
: record_route_token /*'Record-Route'*/ sp_tab_colon rec_route ( COMMA rec_route)* {$ret = $header_record_route::first;};
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
$ret = $header_record_route::first;
if ($ret) belle_sip_object_unref($ret);
$ret=NULL;
}
rec_route
scope { belle_sip_header_record_route_t* prev;}
@init { if ($header_record_route::current == NULL) {
$header_record_route::first = $header_record_route::current = belle_sip_header_record_route_new();
$rec_route::prev=NULL;
} else {
belle_sip_header_t* header = BELLE_SIP_HEADER($header_record_route::current);
$rec_route::prev=$header_record_route::current;
belle_sip_header_set_next(header,(belle_sip_header_t*)($header_record_route::current = belle_sip_header_record_route_new()));
}
}
: name_addr[BELLE_SIP_HEADER_ADDRESS($header_record_route::current)] ( SEMI lws? rr_param lws? )*;
rr_param
: generic_param[BELLE_SIP_PARAMETERS($header_record_route::current)];
/*
reply_to
: 'Reply-To' HCOLON rplyto_spec;
rplyto_spec
: ( name_addr | addr_spec )
( SEMI rplyto_param )*;
rplyto_param
: generic_param;
require
: 'Require' HCOLON option_tag (COMMA option_tag)*;
retry_after
: 'Retry-After' HCOLON delta_seconds
comment? ( SEMI retry_param )*;
*/
comment : LPAREN . RPAREN;
/*
retry_param
: ('duration' EQUAL delta_seconds)
| generic_param;
*/
route_token: {IS_TOKEN(Route)}? token;
header_route returns [belle_sip_header_route_t* ret=NULL]
scope { belle_sip_header_route_t* current;belle_sip_header_route_t* first; }
@init { $header_route::current = NULL; $header_route::first =NULL;}
: route_token /*'Route'*/ sp_tab_colon route_param ( COMMA route_param)*{$ret = $header_route::first;};
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
$ret = $header_route::first;
if ($ret) belle_sip_object_unref($ret);
$ret=NULL;
}
route_param
scope { belle_sip_header_route_t* prev;}
@init { if ($header_route::current == NULL) {
$header_route::first = $header_route::current = belle_sip_header_route_new();
$route_param::prev=NULL;
} else {
belle_sip_header_t* header = BELLE_SIP_HEADER($header_route::current);
$route_param::prev=$header_route::current;
belle_sip_header_set_next(header,(belle_sip_header_t*)($header_route::current = belle_sip_header_route_new()));
}
}
: name_addr[BELLE_SIP_HEADER_ADDRESS($header_route::current)] ( SEMI lws? r_param lws?)*;
r_param
: generic_param[BELLE_SIP_PARAMETERS($header_route::current)];
/*
server
: 'Server' HCOLON server_val (lws server_val)*;
*/
/*
subject
: ( 'Subject' | 's' ) HCOLON (text_utf_huit)?;
text_utf_huit
:
;
supported
: ( 'Supported' | 'k' ) HCOLON
(option_tag (COMMA option_tag)*)?;
timestamp
: 'Timestamp' HCOLON (DIGIT)+
( '.' (DIGIT)* )? ( lws delay )?;
delay
: (DIGIT)* ( '.' (DIGIT)* )?;
*/
to_token: {IS_HEADER_NAMED(To,t)}? token;
header_to returns [belle_sip_header_to_t* ret=NULL]
scope { belle_sip_header_to_t* current; }
@init { $header_to::current = belle_sip_header_to_new(); $ret = $header_to::current;}
: to_token /*'To' ( 'To' | 't' )*/ sp_tab_colon to_spec;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_to::current);
$ret=NULL;
}
to_spec
: ( name_addr_with_generic_uri[BELLE_SIP_HEADER_ADDRESS($header_to::current)] | paramless_addr_spec_with_generic_uri[BELLE_SIP_HEADER_ADDRESS($header_to::current)] )
( SEMI lws? to_param lws?)*;
to_param
: /*tag_param |*/ generic_param [BELLE_SIP_PARAMETERS($header_to::current)];
diversion_token: {IS_HEADER_NAMED(Diversion,d)}? token;
header_diversion returns [belle_sip_header_diversion_t* ret=NULL]
scope { belle_sip_header_diversion_t* current; }
@init { $header_diversion::current = belle_sip_header_diversion_new(); $ret = $header_diversion::current;}
: diversion_token /*'Diversion' ( 'Diversion' | 'd' )*/ sp_tab_colon diversion_spec;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_diversion::current);
$ret=NULL;
}
diversion_spec
: ( name_addr_with_generic_uri[BELLE_SIP_HEADER_ADDRESS($header_diversion::current)] | paramless_addr_spec_with_generic_uri[BELLE_SIP_HEADER_ADDRESS($header_diversion::current)] )
( SEMI lws? diversion_param lws?)*;
diversion_param
: /*tag_param |*/ generic_param [BELLE_SIP_PARAMETERS($header_diversion::current)];
refer_to_token: {IS_TOKEN(Refer-To)}? token;
header_refer_to returns [belle_sip_header_refer_to_t* ret=NULL]
: refer_to_token /*'Refer-To'*/
sp_tab_colon
refer_to_spec[BELLE_SIP_HEADER_ADDRESS(belle_sip_header_refer_to_new())] {$ret = BELLE_SIP_HEADER_REFER_TO($refer_to_spec.ret);};
referred_by_token: {IS_TOKEN(Referred-By)}? token;
header_referred_by returns [belle_sip_header_referred_by_t* ret=NULL]
: referred_by_token /*'Referred-By'*/
sp_tab_colon
refer_to_spec[BELLE_SIP_HEADER_ADDRESS(belle_sip_header_referred_by_new())] {$ret = BELLE_SIP_HEADER_REFERRED_BY($refer_to_spec.ret);};
refer_to_spec [belle_sip_header_address_t* address] returns [belle_sip_header_address_t* ret]
@init {$ret=address;}
: (( name_addr[address] | paramless_addr_spec[address]) ( SEMI lws? generic_param [BELLE_SIP_PARAMETERS(address)] lws? )* );
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref(address);
$ret=NULL;
}
/*
unsupported
: 'Unsupported' HCOLON option_tag (COMMA option_tag)*;
*/
header_user_agent returns [belle_sip_header_user_agent_t* ret]
scope { belle_sip_header_user_agent_t* current; }
@init { $header_user_agent::current = belle_sip_header_user_agent_new();$ret = $header_user_agent::current;}
: {IS_TOKEN(User-Agent)}? token /*'User-Agent'*/ hcolon server_val (lws server_val)*;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_user_agent::current);
$ret=NULL;
}
server_val : word {belle_sip_header_user_agent_add_product($header_user_agent::current,(const char*)$word.text->chars); };
/*serval_item
: product | comment ;
product
: token (SLASH product_version)?;
product_version
: token;
*/
via_token: {IS_HEADER_NAMED(Via,v)}? token;
header_via returns [belle_sip_header_via_t* ret]
scope { belle_sip_header_via_t* current; belle_sip_header_via_t* first; }
@init { $header_via::current = NULL;$header_via::first =NULL;$ret = NULL;}
: via_token/* ( 'via' | 'v' )*/ hcolon via_parm (comma via_parm)* {$ret = $header_via::first;} ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
$ret = $header_via::first;
if ($ret) belle_sip_object_unref($ret);
$ret=NULL;
}
via_parm
scope { belle_sip_header_via_t* prev;}
@init { if ($header_via::current == NULL) {
$header_via::first = $header_via::current = belle_sip_header_via_new();
$via_parm::prev=NULL;
} else {
belle_sip_header_t* header;
$via_parm::prev=$header_via::current;
header = BELLE_SIP_HEADER($header_via::current);
belle_sip_header_set_next(header,(belle_sip_header_t*)($header_via::current = belle_sip_header_via_new()));
}
}
: sent_protocol lws sent_by ( semi via_params )*;
via_params
: /*via_ttl | via_maddr
| via_branch
| via_extension */ via_received[$header_via::current] | generic_param [BELLE_SIP_PARAMETERS($header_via::current)];
/*via_ttl
: 'ttl' EQUAL ttl;
via_maddr
: 'maddr' EQUAL host;*/
via_received [belle_sip_header_via_t* object]
: {IS_TOKEN(received)}? token EQUAL via_address {belle_sip_header_via_set_received(object,(const char*)$via_address.text->chars);};
via_address: ipv4address | ipv6address;
/*
via_branch
: 'branch' EQUAL token;
via_extension
: generic_param;*/
sent_protocol
: (protocol_name slash protocol_version) {belle_sip_header_via_set_protocol($header_via::current,(const char*)$text->chars);}
slash transport {belle_sip_header_via_set_transport($header_via::current,(const char*)$transport.text->chars);} ;
protocol_name
: /*'SIP' |*/ token;
protocol_version
: token;
transport
: /* 'UDP' | 'TCP' | 'TLS' | 'SCTP'
| */ other_transport;
other_transport
: token;
sent_by
: host {belle_sip_header_via_set_host($header_via::current,$host.ret);}
( COLON port {belle_sip_header_via_set_port($header_via::current,$port.ret);} )? ;
/*
warning
: 'Warning' HCOLON warning_value (COMMA warning_value)*;
warning_value
: warn_code SP warn_agent SP warn_text;
warn_code
: DIGIT DIGIT DIGIT;
warn_agent
: hostport | pseudonym;
// the name or pseudonym of the server adding
// the Warning header, for use in debugging
warn_text
: quoted_string;
pseudonym
: token;
*/
header_www_authenticate returns [belle_sip_header_www_authenticate_t* ret]
scope { belle_sip_header_www_authenticate_t* current; }
@init { $header_www_authenticate::current = belle_sip_header_www_authenticate_new();$ret = $header_www_authenticate::current; }
: {IS_TOKEN(WWW-Authenticate)}? token /*'WWW-Authenticate'*/ hcolon challenge[$header_www_authenticate::current];
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_www_authenticate::current);
$ret=NULL;
}
state_value: token ;
header_subscription_state returns [belle_sip_header_subscription_state_t* ret]
scope { belle_sip_header_subscription_state_t* current; }
@init { $header_subscription_state::current = belle_sip_header_subscription_state_new();$ret = $header_subscription_state::current; }
: {IS_TOKEN(Subscription-State)}? token /*"Subscription-State"*/
hcolon state_value {belle_sip_header_subscription_state_set_state($header_subscription_state::current,(const char*)$state_value.text->chars);}
(semi generic_param [BELLE_SIP_PARAMETERS($header_subscription_state::current)])* ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_subscription_state::current);
$ret=NULL;
}
header_event returns [belle_sip_header_event_t* ret]
scope { belle_sip_header_event_t* current; }
@init { $header_event::current = belle_sip_header_event_new();$ret = $header_event::current; }
: {IS_TOKEN(Event)}? token /*"Event"*/
hcolon event_package {belle_sip_header_event_set_package_name($header_event::current,(const char*)$event_package.text->chars);}
(semi generic_param [BELLE_SIP_PARAMETERS($header_event::current)])* ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_event::current);
$ret=NULL;
}
event_package
: token;
/*
Replaces = "Replaces" HCOLON replaces-values
*(COMMA replaces-values)
replaces-values = callid *( SEMI replaces-param )
callid = token [ "@" token ]
replaces-param = to-tag | from-tag | extension-param
to-tag = "to-tag" EQUAL ( UUID | "*" )
from-tag = "from-tag" EQUAL UUID
extension-param = token [ EQUAL ( token | quoted-string ) ]
*/
header_replaces returns [belle_sip_header_replaces_t* ret]
scope { belle_sip_header_replaces_t* current; }
@init { $header_replaces::current = belle_sip_header_replaces_new();$ret = $header_replaces::current; }
: {IS_TOKEN(Replaces)}? token /*"Replaces"*/
hcolon call_id {belle_sip_header_replaces_set_call_id($header_replaces::current,(const char*)$call_id.text->chars);}
(semi generic_param [BELLE_SIP_PARAMETERS($header_replaces::current)])* ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_replaces::current);
$ret=NULL;
}
//**********************************Privacy*******************************//
header_p_preferred_identity returns [belle_sip_header_p_preferred_identity_t* ret]
@init { $ret=NULL; }
: {IS_TOKEN(P-Preferred-Identity)}? token /*"P-Preferred-Identity"*/
sp_tab_colon header_address_base[(belle_sip_header_address_t*)belle_sip_header_p_preferred_identity_new()] {$ret=(belle_sip_header_p_preferred_identity_t*)$header_address_base.ret;};
header_privacy returns [belle_sip_header_privacy_t* ret]
scope { belle_sip_header_privacy_t* current; }
@init { $header_privacy::current = belle_sip_header_privacy_new();$ret = $header_privacy::current;}
: {IS_TOKEN(Privacy)}? token /*'Privacy'*/ hcolon privacy_val (semi privacy_val)*;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($ret);
$ret=NULL;
}
privacy_val: token {belle_sip_header_privacy_add_privacy($header_privacy::current,(const char*)$token.text->chars);};
//**********************************Supported*******************************//
header_supported returns [belle_sip_header_supported_t* ret]
scope { belle_sip_header_supported_t* current; }
@init { $header_supported::current = belle_sip_header_supported_new();$ret = $header_supported::current;}
: {IS_TOKEN(Supported)}? token /*'Supported'*/ hcolon supported_val (comma supported_val)*;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($ret);
$ret=NULL;
}
supported_val: token {belle_sip_header_supported_add_supported($header_supported::current,(const char*)$token.text->chars);};
//**********************************Content-Disposition*******************************//
content_disposition_value: token ;
header_content_disposition returns [belle_sip_header_content_disposition_t* ret]
scope { belle_sip_header_content_disposition_t* current; }
@init { $header_content_disposition::current = belle_sip_header_content_disposition_new();$ret = $header_content_disposition::current; }
: {IS_TOKEN(Content-Disposition)}? token /*"Content-Disposition"*/
hcolon content_disposition_value {belle_sip_header_content_disposition_set_content_disposition($header_content_disposition::current,(const char*)$content_disposition_value.text->chars);}
(semi generic_param [BELLE_SIP_PARAMETERS($header_content_disposition::current)])* ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_content_disposition::current);
$ret=NULL;
}
//**********************************Accept*******************************//
accept_token : {IS_TOKEN(Accept)}? token;
header_accept returns [belle_sip_header_accept_t* ret=NULL]
scope { belle_sip_header_accept_t* current; belle_sip_header_accept_t* first; }
@init { $header_accept::current = NULL;$header_accept::first =NULL;$ret = NULL;}
: accept_token/* ( 'Accept')*/ hcolon accept_param (comma accept_param)* {$ret = $header_accept::first;} ;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
$ret = $header_accept::first;
if ($ret) belle_sip_object_unref($ret);
$ret=NULL;
}
accept_param
scope { belle_sip_header_accept_t* prev;}
@init { if ($header_accept::current == NULL) {
$header_accept::first = $header_accept::current = belle_sip_header_accept_new();
$accept_param::prev=NULL;
} else {
belle_sip_header_t* header;
$accept_param::prev=$header_accept::current;
header = BELLE_SIP_HEADER($header_accept::current);
belle_sip_header_set_next(header,(belle_sip_header_t*)($header_accept::current = belle_sip_header_accept_new()));
}
}
: accept_main_media_type {belle_sip_header_accept_set_type($header_accept::current,(const char*)$accept_main_media_type.text->chars);}
slash
accept_sub_media_type {belle_sip_header_accept_set_subtype($header_accept::current,(const char*)$accept_sub_media_type.text->chars);}
(semi generic_param [BELLE_SIP_PARAMETERS($header_accept::current)])*;
accept_main_media_type: token;
accept_sub_media_type: token;
//****************************Reason***********************************//
/*
Reason = "Reason" HCOLON reason-value *(COMMA reason-value)
reason-value = protocol *(SEMI reason-params)
protocol = "SIP" / "Q.850" / token
reason-params = protocol-cause / reason-text
/ reason-extension
protocol-cause = "cause" EQUAL cause
cause = 1*DIGIT
reason-text = "text" EQUAL quoted-string
reason-extension = generic-param
*/
header_reason returns [belle_sip_header_reason_t* ret=NULL]
scope { belle_sip_header_reason_t* current;belle_sip_header_reason_t* first; }
@init { $header_reason::current = NULL; $header_reason::first =NULL;}
: {IS_TOKEN(Reason)}? token /*'Reason'*/ hcolon header_reason_param ( comma header_reason_param)* {$ret = $header_reason::first; };
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
$ret = $header_reason::first;
if ($ret) belle_sip_object_unref($ret);
$ret=NULL;
}
header_reason_param
scope { belle_sip_header_reason_t* prev;}
@init { if ($header_reason::current == NULL) {
$header_reason::first = $header_reason::current = belle_sip_header_reason_new();
$header_reason_param::prev=NULL;
} else {
belle_sip_header_t* header = BELLE_SIP_HEADER($header_reason::current);
$header_reason_param::prev=$header_reason::current;
belle_sip_header_set_next(header,(belle_sip_header_t*)($header_reason::current = belle_sip_header_reason_new()));
}
}
:header_reason_protocol {belle_sip_header_reason_set_protocol($header_reason::current,(const char*)$header_reason_protocol.text->chars);}
(semi generic_param [BELLE_SIP_PARAMETERS($header_reason::current)])*;
header_reason_protocol
: token;
//*********************************************//
/*
AuthenticationInfo = "Authentication-Info" ":" auth-info
auth-info = 1#(nextnonce | [ message-qop ]
| [ response-auth ] | [ cnonce ]
| [nonce-count] )
nextnonce = "nextnonce" "=" nonce-value
response-auth = "rspauth" "=" response-digest
response-digest = <"> *LHEX <">
*/
header_authentication_info returns [belle_sip_header_authentication_info_t* ret=NULL]
scope { belle_sip_header_authentication_info_t* current; }
@init {$header_authentication_info::current = belle_sip_header_authentication_info_new(); $ret=$header_authentication_info::current; }
: {IS_TOKEN( Authentication-Info)}? token /*' Authentication-Info'*/ hcolon auth_info ( comma auth_info)*;
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($header_authentication_info::current);
$ret=NULL;
}
auth_info
:
( next_nonce { belle_sip_header_authentication_info_set_next_nonce($header_authentication_info::current,(char*)$next_nonce.ret);
belle_sip_free($next_nonce.ret);
}
|cnonce{
belle_sip_header_authentication_info_set_cnonce($header_authentication_info::current,(char*)$cnonce.ret);
belle_sip_free($cnonce.ret);
}
| authentication_info_message_qop{
belle_sip_header_authentication_info_set_qop($header_authentication_info::current,$authentication_info_message_qop.ret);
}
|nonce_count{
belle_sip_header_authentication_info_set_nonce_count($header_authentication_info::current,atoi((char*)$nonce_count.ret));
}
|rspauth {
belle_sip_header_authentication_info_set_rsp_auth($header_authentication_info::current,$rspauth.ret);
belle_sip_free($rspauth.ret);
}) ;
qop_token
: {IS_TOKEN(qop)}? token/*'qop'*/;
/*as defined by 3261*/
authentication_info_message_qop returns [const char* ret=NULL]
: qop_token equal token { $ret = (const char*)$token.text->chars;};
rspauth returns [char* ret=NULL]
: {IS_TOKEN(rspauth)}? token /*'nonce'*/ equal quoted_string{
$ret = _belle_sip_str_dup_and_unquote_string((char*)$quoted_string.text->chars);
};
next_nonce returns [char* ret=NULL]
: {IS_TOKEN(nextnonce)}? token /*'nonce'*/ equal nonce_value{
$ret = _belle_sip_str_dup_and_unquote_string((char*)$nonce_value.text->chars);
};
quoted_algorithm returns [char* ret=NULL]
: {IS_TOKEN(nextnonce)}? token /*'nonce'*/ equal nonce_value{
$ret = _belle_sip_str_dup_and_unquote_string((char*)$nonce_value.text->chars);
};
//**********************************************//
header returns [belle_sip_header_t* ret=NULL]
: header_extension_base[FALSE] {$ret=$header_extension_base.ret;};
//********************************************************************************************//
header_extension_base[ANTLR3_BOOLEAN is_http] returns [belle_sip_header_t* ret]
scope {int as_value;}
@init {$header_extension_base::as_value=0;$ret=NULL;}
: (header_name
hcolon /*sp_tab_colon*/ /*because LWS can be in both colon or header_value*/
(header_value[(const char*)$header_name.text->chars,$is_http ]{$header_extension_base::as_value=1;$ret=$header_value.ret;})?) {
if (!$ret && !$header_extension_base::as_value) { /*to handle value parsing error*/
/*special case: header without value*/
$ret=belle_sip_header_create((const char*)$header_name.text->chars,NULL);
}
};
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
if ($ret) belle_sip_object_unref($ret);
$ret=NULL;
}
header_name
: token;
header_value[const char* name, ANTLR3_BOOLEAN is_http] returns [belle_sip_header_t* ret]
options { greedy = false; }
@init {$ret=NULL;}
: (~(SP|CRLF) ((CRLF SP) | ~CRLF)* ) {
if ($is_http) {
$ret=belle_http_header_create($name,(const char*)$header_value.text->chars);
}else {
$ret=belle_sip_header_create($name,(const char*)$header_value.text->chars);
}
} ;
message_body
options { greedy = false; }
: OCTET+;
paramless_uri returns [belle_sip_uri_t* ret=NULL]
scope { belle_sip_uri_t* current; }
@init { $paramless_uri::current = belle_sip_uri_new(); }
: sip_schema[$paramless_uri::current] ( (userinfo[$paramless_uri::current]) =>(userinfo[$paramless_uri::current] hostport[$paramless_uri::current]) | hostport[$paramless_uri::current])
headers[$paramless_uri::current]? {$ret = $paramless_uri::current;};
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($paramless_uri::current);
$ret=NULL;
}
uri returns [belle_sip_uri_t* ret=NULL]
scope { belle_sip_uri_t* current; }
@init { $uri::current = belle_sip_uri_new(); }
: sip_schema[$uri::current] ( ((userinfo[NULL])=>userinfo[$uri::current] hostport[$uri::current]) | hostport[$uri::current] )
uri_parameters[$uri::current]?
headers[$uri::current]? {$ret = $uri::current;};
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($uri::current);
$ret=NULL;
}
fast_uri returns [belle_sip_uri_t* ret=NULL]
scope { belle_sip_uri_t* current; }
@init { $fast_uri::current = belle_sip_uri_new(); }
: sip_schema[$fast_uri::current] ( ((userinfo[NULL])=>userinfo[$fast_uri::current] fast_hostport[$fast_uri::current]) | fast_hostport[$fast_uri::current] )
uri_parameters[$fast_uri::current]?
headers[$fast_uri::current]? {$ret = $fast_uri::current;};
catch [ANTLR3_RECOGNITION_EXCEPTION]
{
belle_sip_message("[\%s] reason [\%s]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message);
belle_sip_object_unref($fast_uri::current);
$ret=NULL;
}
sip_token: {IS_TOKEN(sip)}? token;
sips_token: {IS_TOKEN(sips)}? token;
sip_schema[belle_sip_uri_t* uri] : (sips_token {belle_sip_uri_set_secure(uri,1);}
| sip_token) COLON ;
userinfo[belle_sip_uri_t* uri]
scope { belle_sip_uri_t* current; }
@init {$userinfo::current=uri;}
: user ( COLON password )? AT;
user : ( unreserved | escaped | user_unreserved )+ {
char* unescaped_username;
unescaped_username=belle_sip_to_unescaped_string((const char *)$text->chars);
belle_sip_uri_set_user($userinfo::current,unescaped_username);
belle_sip_free(unescaped_username);
};
password : ( unreserved | escaped |AND | EQUAL | PLUS | DOLLARD | COMMA )* {
char* unescaped_userpasswd;
const char* source = (const char*)$text->chars;
if( source != NULL ){
unescaped_userpasswd=belle_sip_to_unescaped_string((const char *)source);
belle_sip_uri_set_user_password($userinfo::current,unescaped_userpasswd);
belle_sip_free(unescaped_userpasswd);
}
};
hostport[belle_sip_uri_t* uri]
scope { belle_sip_uri_t* current; }
@init {$hostport::current=uri;}
: host ( COLON port {belle_sip_uri_set_port($hostport::current,$port.ret);})? {belle_sip_uri_set_host($hostport::current,$host.ret);};
fast_hostport[belle_sip_uri_t* uri]
scope { belle_sip_uri_t* current; }
@init {$fast_hostport::current=uri;}
: fast_host ( COLON port {belle_sip_uri_set_port($fast_hostport::current,$port.ret);})? {belle_sip_uri_set_host($fast_hostport::current,$fast_host.ret);};
uri_parameters[belle_sip_uri_t* uri]
scope { belle_sip_uri_t* current; }
@init {$uri_parameters::current=uri;}
: ( (semi uri_parameter)|(lws? SEMI) )+; /*allow semi only teven if not in the rfc*/
uri_parameter //all parameters are considered as other
: other_param ;
other_param
: pname {
char* unescaped_parameters = belle_sip_to_unescaped_string((const char *) $pname.text->chars);
belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS($uri_parameters::current)
,unescaped_parameters
,NULL);
belle_sip_free(unescaped_parameters);
}
|
(pname EQUAL pvalue) {
char* unescaped_pname = belle_sip_to_unescaped_string((const char *) $pname.text->chars);
char* unescaped_pvalue = belle_sip_to_unescaped_string((const char *) $pvalue.text->chars);
belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS($uri_parameters::current)
,unescaped_pname
,unescaped_pvalue);
belle_sip_free(unescaped_pname);
belle_sip_free(unescaped_pvalue);
}
;
pname
: paramchar+;
pvalue
: paramchar+;
paramchar
: (param_unreserved)=>param_unreserved | unreserved | escaped;
param_unreserved
: LSBRAQUET | RSBRAQUET | SLASH | COLON | AND | PLUS | DOLLARD | DOT;
headers[belle_sip_uri_t* uri]
scope { belle_sip_uri_t* current; int is_hvalue; }
@init {$headers::current=uri; $headers::is_hvalue=0;}
: QMARK uri_header ( AND uri_header )* ;
uri_header
scope {int is_hvalue; }
@init {$uri_header::is_hvalue=0;}
: hname EQUAL (hvalue{$uri_header::is_hvalue = 1;})? {
char* unescaped_hname = belle_sip_to_unescaped_string((const char *)$hname.text->chars);
char* unescaped_hvalue = ($uri_header::is_hvalue)?belle_sip_to_unescaped_string((const char *)$hvalue.text->chars):NULL;
belle_sip_uri_set_header($headers::current,unescaped_hname,unescaped_hvalue);
belle_sip_free(unescaped_hname);
if (unescaped_hvalue) belle_sip_free(unescaped_hvalue);
};
hname : ( hnv_unreserved | unreserved | escaped )+;
hvalue : ( hnv_unreserved | unreserved | escaped )+;
/*hnv-unreserved = "[" / "]" / "/" / "?" / ":" / "+" / "$"*/
hnv_unreserved : LSBRAQUET | RSBRAQUET | SLASH | QMARK | COLON | PLUS | DOLLARD ;
fast_host returns [const char* ret]
scope { const char* current; }
@init {$fast_host::current=$ret=NULL;}
: (fast_hostname {$fast_host::current=(const char *)$fast_hostname.text->chars;}
/*| ipv4address {$fast_host::current=(const char *)$ipv4address.text->chars;} because cannot discriminate quickly betwenn 192.168.0.1 and 192.168.0.com*/
| ipv6reference {$fast_host::current=(const char *)$ipv6reference.ret;}) {$ret=$fast_host::current;};
fast_hostname: alphanum ( alphanum | DASH | DOT )*;
//*************************common tokens*******************************/
user_unreserved : AND | EQUAL | PLUS | DOLLARD | COMMA | SEMI | QMARK | SLASH;
host returns [const char* ret]
scope { const char* current; }
@init {$host::current=$ret=NULL;}
: (hostname {$host::current=(const char *)$hostname.text->chars;}
| ipv4address {$host::current=(const char *)$ipv4address.text->chars;}
| ipv6reference {$host::current=(const char *)$ipv6reference.ret;}) {$ret=$host::current;};
hostname : ( domainlabel DOT )* (toplabel)=>toplabel DOT? ;
domainlabel : alphanum | (alphanum ( alphanum | DASH )* alphanum) ;
toplabel : alpha | (alpha ( DASH? alphanum)+) ;
ipv4address : three_digit DOT three_digit DOT three_digit DOT three_digit ;
ipv6reference returns [const char* ret=NULL] : LSBRAQUET ipv6address RSBRAQUET {$ret=(const char *)$ipv6address.text->chars;};
ipv6address : hexpart ( COLON ipv4address )? ;
hexpart : hexseq | hexseq COLON COLON ( hexseq )? | COLON COLON ( hexseq )?;
hexseq : hex4 ( COLON hex4)*;
hex4 : hexdigit+;/* hexdigit hexdigit hexdigit ;*/
port returns [int ret]
@init {$ret=-1;}
: DIGIT+ { $ret=atoi((const char *)$text->chars); };
escaped : PERCENT hexdigit hexdigit;
ttl : three_digit;
three_digit: (DIGIT) => DIGIT
|
(DIGIT DIGIT) => (DIGIT DIGIT)
|
(DIGIT DIGIT DIGIT) =>(DIGIT DIGIT DIGIT) ;
token
: (alphanum | mark | PERCENT | PLUS | BQUOTE )+;
reserved_for_from_to_contact_addr_spec:
COLON | AT | AND | EQUAL | PLUS | DOLLARD | SLASH;
reserved
: SEMI | COMMA | QMARK | reserved_for_from_to_contact_addr_spec ;
unreserved : alphanum |mark;
alphanum : alpha | DIGIT ;
hexdigit
: HEX_CHAR|DIGIT;
alpha : HEX_CHAR | COMMON_CHAR;
word
: (alphanum | mark | PERCENT
| PLUS | BQUOTE |
LAQUOT | RAQUOT |
COLON | BSLASH | DQUOTE | SLASH | LSBRAQUET | RSBRAQUET | QMARK | LBRACE | RBRACE )+;
mark : DASH | USCORE | DOT | EMARK | TILDE | STAR | SQUOTE | LPAREN | RPAREN ;
sp_tab_colon
:( SP | HTAB )* COLON ;
hcolon : sp_tab_colon lws? //SWS;
;//|( SP | HTAB )* COLON LWS+;
ldquot : lws? DQUOTE ;
rdquot : DQUOTE lws?;
semi: lws? SEMI lws?;
comma : lws? COMMA lws?;
sp_laquot
: lws? LAQUOT ;
raquot_sp
: RAQUOT lws?;
equal:
lws? EQUAL lws?;
slash : lws? SLASH lws?;
lws : (SP* CRLF SP+) | SP+ ; //linear whitespace
//*************************************common tokens*****************/
COMMON_CHAR
: 'g'..'z' | 'G'..'Z' ;
HEX_CHAR: 'a'..'f' |'A'..'F';
DIGIT : '0'..'9' ;
AT: '@';
AND: '&';
DOLLARD: '$';
QMARK: '?';
EMARK: '!';
DASH: '-';
CRLF : '\r\n' { USER1 = (int)((char*)ctx->pLexer->input->currentLine - (char*)ctx->pLexer->input->data); /*GETCHARINDEX()*/;};
HTAB : ' ';
OR : '|';
PERCENT: '%';
DQUOTE : '"';
SQUOTE : '\'';
BQUOTE: '`';
BSLASH: '\\';
LBRACE: '{';
RBRACE: '}';
USCORE: '_';
TILDE: '~';
DOT: '.';
PLUS: '+';
COLON
: ':'
;
SEMI
: ';'
;
COMMA
: ','
;
LAQUOT
: '<'
;
RAQUOT
: '>'
;
RPAREN
: ')'
;
LPAREN
: '('
;
RSBRAQUET
: ']'
;
LSBRAQUET
: '['
;
EQUAL
: '='
;
SLASH
: '/'
;
STAR
: '*'
;
SP
: ' '
;
OCTET : . ;
belle-sip-1.6.3/src/http-listener.c 0000664 0000000 0000000 00000006322 13134375224 0017141 0 ustar 00root root 0000000 0000000 /*
belle-sip - SIP (RFC3261) library.
Copyright (C) 2013 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 .
*/
#include "belle_sip_internal.h"
typedef struct belle_http_callbacks belle_http_callbacks_t;
struct belle_http_callbacks{
belle_sip_object_t base;
belle_http_request_listener_callbacks_t cbs;
void *user_ctx;
};
static void process_response_headers(belle_http_request_listener_t *l, const belle_http_response_event_t *event){
belle_http_callbacks_t *obj=(belle_http_callbacks_t*)l;
if (obj->cbs.process_response_headers)
obj->cbs.process_response_headers(obj->user_ctx,event);
}
static void process_response_event(belle_http_request_listener_t *l, const belle_http_response_event_t *event){
belle_http_callbacks_t *obj=(belle_http_callbacks_t*)l;
if (obj->cbs.process_response)
obj->cbs.process_response(obj->user_ctx,event);
}
static void process_io_error(belle_http_request_listener_t *l, const belle_sip_io_error_event_t *event){
belle_http_callbacks_t *obj=(belle_http_callbacks_t*)l;
if (obj->cbs.process_io_error)
obj->cbs.process_io_error(obj->user_ctx,event);
}
static void process_timeout(belle_http_request_listener_t *l, const belle_sip_timeout_event_t *event){
belle_http_callbacks_t *obj=(belle_http_callbacks_t*)l;
if (obj->cbs.process_timeout)
obj->cbs.process_timeout(obj->user_ctx,event);
}
static void process_auth_requested(belle_http_request_listener_t *l, belle_sip_auth_event_t *event){
belle_http_callbacks_t *obj=(belle_http_callbacks_t*)l;
if (obj->cbs.process_auth_requested)
obj->cbs.process_auth_requested(obj->user_ctx,event);
}
/*BELLE_SIP_DECLARE_VPTR(belle_http_callbacks_t);*/
BELLE_SIP_IMPLEMENT_INTERFACE_BEGIN(belle_http_callbacks_t,belle_http_request_listener_t)
process_response_headers,
process_response_event,
process_io_error,
process_timeout,
process_auth_requested
BELLE_SIP_IMPLEMENT_INTERFACE_END
BELLE_SIP_DECLARE_IMPLEMENTED_INTERFACES_1(belle_http_callbacks_t,belle_http_request_listener_t);
static void belle_http_callbacks_destroy(belle_http_callbacks_t *obj){
if (obj->cbs.listener_destroyed)
obj->cbs.listener_destroyed(obj->user_ctx);
}
BELLE_SIP_INSTANCIATE_VPTR(belle_http_callbacks_t,belle_sip_object_t,belle_http_callbacks_destroy,NULL,NULL,FALSE);
belle_http_request_listener_t *belle_http_request_listener_create_from_callbacks(const belle_http_request_listener_callbacks_t *callbacks, void *user_ctx){
belle_http_callbacks_t *obj=belle_sip_object_new(belle_http_callbacks_t);
memcpy(&obj->cbs,callbacks,sizeof(belle_http_request_listener_callbacks_t));
obj->user_ctx=user_ctx;
return BELLE_HTTP_REQUEST_LISTENER(obj);
}
belle-sip-1.6.3/src/http-message.c 0000664 0000000 0000000 00000014351 13134375224 0016741 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 .
*/
#include "grammars/belle_sip_messageLexer.h"
#include "grammars/belle_sip_messageParser.h"
#include "belle_sip_internal.h"
static void belle_http_request_init(belle_http_request_t *req){
/*nop*/
}
static void belle_http_request_listener_destroyed(belle_http_request_t *req){
req->listener=NULL;
}
static void belle_http_request_destroy(belle_http_request_t *req){
if (req->req_uri) belle_sip_object_unref(req->req_uri);
DESTROY_STRING(req,method)
belle_http_request_set_listener(req,NULL);
belle_http_request_set_channel(req,NULL);
SET_OBJECT_PROPERTY(req,orig_uri,NULL);
SET_OBJECT_PROPERTY(req,response,NULL);
}
static void belle_http_request_clone(belle_http_request_t *obj, const belle_http_request_t *orig){
if (orig->req_uri) obj->req_uri=(belle_generic_uri_t*)belle_sip_object_clone((belle_sip_object_t*)orig->req_uri);
CLONE_STRING(belle_http_request,method,obj,orig)
}
static belle_sip_error_code belle_http_request_marshal(const belle_http_request_t* request, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_snprintf(buff,buff_size,offset,"%s ",belle_http_request_get_method(request));
if (error!=BELLE_SIP_OK) return error;
error=belle_generic_uri_marshal(belle_http_request_get_uri(request),buff,buff_size,offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset," %s","HTTP/1.1\r\n");
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_headers_marshal(BELLE_SIP_MESSAGE(request),buff,buff_size,offset);
if (error!=BELLE_SIP_OK) return error;
return error;
}
GET_SET_STRING(belle_http_request,method);
BELLE_NEW(belle_http_request,belle_sip_message)
BELLE_PARSE(belle_sip_messageParser,belle_,http_request)
belle_http_request_t *belle_http_request_create(const char *method, belle_generic_uri_t *url, ...){
va_list vl;
belle_http_request_t *obj;
belle_sip_header_t *header;
if (belle_generic_uri_get_host(url) == NULL) {
belle_sip_error("%s: NULL host in url", __FUNCTION__);
return NULL;
}
obj=belle_http_request_new();
obj->method=belle_sip_strdup(method);
obj->req_uri=(belle_generic_uri_t*)belle_sip_object_ref(url);
va_start(vl,url);
while((header=va_arg(vl,belle_sip_header_t*))!=NULL){
belle_sip_message_add_header(BELLE_SIP_MESSAGE(obj),header);
}
va_end(vl);
return obj;
}
int belle_http_request_is_cancelled(const belle_http_request_t *req) {
return req->cancelled;
}
void belle_http_request_cancel(belle_http_request_t *req) {
req->cancelled = TRUE;
}
void belle_http_request_set_listener(belle_http_request_t *req, belle_http_request_listener_t *l){
if (req->listener){
belle_sip_object_weak_unref(req->listener,(belle_sip_object_destroy_notify_t)belle_http_request_listener_destroyed,req);
req->listener=NULL;
}
if (l){
belle_sip_object_weak_ref(l,(belle_sip_object_destroy_notify_t)belle_http_request_listener_destroyed,req);
req->listener=l;
}
}
static void notify_http_request_of_channel_destruction(belle_http_request_t *obj, belle_sip_channel_t *chan_being_destroyed){
obj->channel=NULL;
}
void belle_http_request_set_channel(belle_http_request_t *req, belle_sip_channel_t* chan){
if (req->channel){
belle_sip_object_weak_unref(req->channel, (belle_sip_object_destroy_notify_t)notify_http_request_of_channel_destruction, req);
req->channel=NULL;
}
if (chan){
belle_sip_object_weak_ref(chan, (belle_sip_object_destroy_notify_t)notify_http_request_of_channel_destruction, req);
req->channel=chan;
}
}
belle_http_request_listener_t * belle_http_request_get_listener(const belle_http_request_t *req){
return req->listener;
}
belle_generic_uri_t *belle_http_request_get_uri(const belle_http_request_t *req){
return req->req_uri;
}
void belle_http_request_set_uri(belle_http_request_t* request, belle_generic_uri_t* uri) {
SET_OBJECT_PROPERTY(request,req_uri,uri);
}
void belle_http_request_set_response(belle_http_request_t *req, belle_http_response_t *resp){
SET_OBJECT_PROPERTY(req,response,resp);
}
belle_http_response_t *belle_http_request_get_response(belle_http_request_t *req){
return req->response;
}
/*response*/
struct belle_http_response{
belle_sip_message_t base;
char *http_version;
int status_code;
char *reason_phrase;
};
void belle_http_response_destroy(belle_http_response_t *resp){
if (resp->http_version) belle_sip_free(resp->http_version);
if (resp->reason_phrase) belle_sip_free(resp->reason_phrase);
}
static void belle_http_response_init(belle_http_response_t *resp){
}
static void belle_http_response_clone(belle_http_response_t *resp, const belle_http_response_t *orig){
if (orig->http_version) resp->http_version=belle_sip_strdup(orig->http_version);
resp->status_code=orig->status_code;
if (orig->reason_phrase) resp->reason_phrase=belle_sip_strdup(orig->reason_phrase);
}
belle_sip_error_code belle_http_response_marshal(belle_http_response_t *resp, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_snprintf( buff
,buff_size
,offset
,"HTTP/1.1 %i %s\r\n"
,belle_http_response_get_status_code(resp)
,belle_http_response_get_reason_phrase(resp)?belle_http_response_get_reason_phrase(resp):"");
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_headers_marshal(BELLE_SIP_MESSAGE(resp),buff,buff_size,offset);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_NEW(belle_http_response,belle_sip_message)
BELLE_PARSE(belle_sip_messageParser,belle_,http_response)
GET_SET_STRING(belle_http_response,reason_phrase);
GET_SET_INT(belle_http_response,status_code,int)
belle-sip-1.6.3/src/http-provider.c 0000664 0000000 0000000 00000050667 13134375224 0017161 0 ustar 00root root 0000000 0000000 /*
belle-sip - SIP (RFC3261) library.
Copyright (C) 2013 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 .
*/
#include
#include "belle_sip_internal.h"
typedef struct belle_http_channel_context belle_http_channel_context_t;
#define BELLE_HTTP_CHANNEL_CONTEXT(obj) BELLE_SIP_CAST(obj,belle_http_channel_context_t)
static void provider_remove_channel(belle_http_provider_t *obj, belle_sip_channel_t *chan);
struct belle_http_channel_context{
belle_sip_object_t base;
belle_http_provider_t *provider;
belle_sip_list_t *pending_requests;
};
struct belle_http_provider{
belle_sip_object_t base;
belle_sip_stack_t *stack;
char *bind_ip;
int ai_family;
belle_sip_list_t *tcp_channels;
belle_sip_list_t *tls_channels;
belle_tls_crypto_config_t *crypto_config;
};
#define BELLE_HTTP_REQUEST_INVOKE_LISTENER(obj,method,arg) \
obj->listener ? BELLE_SIP_INVOKE_LISTENER_ARG(obj->listener,belle_http_request_listener_t,method,arg) : 0
static int http_channel_context_handle_authentication(belle_http_channel_context_t *ctx, belle_http_request_t *req){
const char *realm=NULL;
belle_sip_auth_event_t *ev=NULL;
belle_http_response_t *resp=belle_http_request_get_response(req);
const char *username=NULL;
const char *passwd=NULL;
const char *ha1=NULL;
char computed_ha1[33];
belle_sip_header_www_authenticate_t* authenticate;
int ret=0;
if (req->auth_attempt_count>1){
req->auth_attempt_count=0;
return -1;
}
if (resp == NULL ) {
belle_sip_error("Missing response for req [%p], cannot authenticate", req);
return -1;
}
if (!(authenticate = belle_sip_message_get_header_by_type(resp,belle_sip_header_www_authenticate_t))) {
if (belle_sip_message_get_header_by_type(resp,belle_sip_header_proxy_authenticate_t)) {
belle_sip_error("Proxy authentication not supported yet, cannot authenticate for resp [%p]", resp);
}
belle_sip_error("Missing auth header in response [%p], cannot authenticate", resp);
return -1;
}
if (strcasecmp("Digest",belle_sip_header_www_authenticate_get_scheme(authenticate)) != 0) {
belle_sip_error("Unsupported auth scheme [%s] in response [%p], cannot authenticate", belle_sip_header_www_authenticate_get_scheme(authenticate),resp);
return -1;
}
/*find if username, passwd were already supplied in original request uri*/
if (req->orig_uri){
username=belle_generic_uri_get_user(req->orig_uri);
passwd=belle_generic_uri_get_user_password(req->orig_uri);
}
realm = belle_sip_header_www_authenticate_get_realm(authenticate);
if (!username || !passwd) {
ev=belle_sip_auth_event_create((belle_sip_object_t*)ctx->provider,realm,NULL);
BELLE_HTTP_REQUEST_INVOKE_LISTENER(req,process_auth_requested,ev);
username=ev->username;
passwd=ev->passwd;
ha1=ev->ha1;
}
if (!ha1 && username && passwd) {
belle_sip_auth_helper_compute_ha1(username,realm,passwd, computed_ha1);
ha1=computed_ha1;
} else if (!ha1){
belle_sip_error("No auth info found for request [%p], cannot authenticate",req);
ret=-1;
}
if (ha1) {
belle_http_header_authorization_t* authorization;
req->auth_attempt_count++;
authorization = belle_http_auth_helper_create_authorization(authenticate);
/*select first qop mode*/
belle_sip_header_authorization_set_qop(BELLE_SIP_HEADER_AUTHORIZATION(authorization),belle_sip_header_www_authenticate_get_qop_first(authenticate));
belle_sip_header_authorization_set_nonce_count(BELLE_SIP_HEADER_AUTHORIZATION(authorization),1); /*we don't store nonce count for now*/
belle_sip_header_authorization_set_username(BELLE_SIP_HEADER_AUTHORIZATION(authorization),username);
belle_http_header_authorization_set_uri(authorization,belle_http_request_get_uri(req));
if (belle_sip_auth_helper_fill_authorization(BELLE_SIP_HEADER_AUTHORIZATION(authorization),belle_http_request_get_method(req),ha1)) {
belle_sip_error("Cannot fill auth header for request [%p]",req);
if (authorization) belle_sip_object_unref(authorization);
ret=-1;
} else {
belle_sip_message_remove_header(BELLE_SIP_MESSAGE(req),BELLE_HTTP_AUTHORIZATION);
belle_sip_message_add_header(BELLE_SIP_MESSAGE(req),BELLE_SIP_HEADER(authorization));
belle_http_provider_send_request(ctx->provider,req,NULL);
}
}
if (ev) belle_sip_auth_event_destroy(ev);
return ret;
}
static void http_channel_context_handle_response_headers(belle_http_channel_context_t *ctx , belle_sip_channel_t *chan, belle_http_response_t *response){
belle_http_request_t *req=ctx->pending_requests ? (belle_http_request_t*) ctx->pending_requests->data : NULL;
belle_http_response_event_t ev={0};
int code;
if (req==NULL){
belle_sip_error("Receiving http response headers not matching any request.");
return;
}
if (belle_http_request_is_cancelled(req)) {
belle_sip_warning("Receiving http response headers for a cancelled request.");
return;
}
code=belle_http_response_get_status_code(response);
if (code!=401 && code!=407){
/*else notify the app about the response headers received*/
ev.source=(belle_sip_object_t*)ctx->provider;
ev.request=req;
ev.response=response;
BELLE_HTTP_REQUEST_INVOKE_LISTENER(req,process_response_headers,&ev);
}
}
static void http_channel_context_handle_response(belle_http_channel_context_t *ctx , belle_sip_channel_t *chan, belle_http_response_t *response){
belle_http_request_t *req=NULL;
belle_http_response_event_t ev={0};
int code;
belle_sip_header_t *connection;
/*pop the request matching this response*/
ctx->pending_requests=belle_sip_list_pop_front(ctx->pending_requests,(void**)&req);
if (req==NULL){
belle_sip_error("Receiving http response not matching any request.");
return;
}
if (belle_http_request_is_cancelled(req)) {
belle_sip_warning("Receiving http response for a cancelled request.");
return;
}
connection=belle_sip_message_get_header((belle_sip_message_t *)response,"Connection");
if (connection && strstr(belle_sip_header_get_unparsed_value(connection),"close")!=NULL)
chan->about_to_be_closed=TRUE;
belle_http_request_set_response(req,response);
code=belle_http_response_get_status_code(response);
if ((code==401 || code==407) && http_channel_context_handle_authentication(ctx,req)==0 ){
/*nothing to do, the request has been resubmitted with authentication*/
}else{
/*else notify the app about the response received*/
ev.source=(belle_sip_object_t*)ctx->provider;
ev.request=req;
ev.response=response;
BELLE_HTTP_REQUEST_INVOKE_LISTENER(req,process_response,&ev);
if( req->background_task_id ){
belle_sip_warning("HTTP request finished: ending bg task id=[%x]", req->background_task_id);
belle_sip_end_background_task(req->background_task_id);
req->background_task_id = 0;
}
}
belle_sip_object_unref(req);
}
static void http_channel_context_handle_io_error(belle_http_channel_context_t *ctx, belle_sip_channel_t *chan){
belle_http_request_t *req=NULL;
belle_sip_io_error_event_t ev={0};
belle_sip_list_t *elem;
/*if the error happens before attempting to send the message, the pending_requests is empty*/
if (ctx->pending_requests==NULL) elem=chan->outgoing_messages;
else elem=ctx->pending_requests;
/*pop the requests for which this error is reported*/
for(;elem!=NULL;elem=elem->next){
req=(belle_http_request_t *)elem->data;
/*else notify the app about the response received*/
/*TODO: would be nice to put the message in the event*/
ev.source=(belle_sip_object_t*)ctx->provider;
ev.host=chan->peer_cname;
ev.port=chan->peer_port;
ev.transport=belle_sip_channel_get_transport_name(chan);
BELLE_HTTP_REQUEST_INVOKE_LISTENER(req,process_io_error,&ev);
if( req->background_task_id ){
belle_sip_warning("IO Error on HTTP request: ending bg task id=[%x]", req->background_task_id);
belle_sip_end_background_task(req->background_task_id);
req->background_task_id = 0;
}
}
}
/* we are called here by the channel when receiving a message for which a body is expected.
* We can notify the application so that it can setup an appropriate body handler.
*/
static void channel_on_message_headers(belle_sip_channel_listener_t *obj, belle_sip_channel_t *chan, belle_sip_message_t *msg){
belle_http_channel_context_t *ctx=BELLE_HTTP_CHANNEL_CONTEXT(obj);
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(msg,belle_http_response_t)){
http_channel_context_handle_response_headers(ctx,chan,(belle_http_response_t*)msg);
}/*ignore requests*/
}
static void channel_on_message(belle_sip_channel_listener_t *obj, belle_sip_channel_t *chan, belle_sip_message_t *msg){
belle_http_channel_context_t *ctx=BELLE_HTTP_CHANNEL_CONTEXT(obj);
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(msg,belle_http_response_t)){
http_channel_context_handle_response(ctx,chan,(belle_http_response_t*)msg);
}/*ignore requests*/
}
static int channel_on_auth_requested(belle_sip_channel_listener_t *obj, belle_sip_channel_t *chan, const char* distinguished_name){
belle_http_channel_context_t *ctx=BELLE_HTTP_CHANNEL_CONTEXT(obj);
if (BELLE_SIP_IS_INSTANCE_OF(chan,belle_sip_tls_channel_t)) {
belle_sip_auth_event_t* auth_event = belle_sip_auth_event_create((belle_sip_object_t*)ctx->provider,NULL,NULL);
belle_sip_tls_channel_t *tls_chan=BELLE_SIP_TLS_CHANNEL(chan);
belle_http_request_t *req=(belle_http_request_t*)chan->outgoing_messages->data;
auth_event->mode=BELLE_SIP_AUTH_MODE_TLS;
belle_sip_auth_event_set_distinguished_name(auth_event,distinguished_name);
BELLE_HTTP_REQUEST_INVOKE_LISTENER(req,process_auth_requested,auth_event);
belle_sip_tls_channel_set_client_certificates_chain(tls_chan,auth_event->cert);
belle_sip_tls_channel_set_client_certificate_key(tls_chan,auth_event->key);
belle_sip_auth_event_destroy(auth_event);
}
return 0;
}
static void channel_on_sending(belle_sip_channel_listener_t *obj, belle_sip_channel_t *chan, belle_sip_message_t *msg){
belle_http_channel_context_t *ctx=BELLE_HTTP_CHANNEL_CONTEXT(obj);
ctx->pending_requests=belle_sip_list_append(ctx->pending_requests,belle_sip_object_ref(msg));
}
static void channel_state_changed(belle_sip_channel_listener_t *obj, belle_sip_channel_t *chan, belle_sip_channel_state_t state){
belle_http_channel_context_t *ctx=BELLE_HTTP_CHANNEL_CONTEXT(obj);
switch(state){
case BELLE_SIP_CHANNEL_INIT:
case BELLE_SIP_CHANNEL_RES_IN_PROGRESS:
case BELLE_SIP_CHANNEL_RES_DONE:
case BELLE_SIP_CHANNEL_CONNECTING:
case BELLE_SIP_CHANNEL_READY:
case BELLE_SIP_CHANNEL_RETRY:
break;
case BELLE_SIP_CHANNEL_ERROR:
http_channel_context_handle_io_error(ctx, chan);
BCTBX_NO_BREAK; /*intentionally no break*/
case BELLE_SIP_CHANNEL_DISCONNECTED:
if (!chan->force_close) provider_remove_channel(ctx->provider,chan);
break;
}
}
static void belle_http_channel_context_uninit(belle_http_channel_context_t *obj){
belle_sip_list_free_with_data(obj->pending_requests,belle_sip_object_unref);
}
static void on_channel_destroyed(belle_http_channel_context_t *obj, belle_sip_channel_t *chan_being_destroyed){
belle_sip_channel_remove_listener(chan_being_destroyed,BELLE_SIP_CHANNEL_LISTENER(obj));
belle_sip_object_unref(obj);
}
/*
* The http channel context stores pending requests so that they can be matched with response received.
* It is associated with the channel when the channel is created, and automatically destroyed when the channel is destroyed.
**/
belle_http_channel_context_t * belle_http_channel_context_new(belle_sip_channel_t *chan, belle_http_provider_t *prov){
belle_http_channel_context_t *obj=belle_sip_object_new(belle_http_channel_context_t);
obj->provider=prov;
belle_sip_channel_add_listener(chan,(belle_sip_channel_listener_t*)obj);
belle_sip_object_weak_ref(chan,(belle_sip_object_destroy_notify_t)on_channel_destroyed,obj);
return obj;
}
int belle_http_channel_is_busy(belle_sip_channel_t *obj) {
belle_sip_list_t *it;
if (obj->incoming_messages != NULL || obj->outgoing_messages != NULL) {
return 1;
}
/*fixme, a litle bit intrusive*/
for (it = obj->full_listeners; it != NULL; it = it->next) {
if (BELLE_SIP_IS_INSTANCE_OF(it->data, belle_http_channel_context_t)) {
belle_http_channel_context_t *obj = it->data;
return obj->pending_requests != NULL;
}
}
return 0;
}
BELLE_SIP_IMPLEMENT_INTERFACE_BEGIN(belle_http_channel_context_t,belle_sip_channel_listener_t)
channel_state_changed,
channel_on_message_headers,
channel_on_message,
channel_on_sending,
channel_on_auth_requested
BELLE_SIP_IMPLEMENT_INTERFACE_END
BELLE_SIP_DECLARE_IMPLEMENTED_INTERFACES_1(belle_http_channel_context_t,belle_sip_channel_listener_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_http_channel_context_t,belle_sip_object_t,belle_http_channel_context_uninit,NULL,NULL,FALSE);
static void http_provider_uninit(belle_http_provider_t *obj){
belle_sip_message("http provider destroyed.");
belle_sip_free(obj->bind_ip);
belle_sip_list_for_each(obj->tcp_channels,(void (*)(void*))belle_sip_channel_force_close);
belle_sip_list_free_with_data(obj->tcp_channels,belle_sip_object_unref);
belle_sip_list_for_each(obj->tls_channels,(void (*)(void*))belle_sip_channel_force_close);
belle_sip_list_free_with_data(obj->tls_channels,belle_sip_object_unref);
belle_sip_object_unref(obj->crypto_config);
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_http_provider_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_http_provider_t,belle_sip_object_t,http_provider_uninit,NULL,NULL,FALSE);
belle_http_provider_t *belle_http_provider_new(belle_sip_stack_t *s, const char *bind_ip){
belle_http_provider_t *p=belle_sip_object_new(belle_http_provider_t);
p->stack=s;
p->bind_ip=belle_sip_strdup(bind_ip);
p->ai_family=strchr(p->bind_ip,':') ? AF_INET6 : AF_INET;
p->crypto_config=belle_tls_crypto_config_new();
return p;
}
static void split_request_url(belle_http_request_t *req){
belle_generic_uri_t *uri=belle_http_request_get_uri(req);
belle_generic_uri_t *new_uri;
char *host_value;
const char *path;
if (belle_generic_uri_get_host(uri)==NULL && req->orig_uri!=NULL) return;/*already processed request uri*/
path=belle_generic_uri_get_path(uri);
if (path==NULL) path="/";
new_uri=belle_generic_uri_new();
belle_generic_uri_set_path(new_uri,path);
belle_generic_uri_set_query(new_uri, belle_generic_uri_get_query(uri));
if (belle_generic_uri_get_port(uri)>0)
host_value=belle_sip_strdup_printf("%s:%i",belle_generic_uri_get_host(uri),belle_generic_uri_get_port(uri));
else
host_value=belle_sip_strdup(belle_generic_uri_get_host(uri));
belle_sip_message_add_header(BELLE_SIP_MESSAGE(req),belle_sip_header_create("Host",host_value));
belle_sip_free(host_value);
SET_OBJECT_PROPERTY(req,orig_uri,uri);
belle_http_request_set_uri(req,new_uri);
}
static void fix_request(belle_http_request_t *req){
size_t size=belle_sip_message_get_body_size((belle_sip_message_t*)req);
belle_sip_header_content_length_t *ctlen=belle_sip_message_get_header_by_type(req, belle_sip_header_content_length_t);
if (size>0 && !ctlen){
belle_sip_message_add_header((belle_sip_message_t*)req,(belle_sip_header_t*)belle_sip_header_content_length_create(size));
}
}
belle_sip_list_t **belle_http_provider_get_channels(belle_http_provider_t *obj, const char *transport_name){
if (strcasecmp(transport_name,"tcp")==0) return &obj->tcp_channels;
else if (strcasecmp(transport_name,"tls")==0) return &obj->tls_channels;
else{
belle_sip_error("belle_http_provider_send_request(): unsupported transport %s",transport_name);
return NULL;
}
}
static void provider_remove_channel(belle_http_provider_t *obj, belle_sip_channel_t *chan){
belle_sip_list_t **channels=belle_http_provider_get_channels(obj,belle_sip_channel_get_transport_name(chan));
*channels=belle_sip_list_remove(*channels,chan);
belle_sip_message("channel [%p] removed from http provider.", chan);
belle_sip_object_unref(chan);
}
static void belle_http_end_background_task(void* data) {
belle_http_request_t *req = BELLE_HTTP_REQUEST(data);
belle_sip_warning("Ending unfinished HTTP transfer background task id=[%x]", req->background_task_id);
if( req->background_task_id ){
belle_sip_end_background_task(req->background_task_id);
req->background_task_id = 0;
}
}
int belle_http_provider_send_request(belle_http_provider_t *obj, belle_http_request_t *req, belle_http_request_listener_t *listener){
belle_sip_channel_t *chan;
belle_sip_list_t **channels;
belle_sip_hop_t *hop=belle_sip_hop_new_from_generic_uri(req->orig_uri ? req->orig_uri : req->req_uri);
if (hop->host == NULL){
belle_sip_error("belle_http_provider_send_request(): no host defined in request uri.");
belle_sip_object_unref(hop);
return -1;
}
channels = belle_http_provider_get_channels(obj,hop->transport);
if (listener) belle_http_request_set_listener(req,listener);
chan=belle_sip_channel_find_from_list(*channels,obj->ai_family, hop);
if (chan) {
// we cannot use the same channel for multiple requests yet since only the first
// one will be processed. Instead of queuing/serializing requests on a single channel,
// we currently create one channel per request if needed.
if (belle_http_channel_is_busy(chan)) {
belle_sip_message("%s: found an available channel but was busy, creating a new one", __FUNCTION__);
chan = NULL;
}
}
if (!chan){
if (strcasecmp(hop->transport,"tcp")==0){
chan=belle_sip_stream_channel_new_client(obj->stack,obj->bind_ip,0,hop->cname,hop->host,hop->port);
} else if (strcasecmp(hop->transport,"tls")==0){
chan=belle_sip_channel_new_tls(obj->stack,obj->crypto_config,obj->bind_ip,0,hop->cname,hop->host,hop->port);
}
if (!chan){
belle_sip_error("%s: cannot create channel for [%s:%s:%i]", __FUNCTION__, hop->transport, hop->cname,
hop->port);
belle_sip_object_unref(hop);
return -1;
}
belle_http_channel_context_new(chan,obj);
*channels=belle_sip_list_prepend(*channels,chan);
}
belle_sip_object_unref(hop);
split_request_url(req);
fix_request(req);
belle_http_request_set_channel(req,chan);
if( req->background_task_id != 0){
req->background_task_id = belle_sip_begin_background_task("belle-sip http", belle_http_end_background_task, req);
}
belle_sip_channel_queue_message(chan,BELLE_SIP_MESSAGE(req));
return 0;
}
static void reenqueue_request(belle_http_request_t *req, belle_http_provider_t *prov){
belle_http_provider_send_request(prov,req,req->listener);
}
void belle_http_provider_cancel_request(belle_http_provider_t *obj, belle_http_request_t *req){
belle_sip_list_t *outgoing_messages;
belle_http_request_cancel(req);
if (req->channel){
// Keep the list of the outgoing messages of the channel...
outgoing_messages = belle_sip_list_copy_with_data(req->channel->outgoing_messages,(void* (*)(void*))belle_sip_object_ref);
if (outgoing_messages && outgoing_messages->data == req){
/*our request didn't go out; so drop it.*/
outgoing_messages = belle_sip_list_remove(outgoing_messages ,req);
belle_sip_object_unref(req);
}
/*protect the channel from being destroyed before removing it (removing it will unref it)*/
belle_sip_object_ref(req->channel);
provider_remove_channel(obj, req->channel);
// ... close the channel...
belle_sip_channel_force_close(req->channel);
belle_sip_object_unref(req->channel);
// ... and reenqueue the previously queued outgoing messages into a new channel
belle_sip_list_for_each2(outgoing_messages,(void (*)(void*,void*))reenqueue_request,obj);
belle_sip_list_free_with_data(outgoing_messages,belle_sip_object_unref);
}
}
int belle_http_provider_set_tls_verify_policy(belle_http_provider_t *obj, belle_tls_verify_policy_t *verify_ctx){
SET_OBJECT_PROPERTY(obj,crypto_config,verify_ctx);
return 0;
}
int belle_http_provider_set_tls_crypto_config(belle_http_provider_t *obj, belle_tls_crypto_config_t *crypto_config){
SET_OBJECT_PROPERTY(obj,crypto_config,crypto_config);
return 0;
}
void belle_http_provider_set_recv_error(belle_http_provider_t *obj, int recv_error) {
belle_sip_list_t *it;
for(it=obj->tcp_channels;it!=NULL;it=it->next){
belle_sip_channel_t *chan = (belle_sip_channel_t*)it->data;
chan->simulated_recv_return=recv_error;
chan->base.notify_required=(recv_error<=0);
}
for(it=obj->tls_channels;it!=NULL;it=it->next){
belle_sip_channel_t *chan = (belle_sip_channel_t*)it->data;
chan->simulated_recv_return=recv_error;
chan->base.notify_required=(recv_error<=0);
}
}
belle-sip-1.6.3/src/ict.c 0000664 0000000 0000000 00000017720 13134375224 0015122 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 .
*/
/**
* INVITE client transaction implementation.
**/
#include
#include "belle_sip_internal.h"
static void on_ict_terminate(belle_sip_ict_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
if (obj->timer_A){
belle_sip_transaction_stop_timer(base,obj->timer_A);
belle_sip_object_unref(obj->timer_A);
obj->timer_A=NULL;
}
if (obj->timer_B){
belle_sip_transaction_stop_timer(base,obj->timer_B);
belle_sip_object_unref(obj->timer_B);
obj->timer_B=NULL;
}
if (obj->timer_D){
belle_sip_transaction_stop_timer(base,obj->timer_D);
belle_sip_object_unref(obj->timer_D);
obj->timer_D=NULL;
}
if (obj->timer_M){
belle_sip_transaction_stop_timer(base,obj->timer_M);
belle_sip_object_unref(obj->timer_M);
obj->timer_M=NULL;
}
if (obj->ack){
belle_sip_object_unref(obj->ack);
obj->ack=NULL;
}
}
static void ict_destroy(belle_sip_ict_t *obj){
on_ict_terminate(obj);
}
static belle_sip_request_t *make_ack(belle_sip_ict_t *obj, belle_sip_response_t *resp){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
if (obj->ack==NULL){
obj->ack=belle_sip_request_new();
belle_sip_object_ref(obj->ack);
belle_sip_request_set_method(obj->ack,"ACK");
belle_sip_request_set_uri(obj->ack,belle_sip_request_get_uri(base->request));
belle_sip_util_copy_headers((belle_sip_message_t*)base->request,(belle_sip_message_t*)obj->ack,BELLE_SIP_VIA,FALSE);
belle_sip_util_copy_headers((belle_sip_message_t*)base->request,(belle_sip_message_t*)obj->ack,BELLE_SIP_CALL_ID,FALSE);
belle_sip_util_copy_headers((belle_sip_message_t*)base->request,(belle_sip_message_t*)obj->ack,BELLE_SIP_FROM,FALSE);
belle_sip_util_copy_headers((belle_sip_message_t*)resp,(belle_sip_message_t*)obj->ack,BELLE_SIP_TO,FALSE);
belle_sip_util_copy_headers((belle_sip_message_t*)base->request,(belle_sip_message_t*)obj->ack,BELLE_SIP_CONTACT,TRUE);
belle_sip_util_copy_headers((belle_sip_message_t*)base->request,(belle_sip_message_t*)obj->ack,BELLE_SIP_ROUTE,TRUE);
belle_sip_util_copy_headers((belle_sip_message_t*)base->request,(belle_sip_message_t*)obj->ack,BELLE_SIP_MAX_FORWARDS,FALSE);
belle_sip_message_add_header((belle_sip_message_t*)obj->ack,
(belle_sip_header_t*)belle_sip_header_cseq_create(
belle_sip_header_cseq_get_seq_number((belle_sip_header_cseq_t*)belle_sip_message_get_header((belle_sip_message_t*)base->request,BELLE_SIP_CSEQ)),
"ACK"));
}
return obj->ack;
}
/* Timer D: Wait time for response retransmits */
static int ict_on_timer_D(belle_sip_ict_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
if (base->state==BELLE_SIP_TRANSACTION_COMPLETED){
belle_sip_transaction_terminate(base);
}
return BELLE_SIP_STOP;
}
/* Timer M: Wait time for retransmission of 2xx to INVITE or additional 2xx from other branches of a forked INVITE */
static int ict_on_timer_M(belle_sip_ict_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
if (base->state==BELLE_SIP_TRANSACTION_ACCEPTED){
belle_sip_transaction_terminate(base);
}
return BELLE_SIP_STOP;
}
static void ict_on_response(belle_sip_ict_t *obj, belle_sip_response_t *resp){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
int code=belle_sip_response_get_status_code(resp);
const belle_sip_timer_config_t *cfg=belle_sip_transaction_get_timer_config(base);
switch (base->state){
case BELLE_SIP_TRANSACTION_CALLING:
belle_sip_transaction_set_state(base,BELLE_SIP_TRANSACTION_PROCEEDING);
BCTBX_NO_BREAK; /*intentionally no break*/
case BELLE_SIP_TRANSACTION_PROCEEDING:
if (code>=300){
belle_sip_transaction_set_state(base,BELLE_SIP_TRANSACTION_COMPLETED);
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)make_ack(obj,resp));
belle_sip_client_transaction_notify_response((belle_sip_client_transaction_t*)obj,resp);
obj->timer_D=belle_sip_timeout_source_new((belle_sip_source_func_t)ict_on_timer_D,obj,cfg->T1*64);
belle_sip_transaction_start_timer(base,obj->timer_D);
}else if (code>=200){
obj->timer_M=belle_sip_timeout_source_new((belle_sip_source_func_t)ict_on_timer_M,obj,cfg->T1*64);
belle_sip_transaction_start_timer(base,obj->timer_M);
belle_sip_transaction_set_state(base,BELLE_SIP_TRANSACTION_ACCEPTED);
belle_sip_client_transaction_notify_response((belle_sip_client_transaction_t*)obj,resp);
}else if (code>=100){
belle_sip_client_transaction_notify_response((belle_sip_client_transaction_t*)obj,resp);
}
break;
case BELLE_SIP_TRANSACTION_ACCEPTED:
if (code>=200 && code<300){
belle_sip_client_transaction_notify_response((belle_sip_client_transaction_t*)obj,resp);
}
break;
case BELLE_SIP_TRANSACTION_COMPLETED:
if (code>=300 && obj->ack){
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)obj->ack);
}
break;
default:
break;
}
}
/* Timer A: INVITE request retransmit interval, for UDP only */
static int ict_on_timer_A(belle_sip_ict_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
if (!base->channel) return BELLE_SIP_STOP;
switch(base->state){
case BELLE_SIP_TRANSACTION_CALLING:
{
/*reset the timer to twice the previous value, and retransmit */
unsigned int prev_timeout=belle_sip_source_get_timeout(obj->timer_A);
belle_sip_source_set_timeout(obj->timer_A,2*prev_timeout);
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)base->request);
}
break;
default:
break;
}
return BELLE_SIP_CONTINUE;
}
/* Timer B: INVITE transaction timeout timer */
static int ict_on_timer_B(belle_sip_ict_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
switch (base->state){
case BELLE_SIP_TRANSACTION_CALLING:
belle_sip_transaction_notify_timeout(base);
break;
default:
break;
}
return BELLE_SIP_STOP;
}
static void ict_send_request(belle_sip_ict_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
const belle_sip_timer_config_t *cfg=belle_sip_transaction_get_timer_config(base);
belle_sip_transaction_set_state(base,BELLE_SIP_TRANSACTION_CALLING);
if (!belle_sip_channel_is_reliable(base->channel)){
obj->timer_A=belle_sip_timeout_source_new((belle_sip_source_func_t)ict_on_timer_A,obj,cfg->T1);
belle_sip_transaction_start_timer(base,obj->timer_A);
}
obj->timer_B=belle_sip_timeout_source_new((belle_sip_source_func_t)ict_on_timer_B,obj,cfg->T1*64);
belle_sip_transaction_start_timer(base,obj->timer_B);
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)base->request);
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_ict_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_ict_t)
{
{
{
BELLE_SIP_VPTR_INIT(belle_sip_ict_t,belle_sip_client_transaction_t,TRUE),
(belle_sip_object_destroy_t)ict_destroy,
NULL,
NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
(void (*)(belle_sip_transaction_t*))on_ict_terminate
},
(void (*)(belle_sip_client_transaction_t*))ict_send_request,
(void (*)(belle_sip_client_transaction_t*,belle_sip_response_t*))ict_on_response
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
belle_sip_ict_t *belle_sip_ict_new(belle_sip_provider_t *prov, belle_sip_request_t *req){
belle_sip_ict_t *obj=belle_sip_object_new(belle_sip_ict_t);
belle_sip_client_transaction_init((belle_sip_client_transaction_t*)obj,prov,req);
return obj;
}
belle-sip-1.6.3/src/ist.c 0000664 0000000 0000000 00000015062 13134375224 0015137 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 .
*/
/**
* INVITE server transaction implementation.
**/
#include "belle_sip_internal.h"
static void ist_on_terminate(belle_sip_ist_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
/*timer pointers are set to NULL because they can be released later*/
if (obj->timer_G){
belle_sip_transaction_stop_timer(base,obj->timer_G);
belle_sip_object_unref(obj->timer_G);
obj->timer_G=NULL;
}
if (obj->timer_H){
belle_sip_transaction_stop_timer(base,obj->timer_H);
belle_sip_object_unref(obj->timer_H);
obj->timer_H=NULL;
}
if (obj->timer_I){
belle_sip_transaction_stop_timer(base,obj->timer_I);
belle_sip_object_unref(obj->timer_I);
obj->timer_I=NULL;
}
if (obj->timer_L){
belle_sip_transaction_stop_timer(base,obj->timer_L);
belle_sip_object_unref(obj->timer_L);
obj->timer_L=NULL;
}
}
static void ist_destroy(belle_sip_ist_t *obj){
ist_on_terminate(obj);
}
/* Timer G: INVITE response retransmit interval */
static int ist_on_timer_G(belle_sip_ist_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
if (base->state==BELLE_SIP_TRANSACTION_COMPLETED){
const belle_sip_timer_config_t *cfg=belle_sip_transaction_get_timer_config(base);
int interval=belle_sip_source_get_timeout(obj->timer_G);
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)base->last_response);
belle_sip_source_set_timeout(obj->timer_G,MIN(2*interval,cfg->T2));
return BELLE_SIP_CONTINUE;
}
return BELLE_SIP_STOP;
}
/* Timer H: Wait time for ACK receipt */
static int ist_on_timer_H(belle_sip_ist_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
if (base->state==BELLE_SIP_TRANSACTION_COMPLETED){
belle_sip_transaction_terminate(base);
/*FIXME: no ACK was received, should report the failure */
}
return BELLE_SIP_STOP;
}
/* Timer I: Wait time for ACK retransmits */
static int ist_on_timer_I(belle_sip_ist_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
belle_sip_transaction_terminate(base);
return BELLE_SIP_STOP;
}
/* Timer L: Wait time for accepted INVITE request retransmits */
static int ist_on_timer_L(belle_sip_ist_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
belle_sip_transaction_terminate(base);
return BELLE_SIP_STOP;
}
int belle_sip_ist_process_ack(belle_sip_ist_t *obj, belle_sip_message_t *ack){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
int ret=-1;
switch(base->state){
case BELLE_SIP_TRANSACTION_COMPLETED:
/*clear timer G*/
if (obj->timer_G){
belle_sip_transaction_stop_timer(base,obj->timer_G);
belle_sip_object_unref(obj->timer_G);
obj->timer_G=NULL;
}
belle_sip_transaction_set_state(base,BELLE_SIP_TRANSACTION_CONFIRMED);
if (!belle_sip_channel_is_reliable(base->channel)){
const belle_sip_timer_config_t *cfg=belle_sip_transaction_get_timer_config(base);
obj->timer_I=belle_sip_timeout_source_new((belle_sip_source_func_t)ist_on_timer_I,obj,cfg->T4);
belle_sip_transaction_start_timer(base,obj->timer_I);
}else ist_on_timer_I(obj);
break;
case BELLE_SIP_TRANSACTION_ACCEPTED:
ret=0; /*let the ACK be reported to TU */
break;
default:
break;
}
return ret;
}
static int ist_send_new_response(belle_sip_ist_t *obj, belle_sip_response_t *resp){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
int code=belle_sip_response_get_status_code(resp);
int ret=-1;
switch(base->state){
case BELLE_SIP_TRANSACTION_PROCEEDING:
{
const belle_sip_timer_config_t *cfg=belle_sip_transaction_get_timer_config(base);
ret=0;
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)resp);
if (code>=200 && code<300){
belle_sip_transaction_set_state(base,BELLE_SIP_TRANSACTION_ACCEPTED);
obj->timer_L=belle_sip_timeout_source_new((belle_sip_source_func_t)ist_on_timer_L,obj,64*cfg->T1);
belle_sip_transaction_start_timer(base,obj->timer_L);
}else if (code>=300){
belle_sip_transaction_set_state(base,BELLE_SIP_TRANSACTION_COMPLETED);
if (!belle_sip_channel_is_reliable(base->channel)){
obj->timer_G=belle_sip_timeout_source_new((belle_sip_source_func_t)ist_on_timer_G,obj,cfg->T1);
belle_sip_transaction_start_timer(base,obj->timer_G);
}
obj->timer_H=belle_sip_timeout_source_new((belle_sip_source_func_t)ist_on_timer_H,obj,64*cfg->T1);
belle_sip_transaction_start_timer(base,obj->timer_H);
}
}
break;
case BELLE_SIP_TRANSACTION_ACCEPTED:
if (code>=200 && code<300){
ret=0; /*let the response go to transport layer*/
}
default:
break;
}
return ret;
}
static void ist_on_request_retransmission(belle_sip_nist_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
switch(base->state){
case BELLE_SIP_TRANSACTION_PROCEEDING:
case BELLE_SIP_TRANSACTION_COMPLETED:
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)base->last_response);
break;
default:
break;
}
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_ist_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_ist_t)
{
{
{
BELLE_SIP_VPTR_INIT(belle_sip_ist_t,belle_sip_server_transaction_t,TRUE),
(belle_sip_object_destroy_t)ist_destroy,
NULL,
NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
(void (*)(belle_sip_transaction_t *))ist_on_terminate
},
(int (*)(belle_sip_server_transaction_t*, belle_sip_response_t *))ist_send_new_response,
(void (*)(belle_sip_server_transaction_t*))ist_on_request_retransmission,
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
belle_sip_ist_t *belle_sip_ist_new(belle_sip_provider_t *prov, belle_sip_request_t *req){
belle_sip_ist_t *obj=belle_sip_object_new(belle_sip_ist_t);
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
belle_sip_server_transaction_init((belle_sip_server_transaction_t*)obj,prov,req);
belle_sip_transaction_set_state(base,BELLE_SIP_TRANSACTION_PROCEEDING);
return obj;
}
belle-sip-1.6.3/src/listeningpoint.c 0000664 0000000 0000000 00000020445 13134375224 0017407 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 .
*/
#include "belle_sip_internal.h"
void belle_sip_listening_point_init(belle_sip_listening_point_t *lp, belle_sip_stack_t *s, const char *address, int port){
char *tmp;
belle_sip_init_sockets();
lp->stack=s;
lp->listening_uri=belle_sip_uri_create(NULL,address);
belle_sip_object_ref(lp->listening_uri);
belle_sip_uri_set_port(lp->listening_uri,port);
belle_sip_uri_set_transport_param(lp->listening_uri,BELLE_SIP_OBJECT_VPTR(lp,belle_sip_listening_point_t)->transport);
tmp=belle_sip_object_to_string((belle_sip_object_t*)BELLE_SIP_LISTENING_POINT(lp)->listening_uri);
if (strchr(address,':')) {
lp->ai_family=AF_INET6;
} else {
lp->ai_family=AF_INET;
}
belle_sip_message("Creating listening point [%p] on [%s]",lp, tmp);
belle_sip_free(tmp);
}
static void belle_sip_listening_point_uninit(belle_sip_listening_point_t *lp){
char *tmp=belle_sip_object_to_string((belle_sip_object_t*)BELLE_SIP_LISTENING_POINT(lp)->listening_uri);
belle_sip_listening_point_clean_channels(lp);
belle_sip_message("Listening point [%p] on [%s] destroyed",lp, tmp);
belle_sip_object_unref(lp->listening_uri);
belle_sip_free(tmp);
lp->channel_listener=NULL; /*does not unref provider*/
belle_sip_uninit_sockets();
belle_sip_listening_point_set_keep_alive(lp,-1);
}
void belle_sip_listening_point_add_channel(belle_sip_listening_point_t *lp, belle_sip_channel_t *chan){
chan->lp=lp;
belle_sip_channel_add_listener(chan,lp->channel_listener); /*add channel listener*/
/*channel is already owned, no ref needed - REVISIT: channel should be initally unowned probably.*/
/* The channel with names must be treated with higher priority by the get_channel() method so queued on front.
* This is to prevent the UDP listening point to dispatch incoming messages to channels that were created by inbound connection
* where name cannot be determined. When this arrives, there can be 2 channels for the same destination IP and strange problems can occur
* where requests are sent through name qualified channel and response received through name unqualified channel.
*/
if (chan->has_name)
lp->channels=belle_sip_list_prepend(lp->channels,chan);
else
lp->channels=belle_sip_list_append(lp->channels,chan);
}
belle_sip_channel_t *belle_sip_listening_point_create_channel(belle_sip_listening_point_t *obj, const belle_sip_hop_t *hop){
belle_sip_channel_t *chan=BELLE_SIP_OBJECT_VPTR(obj,belle_sip_listening_point_t)->create_channel(obj,hop);
if (chan){
belle_sip_listening_point_add_channel(obj,chan);
}
return chan;
}
void belle_sip_listening_point_remove_channel(belle_sip_listening_point_t *lp, belle_sip_channel_t *chan){
belle_sip_channel_remove_listener(chan,lp->channel_listener);
lp->channels=belle_sip_list_remove(lp->channels,chan);
belle_sip_object_unref(chan);
}
void belle_sip_listening_point_clean_channels(belle_sip_listening_point_t *lp){
int existing_channels = belle_sip_listening_point_get_channel_count(lp);
belle_sip_list_t* iterator;
if (existing_channels > 0) {
belle_sip_message("Listening point destroying [%i] channels",existing_channels);
}
for (iterator=lp->channels;iterator!=NULL;iterator=iterator->next) {
belle_sip_channel_t *chan=(belle_sip_channel_t*)iterator->data;
belle_sip_channel_force_close(chan);
}
lp->channels=belle_sip_list_free_with_data(lp->channels,(void (*)(void*))belle_sip_object_unref);
}
int belle_sip_listening_point_get_channel_count(const belle_sip_listening_point_t *lp){
return (int)belle_sip_list_size(lp->channels);
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_listening_point_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_listening_point_t)
{
BELLE_SIP_VPTR_INIT(belle_sip_listening_point_t, belle_sip_object_t,FALSE),
(belle_sip_object_destroy_t)belle_sip_listening_point_uninit,
NULL,
NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
NULL,
NULL
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
const char *belle_sip_listening_point_get_ip_address(const belle_sip_listening_point_t *lp){
return belle_sip_uri_get_host(lp->listening_uri);
}
int belle_sip_listening_point_get_port(const belle_sip_listening_point_t *lp){
return belle_sip_uri_get_listening_port(lp->listening_uri);
}
const char *belle_sip_listening_point_get_transport(const belle_sip_listening_point_t *lp){
return belle_sip_uri_get_transport_param(lp->listening_uri);
}
const belle_sip_uri_t* belle_sip_listening_point_get_uri(const belle_sip_listening_point_t *lp) {
return lp->listening_uri;
}
int belle_sip_listening_point_get_well_known_port(const char *transport){
if (strcasecmp(transport,"UDP")==0 || strcasecmp(transport,"TCP")==0 ) return 5060;
if (strcasecmp(transport,"DTLS")==0 || strcasecmp(transport,"TLS")==0 ) return 5061;
belle_sip_error("No well known port for transport %s", transport);
return -1;
}
belle_sip_channel_t *_belle_sip_listening_point_get_channel(belle_sip_listening_point_t *lp, const belle_sip_hop_t *hop, const struct addrinfo *addr){
return belle_sip_channel_find_from_list_with_addrinfo(lp->channels,hop,addr);
}
belle_sip_channel_t *belle_sip_listening_point_get_channel(belle_sip_listening_point_t *lp,const belle_sip_hop_t *hop){
return belle_sip_channel_find_from_list(lp->channels,lp->ai_family,hop);
}
static int send_keep_alive(belle_sip_channel_t* obj) {
/*keep alive*/
const char* crlfcrlf = "\r\n\r\n";
size_t size=strlen(crlfcrlf);
int err=belle_sip_channel_send(obj,crlfcrlf,size);
if (err<=0 && !belle_sip_error_code_is_would_block(-err) && err!=-EINTR){
belle_sip_error("channel [%p]: could not send [%u] bytes of keep alive from [%s://%s:%i] to [%s:%i]" ,obj
,(unsigned int)size
,belle_sip_channel_get_transport_name(obj)
,obj->local_ip
,obj->local_port
,obj->peer_name
,obj->peer_port);
return -1;
}else{
belle_sip_message("channel [%p]: keep alive sent to [%s://%s:%i]"
,obj
,belle_sip_channel_get_transport_name(obj)
,obj->peer_name
,obj->peer_port);
return 0;
}
}
static int keep_alive_timer_func(void *user_data, unsigned int events) {
belle_sip_listening_point_t* lp=(belle_sip_listening_point_t*)user_data;
belle_sip_list_t* iterator;
belle_sip_channel_t* channel;
belle_sip_list_t *to_be_closed=NULL;
for (iterator=lp->channels;iterator!=NULL;iterator=iterator->next) {
channel=(belle_sip_channel_t*)iterator->data;
if (channel->state == BELLE_SIP_CHANNEL_READY && send_keep_alive(channel)==-1) { /*only send keep alive if ready*/
to_be_closed=belle_sip_list_append(to_be_closed,channel);
}
}
for (iterator=to_be_closed;iterator!=NULL;iterator=iterator->next){
channel=(belle_sip_channel_t*)iterator->data;
channel_set_state(channel,BELLE_SIP_CHANNEL_ERROR);
belle_sip_channel_close(channel);
}
belle_sip_list_free(to_be_closed);
return BELLE_SIP_CONTINUE_WITHOUT_CATCHUP;
}
void belle_sip_listening_point_set_keep_alive(belle_sip_listening_point_t *lp,int ms) {
if (ms <=0) {
if (lp->keep_alive_timer) {
belle_sip_main_loop_remove_source(lp->stack->ml,lp->keep_alive_timer);
belle_sip_object_unref(lp->keep_alive_timer);
lp->keep_alive_timer=NULL;
}
return;
}
if (!lp->keep_alive_timer) {
lp->keep_alive_timer = belle_sip_main_loop_create_timeout(lp->stack->ml
, keep_alive_timer_func
, lp
, ms
,"keep alive") ;
} else {
belle_sip_source_set_timeout(lp->keep_alive_timer,ms);
}
return;
}
int belle_sip_listening_point_get_keep_alive(const belle_sip_listening_point_t *lp) {
return lp->keep_alive_timer?(int)belle_sip_source_get_timeout(lp->keep_alive_timer):-1;
}
void belle_sip_listening_point_set_channel_listener(belle_sip_listening_point_t *lp,belle_sip_channel_listener_t* channel_listener) {
lp->channel_listener=channel_listener;
}
belle-sip-1.6.3/src/listeningpoint_internal.h 0000664 0000000 0000000 00000012506 13134375224 0021307 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 .
*/
#ifndef LISTENINGPOINT_INTERNAL_H_
#define LISTENINGPOINT_INTERNAL_H_
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_listening_point_t,belle_sip_object_t)
const char *transport;
belle_sip_channel_t * (*create_channel)(belle_sip_listening_point_t *, const belle_sip_hop_t *hop);
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
#define BELLE_SIP_LISTENING_POINT(obj) BELLE_SIP_CAST(obj,belle_sip_listening_point_t)
/*
Listening points: base, udp
*/
struct belle_sip_listening_point{
belle_sip_object_t base;
belle_sip_stack_t *stack;
belle_sip_list_t *channels;
belle_sip_uri_t* listening_uri;
belle_sip_source_t* keep_alive_timer;
belle_sip_channel_listener_t* channel_listener; /*initial channel listener used for channel creation, specially for socket server*/
int ai_family; /*AF_INET or AF_INET6*/
};
BELLE_SIP_BEGIN_DECLS
void belle_sip_listening_point_init(belle_sip_listening_point_t *lp, belle_sip_stack_t *s, const char *address, int port);
belle_sip_channel_t *_belle_sip_listening_point_get_channel(belle_sip_listening_point_t *lp,const belle_sip_hop_t *hop, const struct addrinfo *addr);
belle_sip_channel_t *belle_sip_listening_point_create_channel(belle_sip_listening_point_t *ip, const belle_sip_hop_t *hop);
void belle_sip_listening_point_remove_channel(belle_sip_listening_point_t *lp, belle_sip_channel_t *chan);
int belle_sip_listening_point_get_well_known_port(const char *transport);
belle_sip_channel_t *belle_sip_listening_point_get_channel(belle_sip_listening_point_t *lp, const belle_sip_hop_t *hop);
void belle_sip_listening_point_add_channel(belle_sip_listening_point_t *lp, belle_sip_channel_t *chan);
void belle_sip_listening_point_set_channel_listener(belle_sip_listening_point_t *lp,belle_sip_channel_listener_t* channel_listener);
BELLE_SIP_END_DECLS
/**udp*/
typedef struct belle_sip_udp_listening_point belle_sip_udp_listening_point_t;
belle_sip_channel_t * belle_sip_channel_new_udp(belle_sip_stack_t *stack, int sock, const char *bindip, int localport, const char *peername, int peerport);
belle_sip_channel_t * belle_sip_channel_new_udp_with_addr(belle_sip_stack_t *stack, int sock, const char *bindip, int localport, const struct addrinfo *ai);
belle_sip_listening_point_t * belle_sip_udp_listening_point_new(belle_sip_stack_t *s, const char *ipaddress, int port);
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_udp_listening_point_t,belle_sip_listening_point_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
/*stream*/
typedef struct belle_sip_stream_listening_point belle_sip_stream_listening_point_t;
struct belle_sip_stream_listening_point{
belle_sip_listening_point_t base;
belle_sip_socket_t server_sock;
belle_sip_source_t *source;
};
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_stream_listening_point_t,belle_sip_listening_point_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
void belle_sip_stream_listening_point_setup_server_socket(belle_sip_stream_listening_point_t *obj, belle_sip_source_func_t on_new_connection_cb );
void belle_sip_stream_listening_point_destroy_server_socket(belle_sip_stream_listening_point_t *lp);
void belle_sip_stream_listening_point_init(belle_sip_stream_listening_point_t *obj, belle_sip_stack_t *s, const char *ipaddress, int port, belle_sip_source_func_t on_new_connection_cb );
belle_sip_listening_point_t * belle_sip_stream_listening_point_new(belle_sip_stack_t *s, const char *ipaddress, int port);
/*tls*/
struct belle_sip_tls_listening_point{
belle_sip_stream_listening_point_t base;
belle_tls_crypto_config_t *crypto_config;
};
int belle_sip_tls_listening_point_available(void);
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_tls_listening_point_t,belle_sip_listening_point_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
#define BELLE_SIP_TLS_LISTENING_POINT(obj) BELLE_SIP_CAST(obj,belle_sip_tls_listening_point_t)
belle_sip_listening_point_t * belle_sip_tls_listening_point_new(belle_sip_stack_t *s, const char *ipaddress, int port);
belle_sip_channel_t * belle_sip_channel_new_tls(belle_sip_stack_t *s, belle_tls_verify_policy_t* verify_ctx, const char *bindip, int localport,const char *cname, const char *name, int port);
/*tunnel*/
#ifdef HAVE_TUNNEL
typedef struct belle_sip_tunnel_listening_point belle_sip_tunnel_listening_point_t;
BELLE_SIP_DECLARE_CUSTOM_VPTR_BEGIN(belle_sip_tunnel_listening_point_t,belle_sip_listening_point_t)
BELLE_SIP_DECLARE_CUSTOM_VPTR_END
#define BELLE_SIP_TUNNEL_LISTENING_POINT(obj) BELLE_SIP_CAST(obj,belle_sip_tunnel_listening_point_t)
belle_sip_channel_t * belle_sip_channel_new_tunnel(belle_sip_stack_t *s, void *tunnelclient, const char *bindip, int localport, const char *name, int port);
#endif
#include "transports/stream_channel.h"
#endif /* LISTENINGPOINT_INTERNAL_H_ */
belle-sip-1.6.3/src/md5.c 0000664 0000000 0000000 00000030304 13134375224 0015021 0 ustar 00root root 0000000 0000000 /*
Copyright (C) 1999, 2000, 2002 Aladdin Enterprises. All rights reserved.
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
L. Peter Deutsch
ghost@aladdin.com
*/
/* $Id: md5.c,v 1.6 2002/04/13 19:20:28 lpd Exp $ */
/*
Independent implementation of MD5 (RFC 1321).
This code implements the MD5 Algorithm defined in RFC 1321, whose
text is available at
http://www.ietf.org/rfc/rfc1321.txt
The code is derived from the text of the RFC, including the test suite
(section A.5) but excluding the rest of Appendix A. It does not include
any code or documentation that is identified in the RFC as being
copyrighted.
The original and principal author of md5.c is L. Peter Deutsch
. Other authors are noted in the change history
that follows (in reverse chronological order):
2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order
either statically or dynamically; added missing #include
in library.
2002-03-11 lpd Corrected argument list for main(), and added int return
type, in test program and T value program.
2002-02-21 lpd Added missing #include in test program.
2000-07-03 lpd Patched to eliminate warnings about "constant is
unsigned in ANSI C, signed in traditional"; made test program
self-checking.
1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
1999-05-03 lpd Original version.
*/
#include "md5.h"
#include
#undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */
#ifdef ARCH_IS_BIG_ENDIAN
# define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
#else
# define BYTE_ORDER 0
#endif
#define T_MASK ((md5_word_t)~0)
#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
#define T3 0x242070db
#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
#define T6 0x4787c62a
#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
#define T9 0x698098d8
#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
#define T13 0x6b901122
#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
#define T16 0x49b40821
#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
#define T19 0x265e5a51
#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
#define T22 0x02441453
#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
#define T25 0x21e1cde6
#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
#define T28 0x455a14ed
#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
#define T31 0x676f02d9
#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
#define T35 0x6d9d6122
#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
#define T38 0x4bdecfa9
#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
#define T41 0x289b7ec6
#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
#define T44 0x04881d05
#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
#define T47 0x1fa27cf8
#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
#define T50 0x432aff97
#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
#define T53 0x655b59c3
#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
#define T57 0x6fa87e4f
#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
#define T60 0x4e0811a1
#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
#define T63 0x2ad7d2bb
#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
static void
md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
{
md5_word_t
a = pms->abcd[0], b = pms->abcd[1],
c = pms->abcd[2], d = pms->abcd[3];
md5_word_t t;
#if BYTE_ORDER > 0
/* Define storage only for big-endian CPUs. */
md5_word_t X[16];
#else
/* Define storage for little-endian or both types of CPUs. */
md5_word_t xbuf[16];
const md5_word_t *X;
#endif
{
#if BYTE_ORDER == 0
/*
* Determine dynamically whether this is a big-endian or
* little-endian machine, since we can use a more efficient
* algorithm on the latter.
*/
static const int w = 1;
if (*((const md5_byte_t *)&w)) /* dynamic little-endian */
#endif
#if BYTE_ORDER <= 0 /* little-endian */
{
/*
* On little-endian machines, we can process properly aligned
* data without copying it.
*/
if (!((data - (const md5_byte_t *)0) & 3)) {
/* data are properly aligned */
X = (const md5_word_t *)data;
} else {
/* not aligned */
memcpy(xbuf, data, 64);
X = xbuf;
}
}
#endif
#if BYTE_ORDER == 0
else /* dynamic big-endian */
#endif
#if BYTE_ORDER >= 0 /* big-endian */
{
/*
* On big-endian machines, we must arrange the bytes in the
* right order.
*/
const md5_byte_t *xp = data;
int i;
# if BYTE_ORDER == 0
X = xbuf; /* (dynamic only) */
# else
# define xbuf X /* (static only) */
# endif
for (i = 0; i < 16; ++i, xp += 4)
xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
}
#endif
}
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
/* Round 1. */
/* Let [abcd k s i] denote the operation
a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
#define SET(a, b, c, d, k, s, Ti)\
t = a + F(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 0, 7, T1);
SET(d, a, b, c, 1, 12, T2);
SET(c, d, a, b, 2, 17, T3);
SET(b, c, d, a, 3, 22, T4);
SET(a, b, c, d, 4, 7, T5);
SET(d, a, b, c, 5, 12, T6);
SET(c, d, a, b, 6, 17, T7);
SET(b, c, d, a, 7, 22, T8);
SET(a, b, c, d, 8, 7, T9);
SET(d, a, b, c, 9, 12, T10);
SET(c, d, a, b, 10, 17, T11);
SET(b, c, d, a, 11, 22, T12);
SET(a, b, c, d, 12, 7, T13);
SET(d, a, b, c, 13, 12, T14);
SET(c, d, a, b, 14, 17, T15);
SET(b, c, d, a, 15, 22, T16);
#undef SET
/* Round 2. */
/* Let [abcd k s i] denote the operation
a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
#define SET(a, b, c, d, k, s, Ti)\
t = a + G(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 1, 5, T17);
SET(d, a, b, c, 6, 9, T18);
SET(c, d, a, b, 11, 14, T19);
SET(b, c, d, a, 0, 20, T20);
SET(a, b, c, d, 5, 5, T21);
SET(d, a, b, c, 10, 9, T22);
SET(c, d, a, b, 15, 14, T23);
SET(b, c, d, a, 4, 20, T24);
SET(a, b, c, d, 9, 5, T25);
SET(d, a, b, c, 14, 9, T26);
SET(c, d, a, b, 3, 14, T27);
SET(b, c, d, a, 8, 20, T28);
SET(a, b, c, d, 13, 5, T29);
SET(d, a, b, c, 2, 9, T30);
SET(c, d, a, b, 7, 14, T31);
SET(b, c, d, a, 12, 20, T32);
#undef SET
/* Round 3. */
/* Let [abcd k s t] denote the operation
a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define SET(a, b, c, d, k, s, Ti)\
t = a + H(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 5, 4, T33);
SET(d, a, b, c, 8, 11, T34);
SET(c, d, a, b, 11, 16, T35);
SET(b, c, d, a, 14, 23, T36);
SET(a, b, c, d, 1, 4, T37);
SET(d, a, b, c, 4, 11, T38);
SET(c, d, a, b, 7, 16, T39);
SET(b, c, d, a, 10, 23, T40);
SET(a, b, c, d, 13, 4, T41);
SET(d, a, b, c, 0, 11, T42);
SET(c, d, a, b, 3, 16, T43);
SET(b, c, d, a, 6, 23, T44);
SET(a, b, c, d, 9, 4, T45);
SET(d, a, b, c, 12, 11, T46);
SET(c, d, a, b, 15, 16, T47);
SET(b, c, d, a, 2, 23, T48);
#undef SET
/* Round 4. */
/* Let [abcd k s t] denote the operation
a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
#define I(x, y, z) ((y) ^ ((x) | ~(z)))
#define SET(a, b, c, d, k, s, Ti)\
t = a + I(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 0, 6, T49);
SET(d, a, b, c, 7, 10, T50);
SET(c, d, a, b, 14, 15, T51);
SET(b, c, d, a, 5, 21, T52);
SET(a, b, c, d, 12, 6, T53);
SET(d, a, b, c, 3, 10, T54);
SET(c, d, a, b, 10, 15, T55);
SET(b, c, d, a, 1, 21, T56);
SET(a, b, c, d, 8, 6, T57);
SET(d, a, b, c, 15, 10, T58);
SET(c, d, a, b, 6, 15, T59);
SET(b, c, d, a, 13, 21, T60);
SET(a, b, c, d, 4, 6, T61);
SET(d, a, b, c, 11, 10, T62);
SET(c, d, a, b, 2, 15, T63);
SET(b, c, d, a, 9, 21, T64);
#undef SET
/* Then perform the following additions. (That is increment each
of the four registers by the value it had before this block
was started.) */
pms->abcd[0] += a;
pms->abcd[1] += b;
pms->abcd[2] += c;
pms->abcd[3] += d;
}
void
belle_sip_md5_init(md5_state_t *pms)
{
pms->count[0] = pms->count[1] = 0;
pms->abcd[0] = 0x67452301;
pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
pms->abcd[3] = 0x10325476;
}
void
belle_sip_md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
{
const md5_byte_t *p = data;
int left = nbytes;
int offset = (pms->count[0] >> 3) & 63;
md5_word_t nbits = (md5_word_t)(nbytes << 3);
if (nbytes <= 0)
return;
/* Update the message length. */
pms->count[1] += nbytes >> 29;
pms->count[0] += nbits;
if (pms->count[0] < nbits)
pms->count[1]++;
/* Process an initial partial block. */
if (offset) {
int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
memcpy(pms->buf + offset, p, copy);
if (offset + copy < 64)
return;
p += copy;
left -= copy;
md5_process(pms, pms->buf);
}
/* Process full blocks. */
for (; left >= 64; p += 64, left -= 64)
md5_process(pms, p);
/* Process a final partial block. */
if (left)
memcpy(pms->buf, p, left);
}
void
belle_sip_md5_finish(md5_state_t *pms, md5_byte_t digest[16])
{
static const md5_byte_t pad[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
md5_byte_t data[8];
int i;
/* Save the length before padding. */
for (i = 0; i < 8; ++i)
data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
/* Pad to 56 bytes mod 64. */
belle_sip_md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
/* Append the length. */
belle_sip_md5_append(pms, data, 8);
for (i = 0; i < 16; ++i)
digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
}
belle-sip-1.6.3/src/md5.h 0000664 0000000 0000000 00000006536 13134375224 0015040 0 ustar 00root root 0000000 0000000 /*
Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved.
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
L. Peter Deutsch
ghost@aladdin.com
*/
/* $Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $ */
/*
Independent implementation of MD5 (RFC 1321).
This code implements the MD5 Algorithm defined in RFC 1321, whose
text is available at
http://www.ietf.org/rfc/rfc1321.txt
The code is derived from the text of the RFC, including the test suite
(section A.5) but excluding the rest of Appendix A. It does not include
any code or documentation that is identified in the RFC as being
copyrighted.
The original and principal author of md5.h is L. Peter Deutsch
. Other authors are noted in the change history
that follows (in reverse chronological order):
2002-04-13 lpd Removed support for non-ANSI compilers; removed
references to Ghostscript; clarified derivation from RFC 1321;
now handles byte order either statically or dynamically.
1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
added conditionalization for C++ compilation from Martin
Purschke .
1999-05-03 lpd Original version.
*/
#ifndef md5_INCLUDED
# define md5_INCLUDED
/*
* This package supports both compile-time and run-time determination of CPU
* byte order. If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be
* compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is
* defined as non-zero, the code will be compiled to run only on big-endian
* CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to
* run on either big- or little-endian CPUs, but will run slightly less
* efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined.
*/
typedef unsigned char md5_byte_t; /* 8-bit byte */
typedef unsigned int md5_word_t; /* 32-bit word */
/* Define the state of the MD5 Algorithm. */
typedef struct md5_state_s {
md5_word_t count[2]; /* message length in bits, lsw first */
md5_word_t abcd[4]; /* digest buffer */
md5_byte_t buf[64]; /* accumulate block */
} md5_state_t;
#ifdef __cplusplus
extern "C"
{
#endif
/* Initialize the algorithm. */
void belle_sip_md5_init(md5_state_t *pms);
/* Append a string to the message. */
void belle_sip_md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
/* Finish the message and return the digest. */
void belle_sip_md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
#ifdef __cplusplus
} /* end extern "C" */
#endif
#endif /* md5_INCLUDED */
belle-sip-1.6.3/src/message.c 0000664 0000000 0000000 00000131224 13134375224 0015763 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 .
*/
#include "grammars/belle_sip_messageLexer.h"
#include "grammars/belle_sip_messageParser.h"
#include "belle_sip_internal.h"
typedef struct _headers_container {
char* name;
belle_sip_list_t* header_list;
} headers_container_t;
/*reference is
* http://www.iana.org/assignments/sip-parameters/sip-parameters.xhtml#sip-parameters-2
*/
static const char * expand_name(const char *name){
const char *full_name=NULL;
if (strlen(name)>1) return name;
switch(name[0]){
case 'a':
full_name="Accept-Contact";
break;
case 'u':
full_name="Allow-Events";
break;
case 'e':
full_name="Content-Encoding";
break;
case 'o':
full_name="Event";
break;
case 'y':
full_name="Identity";
break;
case 'n':
full_name="Identity-Info";
break;
case 'r':
full_name="Refer-To";
break;
case 'b':
full_name="Referred-By";
break;
case 'j':
full_name="Reject-Contact";
break;
case 'd':
full_name="Request-Disposition";
break;
case 'x':
full_name="Session-Expires";
break;
case 's':
full_name="Subject";
break;
case 'k':
full_name="Supported";
break;
default:
full_name=name;
}
return full_name;
}
static headers_container_t* belle_sip_message_headers_container_new(const char* name) {
headers_container_t* headers_container = belle_sip_new0(headers_container_t);
headers_container->name = belle_sip_strdup(expand_name(name));
return headers_container;
}
static void belle_sip_headers_container_delete(headers_container_t *obj){
belle_sip_free(obj->name);
belle_sip_list_free_with_data(obj->header_list,(void (*)(void*))belle_sip_object_unref);
belle_sip_free(obj);
}
static void belle_sip_message_destroy(belle_sip_message_t *msg){
belle_sip_list_free_with_data(msg->header_list,(void (*)(void*))belle_sip_headers_container_delete);
if (msg->body_handler)
belle_sip_object_unref(msg->body_handler);
}
/*very sub-optimal clone method */
static void belle_sip_message_clone(belle_sip_message_t *obj, const belle_sip_message_t *orig){
headers_container_t *c;
const belle_sip_list_t *l;
for(l=orig->header_list;l!=NULL;l=l->next){
c=(headers_container_t*)l->data;
if (c->header_list){
belle_sip_list_t * ll=belle_sip_list_copy_with_data(c->header_list,(void *(*)(void*))belle_sip_object_clone);
belle_sip_message_add_headers(obj,ll);
belle_sip_list_free(ll);
}
}
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_message_t);
BELLE_SIP_INSTANCIATE_VPTR(belle_sip_message_t,belle_sip_object_t,belle_sip_message_destroy,belle_sip_message_clone,NULL,TRUE);
belle_sip_message_t* belle_sip_message_parse (const char* value) {
size_t message_length;
return belle_sip_message_parse_raw(value,strlen(value),&message_length);
}
belle_sip_message_t* belle_sip_message_parse_raw (const char* buff, size_t buff_length,size_t* message_length ) { \
pANTLR3_INPUT_STREAM input;
pbelle_sip_messageLexer lex;
pANTLR3_COMMON_TOKEN_STREAM tokens;
pbelle_sip_messageParser parser;
belle_sip_message_t* l_parsed_object;
input = ANTLR_STREAM_NEW("message",buff,buff_length);
lex = belle_sip_messageLexerNew (input);
tokens = antlr3CommonTokenStreamSourceNew (1025, lex->pLexer->rec->state->tokSource);
parser = belle_sip_messageParserNew (tokens);
l_parsed_object = parser->message_raw(parser,message_length);
/* if (*message_length < buff_length) {*/
/*there is a body*/
/* l_parsed_object->body_length=buff_length-*message_length;
l_parsed_object->body = belle_sip_malloc(l_parsed_object->body_length+1);
memcpy(l_parsed_object->body,buff+*message_length,l_parsed_object->body_length);
l_parsed_object->body[l_parsed_object->body_length]='\0';
}*/
parser ->free(parser);
tokens ->free(tokens);
lex ->free(lex);
input ->close(input);
return l_parsed_object;
}
static int belle_sip_headers_container_comp_func(const headers_container_t *a, const char*b) {
return strcasecmp(a->name,b);
}
void belle_sip_message_init(belle_sip_message_t *message){
}
headers_container_t* belle_sip_headers_container_get(const belle_sip_message_t* message,const char* header_name) {
belle_sip_list_t * result = belle_sip_list_find_custom( message->header_list
, (belle_sip_compare_func)belle_sip_headers_container_comp_func
, header_name);
return result?(headers_container_t*)(result->data):NULL;
}
headers_container_t * get_or_create_container(belle_sip_message_t *message, const char *header_name){
// first check if already exist
headers_container_t* headers_container = belle_sip_headers_container_get(message,header_name);
if (headers_container == NULL) {
headers_container = belle_sip_message_headers_container_new(header_name);
message->header_list=belle_sip_list_append(message->header_list,headers_container);
}
return headers_container;
}
void belle_sip_message_add_first(belle_sip_message_t *message,belle_sip_header_t* header) {
headers_container_t *headers_container=get_or_create_container(message,belle_sip_header_get_name(header));
headers_container->header_list=belle_sip_list_prepend(headers_container->header_list,belle_sip_object_ref(header));
}
void belle_sip_message_add_header(belle_sip_message_t *message,belle_sip_header_t* header) {
headers_container_t *headers_container=get_or_create_container(message,belle_sip_header_get_name(header));
headers_container->header_list=belle_sip_list_append(headers_container->header_list,belle_sip_object_ref(header));
}
void belle_sip_message_add_headers(belle_sip_message_t *message, const belle_sip_list_t *header_list){
const char *hname;
headers_container_t *headers_container;
if (header_list == NULL) return;
hname=belle_sip_header_get_name(BELLE_SIP_HEADER((header_list->data)));
headers_container=get_or_create_container(message,hname);
for(;header_list!=NULL;header_list=header_list->next){
belle_sip_header_t *h=BELLE_SIP_HEADER(header_list->data);
if (strcmp(belle_sip_header_get_name(h),hname)!=0){
belle_sip_fatal("Bad use of belle_sip_message_add_headers(): all headers of the list must be of the same type.");
return ;
}
headers_container->header_list=belle_sip_list_append(headers_container->header_list,belle_sip_object_ref(h));
}
}
void belle_sip_message_set_header(belle_sip_message_t *msg, belle_sip_header_t* header){
headers_container_t *headers_container=get_or_create_container(msg,belle_sip_header_get_name(header));
belle_sip_object_ref(header);
headers_container->header_list=belle_sip_list_free_with_data(headers_container->header_list,belle_sip_object_unref);
headers_container->header_list=belle_sip_list_append(headers_container->header_list,header);
}
const belle_sip_list_t* belle_sip_message_get_headers(const belle_sip_message_t *message,const char* header_name) {
headers_container_t* headers_container = belle_sip_headers_container_get(message,header_name);
return headers_container ? headers_container->header_list:NULL;
}
belle_sip_object_t *_belle_sip_message_get_header_by_type_id(const belle_sip_message_t *message, belle_sip_type_id_t id){
const belle_sip_list_t *e1;
for(e1=message->header_list;e1!=NULL;e1=e1->next){
headers_container_t* headers_container=(headers_container_t*)e1->data;
if (headers_container->header_list){
belle_sip_object_t *ret=headers_container->header_list->data;
if (ret->vptr->id==id) return ret;
}
}
return NULL;
}
void belle_sip_message_remove_first(belle_sip_message_t *msg, const char *header_name){
headers_container_t* headers_container = belle_sip_headers_container_get(msg,header_name);
if (headers_container && headers_container->header_list){
belle_sip_list_t *to_be_removed=headers_container->header_list;
headers_container->header_list=belle_sip_list_remove_link(headers_container->header_list,to_be_removed);
belle_sip_list_free_with_data(to_be_removed,belle_sip_object_unref);
}
}
void belle_sip_message_remove_last(belle_sip_message_t *msg, const char *header_name){
headers_container_t* headers_container = belle_sip_headers_container_get(msg,header_name);
if (headers_container && headers_container->header_list){
belle_sip_list_t *to_be_removed=belle_sip_list_last_elem(headers_container->header_list);
headers_container->header_list=belle_sip_list_remove_link(headers_container->header_list,to_be_removed);
belle_sip_list_free_with_data(to_be_removed,belle_sip_object_unref);
}
}
void belle_sip_message_remove_header(belle_sip_message_t *msg, const char *header_name){
headers_container_t* headers_container = belle_sip_headers_container_get(msg,header_name);
if (headers_container){
msg->header_list = belle_sip_list_remove(msg->header_list,headers_container);
belle_sip_headers_container_delete(headers_container);
}
}
void belle_sip_message_remove_header_from_ptr(belle_sip_message_t *msg, belle_sip_header_t* header) {
headers_container_t* headers_container = belle_sip_headers_container_get(msg,belle_sip_header_get_name(header));
belle_sip_list_t* it;
it=belle_sip_list_find(headers_container->header_list,header);
if (it) {
belle_sip_object_unref(header);
headers_container->header_list=belle_sip_list_delete_link(headers_container->header_list,it);
if (belle_sip_list_size(headers_container->header_list) == 0) {
msg->header_list = belle_sip_list_remove(msg->header_list,headers_container);
belle_sip_headers_container_delete(headers_container);
}
}
}
/*
belle_sip_error_code belle_sip_message_named_headers_marshal(belle_sip_message_t *message, const char* header_name, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=BELLE_SIP_OK;
belle_sip_list_t* header_list = belle_sip_message_get_headers(message,header_name);
if (!header_list) {
belle_sip_error("headers [%s] not found",header_name);
return 0;
}
for(;header_list!=NULL;header_list=header_list->next){
belle_sip_header_t *h=BELLE_SIP_HEADER(header_list->data);
error=belle_sip_object_marshal(BELLE_SIP_OBJECT(h),buff,buff_size,offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s","\r\n");
if (error!=BELLE_SIP_OK) return error;
}
return error;
}
#define MARSHAL_AND_CHECK_HEADER(header) \
if (current_offset == (current_offset+=(header))) {\
belle_sip_error("missing mandatory header");\
return current_offset;\
} else {\
current_offset+=snprintf(buff+current_offset,buff_size-current_offset,"%s","\r\n");\
}
*/
typedef void (*each_header_cb)(const belle_sip_header_t* header,void* userdata);
static void belle_sip_message_for_each_header(const belle_sip_message_t *message,each_header_cb cb,void* user_data) {
belle_sip_list_t* headers_list;
belle_sip_list_t* header_list;
for(headers_list=message->header_list;headers_list!=NULL;headers_list=headers_list->next){
for(header_list=((headers_container_t*)(headers_list->data))->header_list
;header_list!=NULL
;header_list=header_list->next) {
cb(BELLE_SIP_HEADER(header_list->data),user_data);
}
}
return;
}
static void append_header(const belle_sip_header_t* header,void* user_data) {
*(belle_sip_list_t**)user_data=belle_sip_list_append((*(belle_sip_list_t**)user_data),(void*)header);
}
belle_sip_list_t* belle_sip_message_get_all_headers(const belle_sip_message_t *message) {
belle_sip_list_t* headers=NULL;
belle_sip_message_for_each_header(message,append_header,&headers);
return headers;
}
belle_sip_error_code belle_sip_headers_marshal(belle_sip_message_t *message, char* buff, size_t buff_size, size_t *offset) {
/*FIXME, replace this code by belle_sip_message_for_each_header*/
belle_sip_list_t* headers_list;
belle_sip_list_t* header_list;
belle_sip_error_code error=BELLE_SIP_OK;
#ifdef BELLE_SIP_WORKAROUND_TECHNICOLOR_SIP_ALG_ROUTER_BUG
belle_sip_header_t *content_length=NULL;
#endif
for(headers_list=message->header_list;headers_list!=NULL;headers_list=headers_list->next){
for(header_list=((headers_container_t*)(headers_list->data))->header_list
;header_list!=NULL
;header_list=header_list->next) {
belle_sip_header_t *h=BELLE_SIP_HEADER(header_list->data);
#ifdef BELLE_SIP_WORKAROUND_TECHNICOLOR_SIP_ALG_ROUTER_BUG
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(h,belle_sip_header_content_length_t)){
content_length=h;
}else
#endif
{
while (h!=NULL) { /*header can be chained*/
error=belle_sip_object_marshal(BELLE_SIP_OBJECT(h),buff,buff_size,offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s","\r\n");
if (error!=BELLE_SIP_OK) return error;
h= belle_sip_header_get_next(h);
}
}
}
}
#ifdef BELLE_SIP_WORKAROUND_TECHNICOLOR_SIP_ALG_ROUTER_BUG
if (content_length){
error=belle_sip_object_marshal(BELLE_SIP_OBJECT(content_length),buff,buff_size,offset);
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset,"%s","\r\n");
if (error!=BELLE_SIP_OK) return error;
}
#endif
error=belle_sip_snprintf(buff,buff_size,offset,"%s","\r\n");
if (error!=BELLE_SIP_OK) return error;
return error;
}
static void belle_sip_request_destroy(belle_sip_request_t* request) {
if (request->method) belle_sip_free(request->method);
if (request->uri) belle_sip_object_unref(request->uri);
if (request->absolute_uri) belle_sip_object_unref(request->absolute_uri);
if (request->dialog) belle_sip_object_unref(request->dialog);
if (request->rfc2543_branch) belle_sip_free(request->rfc2543_branch);
}
static void belle_sip_request_init(belle_sip_request_t *message){
}
static void belle_sip_request_clone(belle_sip_request_t *request, const belle_sip_request_t *orig){
if (orig->method) request->method=belle_sip_strdup(orig->method);
if (orig->uri) request->uri=(belle_sip_uri_t*)belle_sip_object_ref(belle_sip_object_clone((belle_sip_object_t*)orig->uri));
if (orig->absolute_uri) request->absolute_uri=(belle_generic_uri_t*)belle_sip_object_ref(belle_sip_object_clone((belle_sip_object_t*)orig->absolute_uri));
if (orig->rfc2543_branch) request->rfc2543_branch=belle_sip_strdup(orig->rfc2543_branch);
}
belle_sip_error_code belle_sip_request_marshal(belle_sip_request_t* request, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_snprintf(buff,buff_size,offset,"%s ",belle_sip_request_get_method(request) ? belle_sip_request_get_method(request) : "");
if (error!=BELLE_SIP_OK) return error;
if (request->uri)
error=belle_sip_uri_marshal(belle_sip_request_get_uri(request),buff,buff_size,offset);
else if (request->absolute_uri)
error=belle_generic_uri_marshal(belle_sip_request_get_absolute_uri(request),buff,buff_size,offset);
else {
belle_sip_error("Missing uri for marshaling request [%p]",request);
/*fixme better to have an error code*/
error=BELLE_SIP_OK;
}
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_snprintf(buff,buff_size,offset," %s","SIP/2.0\r\n");
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_headers_marshal(BELLE_SIP_MESSAGE(request),buff,buff_size,offset);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW(request,message)
BELLE_SIP_PARSE(request)
GET_SET_STRING(belle_sip_request,method);
GET_SET_STRING(belle_sip_request,rfc2543_branch);
/*caching of the dialog in the request, used when creating a request in dialog to avoid dialog lookup*/
void belle_sip_request_set_dialog(belle_sip_request_t *req, belle_sip_dialog_t *dialog){
SET_OBJECT_PROPERTY(req,dialog,dialog);
}
void belle_sip_request_set_uri(belle_sip_request_t* request,belle_sip_uri_t* uri) {
SET_OBJECT_PROPERTY(request,uri,uri);
if (request->absolute_uri && uri) {
belle_sip_warning("absolute uri [%p] already set for request [%p], cleaning it",request->absolute_uri, request);
belle_sip_request_set_absolute_uri(request,NULL);
}
}
belle_sip_uri_t * belle_sip_request_get_uri(const belle_sip_request_t *request){
return request->uri;
}
void belle_sip_request_set_absolute_uri(belle_sip_request_t* request,belle_generic_uri_t* absolute_uri) {
SET_OBJECT_PROPERTY(request,absolute_uri,absolute_uri);
if (request->uri && absolute_uri) {
belle_sip_warning("sip uri [%p] already set for request [%p], cleaning it",request->uri, request);
belle_sip_request_set_uri(request,NULL);
}
}
belle_generic_uri_t * belle_sip_request_get_absolute_uri(const belle_sip_request_t *request){
return request->absolute_uri;
}
belle_sip_uri_t* belle_sip_request_extract_origin(const belle_sip_request_t* req) {
belle_sip_header_via_t* via_header = belle_sip_message_get_header_by_type(req,belle_sip_header_via_t);
belle_sip_uri_t* uri=NULL;
const char* received = belle_sip_header_via_get_received(via_header);
int rport = belle_sip_header_via_get_rport(via_header);
uri = belle_sip_uri_new();
if (received!=NULL) {
belle_sip_uri_set_host(uri,received);
} else {
belle_sip_uri_set_host(uri,belle_sip_header_via_get_host(via_header));
}
if (rport>0) {
belle_sip_uri_set_port(uri,rport);
} else if (belle_sip_header_via_get_port(via_header)) {
belle_sip_uri_set_port(uri,belle_sip_header_via_get_port(via_header));
}
if (belle_sip_header_via_get_transport(via_header)) {
belle_sip_uri_set_transport_param(uri,belle_sip_header_via_get_transport_lowercase(via_header));
}
return uri;
}
int belle_sip_message_is_request(belle_sip_message_t *msg){
return BELLE_SIP_IS_INSTANCE_OF(BELLE_SIP_OBJECT(msg),belle_sip_request_t);
}
int belle_sip_message_is_response(const belle_sip_message_t *msg){
return BELLE_SIP_IS_INSTANCE_OF(BELLE_SIP_OBJECT(msg),belle_sip_response_t);
}
belle_sip_header_t *belle_sip_message_get_header(const belle_sip_message_t *msg, const char *header_name){
const belle_sip_list_t *l=belle_sip_message_get_headers(msg,header_name);
if (l!=NULL)
return (belle_sip_header_t*)l->data;
return NULL;
}
char *belle_sip_message_to_string(belle_sip_message_t *msg){
return belle_sip_object_to_string(BELLE_SIP_OBJECT(msg));
}
belle_sip_body_handler_t *belle_sip_message_get_body_handler(const belle_sip_message_t *msg){
return msg->body_handler;
}
void belle_sip_message_set_body_handler(belle_sip_message_t *msg, belle_sip_body_handler_t *body_handler){
belle_sip_header_content_length_t *content_length_header = belle_sip_message_get_header_by_type(msg, belle_sip_header_content_length_t);
belle_sip_header_content_type_t *content_type_header = belle_sip_message_get_header_by_type(msg, belle_sip_header_content_type_t);
/* In case of multipart message, we must add the message Content-Type header containing the boundary */
if (body_handler != NULL) {
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(body_handler, belle_sip_multipart_body_handler_t)){
belle_sip_multipart_body_handler_t *multipart_body_handler = BELLE_SIP_MULTIPART_BODY_HANDLER(body_handler);
belle_sip_header_content_type_t * content_type = belle_sip_header_content_type_new();
belle_sip_header_content_type_set_type(content_type, "multipart");
if (belle_sip_multipart_body_handler_is_related(multipart_body_handler)) {
const belle_sip_list_t *parts = belle_sip_multipart_body_handler_get_parts(multipart_body_handler);
if (parts) {
belle_sip_body_handler_t *first_part=BELLE_SIP_BODY_HANDLER(parts->data);
const belle_sip_list_t *first_part_headers = belle_sip_body_handler_get_headers(first_part);
belle_sip_list_t *it;
belle_sip_header_content_type_t *first_part_content_type=NULL;;
for(it = (belle_sip_list_t *)first_part_headers;it!=NULL;it=it->next) {
belle_sip_header_t *header = BELLE_SIP_HEADER(it->data);
if(strcasecmp("Content-Type",belle_sip_header_get_name(header)) == 0) {
first_part_content_type=BELLE_SIP_HEADER_CONTENT_TYPE(header);
break;
}
}
if (first_part_content_type) {
char *type_slash_subtype = belle_sip_strdup_printf("%s/%s"
, belle_sip_header_content_type_get_type(first_part_content_type)
, belle_sip_header_content_type_get_subtype(first_part_content_type));
belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS(content_type), "type", type_slash_subtype);
belle_sip_free(type_slash_subtype);
} else {
belle_sip_error("Multipart related body handler [%p] cannot be set without first part content type header",body_handler);
}
} else {
belle_sip_error("Multipart related body handler [%p] cannot be set without first part",body_handler);
}
belle_sip_header_content_type_set_subtype(content_type, "related");
} else {
belle_sip_header_content_type_set_subtype(content_type, "form-data");
}
belle_sip_parameters_set_parameter(BELLE_SIP_PARAMETERS(content_type), "boundary", BELLESIP_MULTIPART_BOUNDARY);
belle_sip_message_add_header(BELLE_SIP_MESSAGE(msg), BELLE_SIP_HEADER(content_type));
} else {
const belle_sip_list_t *headers = belle_sip_body_handler_get_headers(body_handler);
for(; headers != NULL; headers = headers->next) {
belle_sip_header_t *header = BELLE_SIP_HEADER(headers->data);
if (strcasecmp(belle_sip_header_get_name(header),BELLE_SIP_CONTENT_LENGTH ) == 0 && content_length_header)
belle_sip_message_remove_header_from_ptr(msg, BELLE_SIP_HEADER(content_length_header));
if (strcasecmp(belle_sip_header_get_name(header),BELLE_SIP_CONTENT_TYPE ) == 0 && content_type_header)
belle_sip_message_remove_header_from_ptr(msg, BELLE_SIP_HEADER(content_type_header));
belle_sip_message_add_header(BELLE_SIP_MESSAGE(msg), header);
}
}
} else {
if (content_length_header != NULL) belle_sip_message_remove_header_from_ptr(msg, BELLE_SIP_HEADER(content_length_header));
if (content_type_header != NULL) belle_sip_message_remove_header_from_ptr(msg, BELLE_SIP_HEADER(content_type_header));
}
SET_OBJECT_PROPERTY(msg,body_handler,body_handler);
}
const char* belle_sip_message_get_body(belle_sip_message_t *msg) {
if (msg->body_handler==NULL) return NULL;
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(msg->body_handler, belle_sip_memory_body_handler_t)){
return (const char*)belle_sip_memory_body_handler_get_buffer(
BELLE_SIP_MEMORY_BODY_HANDLER(msg->body_handler)
);
}
belle_sip_error("belle_sip_message_get_body(): body cannot be returned as pointer.");
return NULL;
}
size_t belle_sip_message_get_body_size(const belle_sip_message_t *msg){
if (msg->body_handler==NULL) return 0;
return belle_sip_body_handler_get_size(msg->body_handler);
}
void belle_sip_message_set_body(belle_sip_message_t *msg, const char* body, size_t size) {
belle_sip_body_handler_t *bh=NULL;
if (body && size) bh=(belle_sip_body_handler_t*)belle_sip_memory_body_handler_new_copy_from_buffer(body,size,NULL,NULL);
belle_sip_message_set_body_handler(msg,bh);
}
void belle_sip_message_assign_body(belle_sip_message_t *msg, char* body, size_t size) {
belle_sip_body_handler_t *bh=(belle_sip_body_handler_t*)belle_sip_memory_body_handler_new_from_buffer(body,size,NULL,NULL);
belle_sip_message_set_body_handler(msg,bh);
}
struct _belle_sip_response{
belle_sip_message_t base;
char *sip_version;
int status_code;
char *reason_phrase;
};
typedef struct code_phrase{
int code;
const char *phrase;
} code_phrase_t;
static code_phrase_t well_known_codes[]={
{ 100 , "Trying" },
{ 101 , "Dialog establishment" },
{ 180 , "Ringing" },
{ 181 , "Call is being forwarded" },
{ 182 , "Queued" },
{ 183 , "Session progress" },
{ 200 , "Ok" },
{ 202 , "Accepted" },
{ 300 , "Multiple choices" },
{ 301 , "Moved permanently" },
{ 302 , "Moved temporarily" },
{ 305 , "Use proxy" },
{ 380 , "Alternate contact" },
{ 400 , "Bad request" },
{ 401 , "Unauthorized" },
{ 402 , "Payment required" },
{ 403 , "Forbidden" },
{ 404 , "Not found" },
{ 405 , "Method not allowed" },
{ 406 , "Not acceptable" },
{ 407 , "Proxy authentication required" },
{ 408 , "Request timeout" },
{ 410 , "Gone" },
{ 412 , "Conditional Request Failed" }, /*rfc3903*/
{ 413 , "Request entity too large" },
{ 414 , "Request-URI too long" },
{ 415 , "Unsupported media type" },
{ 416 , "Unsupported URI scheme" },
{ 420 , "Bad extension" },
{ 421 , "Extension required" },
{ 423 , "Interval too brief" },
{ 480 , "Temporarily unavailable" },
{ 481 , "Call/transaction does not exist" },
{ 482 , "Loop detected" },
{ 483 , "Too many hops" },
{ 484 , "Address incomplete" },
{ 485 , "Ambiguous" },
{ 486 , "Busy here" },
{ 487 , "Request terminated" },
{ 488 , "Not acceptable here" },
{ 489 , "Bad Event" }, /*rfc3265*/
{ 491 , "Request pending" },
{ 493 , "Undecipherable" },
{ 500 , "Server internal error" },
{ 501 , "Not implemented" },
{ 502 , "Bad gateway" },
{ 503 , "Service unavailable" },
{ 504 , "Server time-out" },
{ 505 , "Version not supported" },
{ 513 , "Message too large" },
{ 600 , "Busy everywhere" },
{ 603 , "Decline" },
{ 604 , "Does not exist anywhere" },
{ 606 , "Not acceptable" },
{ 0 , NULL }
};
const char *belle_sip_get_well_known_reason_phrase(int status_code){
int i;
for(i=0;well_known_codes[i].code!=0;++i){
if (well_known_codes[i].code==status_code)
return well_known_codes[i].phrase;
}
return "Unknown reason";
}
void belle_sip_response_destroy(belle_sip_response_t *resp){
if (resp->sip_version) belle_sip_free(resp->sip_version);
if (resp->reason_phrase) belle_sip_free(resp->reason_phrase);
}
static void belle_sip_response_init(belle_sip_response_t *resp){
}
static void belle_sip_response_clone(belle_sip_response_t *resp, const belle_sip_response_t *orig){
if (orig->sip_version) resp->sip_version=belle_sip_strdup(orig->sip_version);
if (orig->reason_phrase) resp->reason_phrase=belle_sip_strdup(orig->reason_phrase);
}
belle_sip_error_code belle_sip_response_marshal(belle_sip_response_t *resp, char* buff, size_t buff_size, size_t *offset) {
belle_sip_error_code error=belle_sip_snprintf( buff
,buff_size
,offset
,"SIP/2.0 %i %s\r\n"
,belle_sip_response_get_status_code(resp)
,belle_sip_response_get_reason_phrase(resp)?belle_sip_response_get_reason_phrase(resp):"");
if (error!=BELLE_SIP_OK) return error;
error=belle_sip_headers_marshal(BELLE_SIP_MESSAGE(resp),buff,buff_size,offset);
if (error!=BELLE_SIP_OK) return error;
return error;
}
BELLE_SIP_NEW(response,message);
BELLE_SIP_PARSE(response)
GET_SET_STRING(belle_sip_response,reason_phrase);
GET_SET_INT(belle_sip_response,status_code,int)
static int is_authorized_uri_header(const char* header_name) {
/*From, Call-ID, CSeq, Via, and Record-Route*/
/*Accept, Accept-Encoding, Accept-Language, Allow,
Contact (in its dialog usage), Organization, Supported, and User-Agent*/
return (strcasecmp("From",header_name) != 0
&& strcasecmp("Call-ID",header_name) != 0
&& strcasecmp("CSeq",header_name) != 0
&& strcasecmp("Via",header_name) != 0
&& strcasecmp("Record-Route",header_name) != 0
&& strcasecmp("Accept",header_name) != 0
&& strcasecmp("Accept-Encoding",header_name) != 0
&& strcasecmp("Accept-Language",header_name) != 0
&& strcasecmp("Allow",header_name) != 0
&& strcasecmp("Contact",header_name) != 0
&& strcasecmp("Organization",header_name) != 0
&& strcasecmp("Supported",header_name) != 0
&& strcasecmp("User-Agent",header_name) != 0);
}
belle_sip_request_t* belle_sip_request_create(belle_sip_uri_t *requri, const char* method,
belle_sip_header_call_id_t *callid,
belle_sip_header_cseq_t * cseq,
belle_sip_header_from_t *from,
belle_sip_header_to_t *to,
belle_sip_header_via_t *via,
int max_forward)
{
belle_sip_request_t *ret=belle_sip_request_new();
belle_sip_header_max_forwards_t *mf=belle_sip_header_max_forwards_new();
belle_sip_list_t* iterator;
if (max_forward==0) max_forward=70;
belle_sip_header_max_forwards_set_max_forwards(mf,max_forward);
belle_sip_request_set_method(ret,method);
belle_sip_message_add_header((belle_sip_message_t*)ret,BELLE_SIP_HEADER(via));
belle_sip_message_add_header((belle_sip_message_t*)ret,BELLE_SIP_HEADER(from));
if (to) belle_sip_message_add_header((belle_sip_message_t*)ret,BELLE_SIP_HEADER(to)); /*to might be in header uri*/
belle_sip_message_add_header((belle_sip_message_t*)ret,BELLE_SIP_HEADER(cseq));
belle_sip_message_add_header((belle_sip_message_t*)ret,BELLE_SIP_HEADER(callid));
if (!belle_sip_message_get_header_by_type(ret,belle_sip_header_max_forwards_t))
belle_sip_message_add_header((belle_sip_message_t*)ret,BELLE_SIP_HEADER(mf));
else
belle_sip_object_unref(mf);
/*
19.1.5 Forming Requests from a URI
An implementation needs to take care when forming requests directly
from a URI. URIs from business cards, web pages, and even from
sources inside the protocol such as registered contacts may contain
inappropriate header fields or body parts.
An implementation MUST include any provided transport, maddr, ttl, or
user parameter in the Request-URI of the formed request. If the URI
contains a method parameter, its value MUST be used as the method of
the request. The method parameter MUST NOT be placed in the
Request-URI. Unknown URI parameters MUST be placed in the message's
Request-URI.
An implementation SHOULD treat the presence of any headers or body
parts in the URI as a desire to include them in the message, and
choose to honor the request on a per-component basis.
An implementation SHOULD NOT honor these obviously dangerous header
fields: From, Call-ID, CSeq, Via, and Record-Route.
An implementation SHOULD NOT honor any requested Route header field
values in order to not be used as an unwitting agent in malicious
attacks.
An implementation SHOULD NOT honor requests to include header fields
that may cause it to falsely advertise its location or capabilities.
These include: Accept, Accept-Encoding, Accept-Language, Allow,
Contact (in its dialog usage), Organization, Supported, and User-
Agent.
An implementation SHOULD verify the accuracy of any requested
descriptive header fields, including: Content-Disposition, Content-
Encoding, Content-Language, Content-Length, Content-Type, Date,
Mime-Version, and Timestamp.*/
if (belle_sip_uri_get_header_names(requri)) {
for (iterator=(belle_sip_list_t*)belle_sip_uri_get_header_names(requri);iterator!=NULL;iterator=iterator->next) {
const char* header_name=(const char*)iterator->data;
/*1 check header name*/
if (is_authorized_uri_header(header_name)) {
belle_sip_header_extension_t* extended_header = belle_sip_header_extension_create(header_name, belle_sip_uri_get_header(requri, header_name));
if (extended_header) {
belle_sip_message_add_header((belle_sip_message_t*)ret,BELLE_SIP_HEADER(extended_header));
}
} else {
belle_sip_warning("Skiping uri header [%s] for request [%p]",header_name,requri);
}
}
}
belle_sip_uri_headers_clean(requri); /*remove all headers*/
belle_sip_request_set_uri(ret,requri);
return ret;
}
static void belle_sip_response_init_default(belle_sip_response_t *resp, int status_code, const char *phrase){
resp->status_code=status_code;
resp->sip_version=belle_sip_strdup("SIP/2.0");
if (phrase==NULL) phrase=belle_sip_get_well_known_reason_phrase(status_code);
resp->reason_phrase=belle_sip_strdup(phrase);
}
/*
* note: we must not assume the request to be well formed because this function may be used to generate 400 Bad request response.
*/
belle_sip_response_t *belle_sip_response_create_from_request(belle_sip_request_t *req, int status_code){
belle_sip_response_t *resp=belle_sip_response_new();
belle_sip_header_t *h;
belle_sip_header_to_t *to;
const belle_sip_list_t *vias;
belle_sip_response_init_default(resp,status_code,NULL);
if (status_code==100 && (h=belle_sip_message_get_header((belle_sip_message_t*)req,"timestamp"))){
belle_sip_message_add_header((belle_sip_message_t*)resp,h);
}
vias=belle_sip_message_get_headers ((belle_sip_message_t*)req,"via");
belle_sip_message_add_headers((belle_sip_message_t*)resp,vias);
h=belle_sip_message_get_header((belle_sip_message_t*)req,"from");
if (h) belle_sip_message_add_header((belle_sip_message_t*)resp,h);
h=belle_sip_message_get_header((belle_sip_message_t*)req,"to");
if (h){
if (status_code!=100){
//so that to tag can be added
to=(belle_sip_header_to_t*)belle_sip_object_clone((belle_sip_object_t*)h);
}else{
to=(belle_sip_header_to_t*)h;
}
belle_sip_message_add_header((belle_sip_message_t*)resp,(belle_sip_header_t*)to);
}
h=belle_sip_message_get_header((belle_sip_message_t*)req,"call-id");
if (h) belle_sip_message_add_header((belle_sip_message_t*)resp,h);
h=belle_sip_message_get_header((belle_sip_message_t*)req,"cseq");
if (h){
belle_sip_message_add_header((belle_sip_message_t*)resp,h);
}
return resp;
}
/*
12.1.1 UAS behavior
When a UAS responds to a request with a response that establishes a
dialog (such as a 2xx to INVITE), the UAS MUST copy all Record-Route
header field values from the request into the response (including the
URIs, URI parameters, and any Record-Route header field parameters,
whether they are known or unknown to the UAS) and MUST maintain the
order of those values.
*/
void belle_sip_response_fill_for_dialog(belle_sip_response_t *obj, belle_sip_request_t *req){
const belle_sip_list_t *rr=belle_sip_message_get_headers((belle_sip_message_t*)req,BELLE_SIP_RECORD_ROUTE);
belle_sip_header_contact_t *ct=belle_sip_message_get_header_by_type(obj,belle_sip_header_contact_t);
belle_sip_message_remove_header((belle_sip_message_t*)obj,BELLE_SIP_RECORD_ROUTE);
if (rr)
belle_sip_message_add_headers((belle_sip_message_t*)obj,rr);
if (belle_sip_response_get_status_code(obj)>=200 && belle_sip_response_get_status_code(obj)<300 && !ct){
const char *method=belle_sip_request_get_method(req);
if (strcmp(method,"INVITE")==0 || strcmp(method,"SUBSCRIBE")==0){
/*add a dummy contact to be filled by channel later*/
belle_sip_message_add_header((belle_sip_message_t*)obj,(belle_sip_header_t*)belle_sip_header_contact_new());
}
}
}
belle_sip_hop_t* belle_sip_response_get_return_hop(belle_sip_response_t *msg){
belle_sip_header_via_t *via=BELLE_SIP_HEADER_VIA(belle_sip_message_get_header(BELLE_SIP_MESSAGE(msg),"via"));
if (via){
const char *host=belle_sip_header_via_get_received(via) ? belle_sip_header_via_get_received(via) : belle_sip_header_via_get_host(via);
int port=belle_sip_header_via_get_rport(via)>0 ? belle_sip_header_via_get_rport(via) : belle_sip_header_via_get_listening_port(via);
return belle_sip_hop_new(belle_sip_header_via_get_transport_lowercase(via),NULL,host,port);
}
return NULL;
}
int belle_sip_response_fix_contact(const belle_sip_response_t* response,belle_sip_header_contact_t* contact) {
belle_sip_header_via_t* via_header;
belle_sip_uri_t* contact_uri;
const char* received;
int rport;
int contact_port;
/*first check received/rport*/
via_header= (belle_sip_header_via_t*)belle_sip_message_get_header(BELLE_SIP_MESSAGE(response),BELLE_SIP_VIA);
received = belle_sip_header_via_get_received(via_header);
rport = belle_sip_header_via_get_rport(via_header);
contact_uri=belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(contact));
if (received) {
/*need to update host*/
belle_sip_uri_set_host(contact_uri,received);
} else {
belle_sip_uri_set_host(contact_uri,belle_sip_header_via_get_host(via_header));
}
contact_port = belle_sip_uri_get_port(contact_uri);
if (rport>0 ) {
/*need to update port*/
if ((rport+contact_port)!=5060) belle_sip_uri_set_port(contact_uri,rport);
} else if ((belle_sip_header_via_get_port(via_header)+contact_port)!=5060) {
belle_sip_uri_set_port(contact_uri,belle_sip_header_via_get_port(via_header));
}
/*try to fix transport if needed (very unlikely)*/
if (strcasecmp(belle_sip_header_via_get_transport(via_header),"UDP")!=0) {
if (!belle_sip_uri_get_transport_param(contact_uri)
||strcasecmp(belle_sip_uri_get_transport_param(contact_uri),belle_sip_header_via_get_transport(via_header))!=0) {
belle_sip_uri_set_transport_param(contact_uri,belle_sip_header_via_get_transport_lowercase(via_header));
}
} else {
if (belle_sip_uri_get_transport_param(contact_uri)) {
belle_sip_uri_set_transport_param(contact_uri,NULL);
}
}
return 0;
}
belle_sip_request_t * belle_sip_request_clone_with_body(const belle_sip_request_t *initial_req) {
belle_sip_request_t* req=BELLE_SIP_REQUEST(belle_sip_object_clone(BELLE_SIP_OBJECT(initial_req)));
if (initial_req->base.body_handler) req->base.body_handler=BELLE_SIP_BODY_HANDLER(belle_sip_object_clone_and_ref(
(belle_sip_object_t*)initial_req->base.body_handler));
return req;
}
typedef struct message_header_list {
const char* method;
const char* headers[10]; /*MAX headers*/
} message_header_list_t;
/**
RFC 3261 SIP: Session Initiation Protocol June 2002
Header field where proxy ACK BYE CAN INV OPT REG
__________________________________________________________________
Accept R - o - o m* o
Accept 2xx - - - o m* o
Accept 415 - c - c c c
Accept-Encoding R - o - o o o
Accept-Encoding 2xx - - - o m* o
Accept-Encoding 415 - c - c c c
Accept-Language R - o - o o o
Accept-Language 2xx - - - o m* o
Accept-Language 415 - c - c c c
Alert-Info R ar - - - o - -
Alert-Info 180 ar - - - o - -
Allow R - o - o o o
Allow 2xx - o - m* m* o
Allow r - o - o o o
Allow 405 - m - m m m
Authentication-Info 2xx - o - o o o
Authorization R o o o o o o
Call-ID c r m m m m m m
Call-Info ar - - - o o o
Contact R o - - m o o
Contact 1xx - - - o - -
Contact 2xx - - - m o o
Contact 3xx d - o - o o o
Contact 485 - o - o o o
Content-Disposition o o - o o o
Content-Encoding o o - o o o
Content-Language o o - o o o
Content-Length ar t t t t t t
Content-Type * * - * * *
CSeq c r m m m m m m
Date a o o o o o o
Error-Info 300-699 a - o o o o o
Expires - - - o - o
From c r m m m m m m
In-Reply-To R - - - o - -
Max-Forwards R amr m m m m m m
Min-Expires 423 - - - - - m
MIME-Version o o - o o o
Organization ar - - - o o o
Priority R ar - - - o - -
Proxy-Authenticate 407 ar - m - m m m
Proxy-Authenticate 401 ar - o o o o o
Proxy-Authorization R dr o o - o o o
Proxy-Require R ar - o - o o o
Record-Route R ar o o o o o -
Record-Route 2xx,18x mr - o o o o -
Reply-To - - - o - -
Require ar - c - c c c
Retry-After 404,413,480,486 - o o o o o
500,503 - o o o o o
600,603 - o o o o o
Route R adr c c c c c c
Server r - o o o o o
Subject R - - - o - -
Supported R - o o m* o o
Supported 2xx - o o m* m* o
Timestamp o o o o o o
To c(1) r m m m m m m
Unsupported 420 - m - m m m
User-Agent o o o o o o
Via R amr m m m m m m
Via rc dr m m m m m m
Warning r - o o o o o
WWW-Authenticate 401 ar - m - m m m
WWW-Authenticate 407 ar - o - o o o
Table 3: Summary of header fields, A--Z; (1): copied with possible
addition of tag
*/
static message_header_list_t mandatory_headers[] = {
{"REGISTER",{"Call-ID","CSeq","From", "Max-Forwards","To","Via",NULL}},
{"INVITE",{"Contact","Call-ID","CSeq","From", "Max-Forwards","To","Via",NULL}},
{"CANCEL",{"Call-ID","CSeq","From", "Max-Forwards","To","Via",NULL}},
{"BYE",{"Call-ID","CSeq","From", "Max-Forwards","To","Via",NULL}},
{"ACK",{"Call-ID","CSeq","From", "Max-Forwards","To","Via",NULL}},
{"*", { "To", "From", "CSeq", "Via", NULL}}, /* catch-all, these fields are required all the time. */
{NULL,{NULL}}
};
/*static int belle_sip_message_is_mandatody_header(const char* method, const char* header_name) {
int i;
for (i=0;mandatory_headers[i].method!=NULL;i++) {
if (strcasecmp(method,mandatory_headers[i].method)==0) {
int j;
for(j=0;mandatory_headers[i].headers[j]!=NULL;j++) {
if (strcasecmp(header_name,mandatory_headers[i].headers[j])==0) {
return 1;
}
}
}
}
return 0;
}
*/
int belle_sip_message_check_headers(const belle_sip_message_t* message) {
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(message,belle_sip_request_t)) {
int i;
belle_sip_header_via_t *via;
const char * method = belle_sip_request_get_method(BELLE_SIP_REQUEST(message));
for (i=0;mandatory_headers[i].method!=NULL;i++) {
if ( (strcasecmp(method,mandatory_headers[i].method)==0) ||
(mandatory_headers[i].method[0] == '*') ){
int j;
for(j=0;mandatory_headers[i].headers[j]!=NULL;j++) {
if (belle_sip_message_get_header(message,mandatory_headers[i].headers[j])==NULL) {
belle_sip_error("Missing mandatory header [%s] for message [%s]",mandatory_headers[i].headers[j],method);
return 0;
}
}
return 1;
}
}
via=belle_sip_message_get_header_by_type(message,belle_sip_header_via_t);
if (!via || belle_sip_header_via_get_branch(via)==NULL) return 0;
}
/*else fixme should also check responses*/
return 1;
}
int belle_sip_request_check_uris_components(const belle_sip_request_t* request) {
belle_sip_list_t* new_list = belle_sip_message_get_all_headers(BELLE_SIP_MESSAGE(request));
belle_sip_list_t* iterator = new_list;
for (;iterator!=NULL;iterator=iterator->next) {
belle_sip_header_t* header=(belle_sip_header_t*)iterator->data;
if (BELLE_SIP_IS_INSTANCE_OF(header,belle_sip_header_address_t)) {
belle_sip_uri_t* uri=belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(header));
if (uri && !belle_sip_uri_check_components_from_context(uri,belle_sip_request_get_method(request),belle_sip_header_get_name(header))) {
char* header_string=belle_sip_object_to_string(header);
belle_sip_error("Malformed header [%s] for request [%p]",header_string,request);
belle_sip_free(header_string);
belle_sip_list_free(new_list);
return FALSE;
}
}
}
belle_sip_list_free(new_list);
return belle_sip_uri_check_components_from_request_uri(belle_sip_request_get_uri((const belle_sip_request_t*)request));
}
belle-sip-1.6.3/src/nict.c 0000664 0000000 0000000 00000013663 13134375224 0015302 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 .
*/
/**
* non-INVITE client transaction implementation.
**/
#include "belle_sip_internal.h"
static int nict_on_timer_K(belle_sip_nict_t *obj){
belle_sip_transaction_terminate((belle_sip_transaction_t*)obj);
return BELLE_SIP_STOP;
}
static void nict_set_completed(belle_sip_nict_t *obj, belle_sip_response_t *resp){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
const belle_sip_timer_config_t *cfg=belle_sip_transaction_get_timer_config(base);
belle_sip_transaction_set_state(base,BELLE_SIP_TRANSACTION_COMPLETED);
if (obj->timer_K) belle_sip_fatal("Should never happen.");
belle_sip_client_transaction_notify_response((belle_sip_client_transaction_t*)obj,resp);
if (!belle_sip_channel_is_reliable(base->channel)){
obj->timer_K=belle_sip_timeout_source_new((belle_sip_source_func_t)nict_on_timer_K,obj,cfg->T4);
belle_sip_object_set_name((belle_sip_object_t*)obj->timer_K,"timer_K");
belle_sip_transaction_start_timer(base,obj->timer_K);
}else belle_sip_transaction_terminate(base);
}
static void nict_on_response(belle_sip_nict_t *obj, belle_sip_response_t *resp){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
int code=belle_sip_response_get_status_code(resp);
switch(base->state){
case BELLE_SIP_TRANSACTION_TRYING:
if (code<200){
belle_sip_transaction_set_state(base,BELLE_SIP_TRANSACTION_PROCEEDING);
belle_sip_client_transaction_notify_response((belle_sip_client_transaction_t*)obj,resp);
}
else {
nict_set_completed(obj,resp);
}
break;
case BELLE_SIP_TRANSACTION_PROCEEDING:
if (code>=200){
nict_set_completed(obj,resp);
}
break;
default:
break;
}
}
static void nict_on_terminate(belle_sip_nict_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
if (obj->timer_F){
belle_sip_transaction_stop_timer(base,obj->timer_F);
belle_sip_object_unref(obj->timer_F);
obj->timer_F=NULL;
}
if (obj->timer_E){
belle_sip_transaction_stop_timer(base,obj->timer_E);
belle_sip_object_unref(obj->timer_E);
obj->timer_E=NULL;
}
if (obj->timer_K){
belle_sip_transaction_stop_timer(base,obj->timer_K);
belle_sip_object_unref(obj->timer_K);
obj->timer_K=NULL;
}
}
static int nict_on_timer_F(belle_sip_nict_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
switch (base->state){
case BELLE_SIP_TRANSACTION_TRYING:
case BELLE_SIP_TRANSACTION_PROCEEDING:
belle_sip_transaction_notify_timeout(base);
break;
default:
break;
}
return BELLE_SIP_STOP;
}
static int nict_on_timer_E(belle_sip_nict_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
const belle_sip_timer_config_t *cfg=belle_sip_transaction_get_timer_config(base);
switch(base->state){
case BELLE_SIP_TRANSACTION_TRYING:
{
/*reset the timer */
unsigned int prev_timeout=belle_sip_source_get_timeout(obj->timer_E);
belle_sip_source_set_timeout(obj->timer_E,MIN(2*prev_timeout,(unsigned int)cfg->T2));
belle_sip_message("nict_on_timer_E: sending retransmission");
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)base->request);
}
break;
case BELLE_SIP_TRANSACTION_PROCEEDING:
belle_sip_source_set_timeout(obj->timer_E,cfg->T2);
belle_sip_message("nict_on_timer_E: sending retransmission");
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)base->request);
break;
default:
/*if we are not in these cases, timer_E does nothing, so remove it*/
return BELLE_SIP_STOP;
break;
}
return BELLE_SIP_CONTINUE;
}
static void nict_send_request(belle_sip_nict_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
const belle_sip_timer_config_t *cfg=belle_sip_transaction_get_timer_config(base);
belle_sip_transaction_set_state(base,BELLE_SIP_TRANSACTION_TRYING);
obj->timer_F=belle_sip_timeout_source_new((belle_sip_source_func_t)nict_on_timer_F,obj,cfg->T1*64);
belle_sip_object_set_name((belle_sip_object_t*)obj->timer_F,"timer_F");
belle_sip_transaction_start_timer(base,obj->timer_F);
if (!belle_sip_channel_is_reliable(base->channel)){
obj->timer_E=belle_sip_timeout_source_new((belle_sip_source_func_t)nict_on_timer_E,obj,cfg->T1);
belle_sip_object_set_name((belle_sip_object_t*)obj->timer_E,"timer_E");
belle_sip_transaction_start_timer(base,obj->timer_E);
}
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)base->request);
}
static void nict_destroy(belle_sip_nict_t *obj){
nict_on_terminate(obj);
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_nict_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_nict_t)
{
{
{
BELLE_SIP_VPTR_INIT(belle_sip_nict_t,belle_sip_client_transaction_t,TRUE),
(belle_sip_object_destroy_t)nict_destroy,
NULL,
NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
(void (*)(belle_sip_transaction_t *))nict_on_terminate
},
(void (*)(belle_sip_client_transaction_t*))nict_send_request,
(void (*)(belle_sip_client_transaction_t*,belle_sip_response_t*))nict_on_response
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
belle_sip_nict_t *belle_sip_nict_new(belle_sip_provider_t *prov, belle_sip_request_t *req){
belle_sip_nict_t *obj=belle_sip_object_new(belle_sip_nict_t);
belle_sip_client_transaction_init((belle_sip_client_transaction_t*)obj,prov,req);
return obj;
}
belle-sip-1.6.3/src/nist.c 0000664 0000000 0000000 00000010172 13134375224 0015312 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 .
*/
/**
* non-INVITE server transaction implementation.
**/
#include
#include "belle_sip_internal.h"
static void nist_on_terminate(belle_sip_nist_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
if (obj->timer_J){
belle_sip_transaction_stop_timer(base,obj->timer_J);
belle_sip_object_unref(obj->timer_J);
obj->timer_J=NULL;
}
}
static void nist_destroy(belle_sip_nist_t *obj){
nist_on_terminate(obj);
}
static int nist_on_timer_J(belle_sip_nist_t *obj){
belle_sip_transaction_terminate((belle_sip_transaction_t *)obj);
return BELLE_SIP_STOP;
}
static void nist_set_completed(belle_sip_nist_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
const belle_sip_timer_config_t *cfg=belle_sip_transaction_get_timer_config(base);
int tval;
if (!belle_sip_channel_is_reliable(base->channel))
tval=cfg->T1*64;
else tval=0;
obj->timer_J=belle_sip_timeout_source_new((belle_sip_source_func_t)nist_on_timer_J,obj,tval);
belle_sip_transaction_start_timer(base,obj->timer_J);
belle_sip_transaction_set_state(base,BELLE_SIP_TRANSACTION_COMPLETED);
}
static int nist_send_new_response(belle_sip_nist_t *obj, belle_sip_response_t *resp){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
int code=belle_sip_response_get_status_code(resp);
int ret=0;
switch(base->state){
case BELLE_SIP_TRANSACTION_TRYING:
if (code<200){
belle_sip_transaction_set_state(base,BELLE_SIP_TRANSACTION_PROCEEDING);
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)resp);
break;
}
BCTBX_NO_BREAK; /* no break nist can directly pass from TRYING to PROCEEDING*/
case BELLE_SIP_TRANSACTION_PROCEEDING:
if (code>=200){
nist_set_completed(obj);
}
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)resp);
break;
case BELLE_SIP_TRANSACTION_COMPLETED:
belle_sip_warning("nist_send_new_response(): not allowed to send a response while transaction is completed.");
ret=-1; /*not allowed to send a response at this time*/
break;
default:
//ignore
break;
}
return ret;
}
static void nist_on_request_retransmission(belle_sip_nist_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
switch(base->state){
case BELLE_SIP_TRANSACTION_PROCEEDING:
case BELLE_SIP_TRANSACTION_COMPLETED:
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)base->last_response);
break;
default:
//ignore
break;
}
}
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(belle_sip_nist_t);
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_nist_t)
{
{
{
BELLE_SIP_VPTR_INIT(belle_sip_nist_t,belle_sip_server_transaction_t,TRUE),
(belle_sip_object_destroy_t)nist_destroy,
NULL,
NULL,
BELLE_SIP_DEFAULT_BUFSIZE_HINT
},
(void (*)(belle_sip_transaction_t *))nist_on_terminate
},
(int (*)(belle_sip_server_transaction_t*, belle_sip_response_t *))nist_send_new_response,
(void (*)(belle_sip_server_transaction_t*))nist_on_request_retransmission,
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
belle_sip_nist_t *belle_sip_nist_new(belle_sip_provider_t *prov, belle_sip_request_t *req){
belle_sip_nist_t *obj=belle_sip_object_new(belle_sip_nist_t);
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
belle_sip_server_transaction_init((belle_sip_server_transaction_t*)obj,prov,req);
belle_sip_transaction_set_state(base,BELLE_SIP_TRANSACTION_TRYING);
return obj;
}
belle-sip-1.6.3/src/parserutils.h 0000664 0000000 0000000 00000004610 13134375224 0016717 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 .
*/
#ifndef belle_sip_parserutils_h
#define belle_sip_parserutils_h
#include "port.h"
static BELLESIP_INLINE int belle_sip_strcasecmp(const char*a, const char* b) {
if (!a || !b) return 0;
return strcasecmp(a,b) == 0;
}
#define IS_TOKEN(token) \
belle_sip_strcasecmp(#token,(const char*)INPUT->toStringTT(INPUT,LT(1),LT(strlen(#token)))->chars)
#define IS_HEADER_NAMED(name,compressed_name) (IS_TOKEN(compressed_name) || IS_TOKEN(name))
#define STRCASECMP_HEADER_NAMED(name,compressed_name,value) \
(strcasecmp(compressed_name,(const char*)value) == 0 || strcasecmp(name,(const char*)value) == 0 )
#define ANTLR3_LOG_EXCEPTION() belle_sip_message("[\%s] reason [\%s] at line[\%u] position[\%d]",(const char*)EXCEPTION->name,(const char*)EXCEPTION->message,EXCEPTION->line,EXCEPTION->charPositionInLine);
BELLESIP_EXPORT belle_sip_header_t* belle_sip_header_get_next(const belle_sip_header_t* headers);
BELLESIP_EXPORT void belle_sip_header_set_next(belle_sip_header_t* header,belle_sip_header_t* next);
BELLESIP_EXPORT char* belle_sip_to_unescaped_string(const char* buff);
belle_sip_param_pair_t* belle_sip_param_pair_new(const char* name,const char* value);
char* _belle_sip_str_dup_and_unquote_string(const char* quoted_string);
/**
* quoted-string = SWS DQUOTE *(qdtext / quoted-pair ) DQUOTE
qdtext = LWS / %x21 / %x23-5B / %x5D-7E
/ UTF8-NONASCII
quoted-pair = "\" (%x00-09 / %x0B-0C
/ %x0E-7F)
remove any \
* */
BELLESIP_EXPORT char* belle_sip_string_to_backslash_less_unescaped_string(const char* buff);
BELLESIP_EXPORT char* belle_sip_display_name_to_backslashed_escaped_string(const char* buff);
#endif
belle-sip-1.6.3/src/port.c 0000664 0000000 0000000 00000014406 13134375224 0015325 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 .
*/
#include "belle_sip_internal.h"
#ifdef _WIN32
#include
#include
#ifdef HAVE_COMPILER_TLS
static __declspec(thread) const void *current_thread_data = NULL;
#endif
static int sockets_initd=0;
int belle_sip_init_sockets(void){
if (sockets_initd==0){
WSADATA data;
int err = WSAStartup(MAKEWORD(2,2), &data);
if (err != 0) {
belle_sip_error("WSAStartup failed with error: %d\n", err);
return -1;
}
}
sockets_initd++;
return 0;
}
void belle_sip_uninit_sockets(void){
sockets_initd--;
if (sockets_initd==0) WSACleanup();
}
typedef struct thread_param {
void * (*func)(void *);
void * arg;
} thread_param_t;
static unsigned WINAPI thread_starter(void *data) {
thread_param_t *params = (thread_param_t*)data;
params->func(params->arg);
belle_sip_free(data);
return 0;
}
int belle_sip_thread_create(belle_sip_thread_t *thread, void *attr, void * (*func)(void *), void *data) {
thread_param_t *params = belle_sip_new(thread_param_t);
params->func = func;
params->arg = data;
*thread = (HANDLE)_beginthreadex(NULL, 0, thread_starter, params, 0, NULL);
return 0;
}
int belle_sip_thread_join(belle_sip_thread_t thread, void **unused) {
if (thread != NULL) {
WaitForSingleObjectEx(thread, INFINITE, FALSE);
CloseHandle(thread);
}
return 0;
}
int belle_sip_mutex_init(belle_sip_mutex_t *mutex, void *attr) {
#ifdef BELLE_SIP_WINDOWS_DESKTOP
*mutex = CreateMutex(NULL, FALSE, NULL);
#else
InitializeSRWLock(mutex);
#endif
return 0;
}
int belle_sip_mutex_lock(belle_sip_mutex_t * hMutex) {
#ifdef BELLE_SIP_WINDOWS_DESKTOP
WaitForSingleObject(*hMutex, INFINITE);
#else
AcquireSRWLockExclusive(hMutex);
#endif
return 0;
}
int belle_sip_mutex_unlock(belle_sip_mutex_t * hMutex) {
#ifdef BELLE_SIP_WINDOWS_DESKTOP
ReleaseMutex(*hMutex);
#else
ReleaseSRWLockExclusive(hMutex);
#endif
return 0;
}
int belle_sip_mutex_destroy(belle_sip_mutex_t * hMutex) {
#ifdef BELLE_SIP_WINDOWS_DESKTOP
CloseHandle(*hMutex);
#endif
return 0;
}
int belle_sip_socket_set_nonblocking(belle_sip_socket_t sock)
{
unsigned long nonBlock = 1;
return ioctlsocket(sock, FIONBIO , &nonBlock);
}
int belle_sip_socket_set_dscp(belle_sip_socket_t sock, int ai_family, int dscp){
belle_sip_warning("belle_sip_socket_set_dscp(): not implemented.");
return -1;
}
const char *belle_sip_get_socket_error_string(){
return belle_sip_get_socket_error_string_from_code(WSAGetLastError());
}
const char *belle_sip_get_socket_error_string_from_code(int code){
static CHAR msgBuf[256];
#ifdef _UNICODE
static WCHAR wMsgBuf[256];
size_t ret;
FormatMessageW(
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
code,
0, // Default language
(LPWSTR) &wMsgBuf,
sizeof(wMsgBuf),
NULL);
ret = wcstombs(msgBuf, wMsgBuf, sizeof(msgBuf));
if (ret == sizeof(msgBuf)) msgBuf[sizeof(msgBuf) - 1] = '\0';
#else
FormatMessageA(
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
code,
0, // Default language
(LPTSTR) &msgBuf,
sizeof(msgBuf),
NULL);
/*FIXME: should convert from TCHAR to UTF8 */
#endif
return (const char *)msgBuf;
}
int belle_sip_thread_key_create(belle_sip_thread_key_t *key, void (*destructor)(void*) ){
#ifdef HAVE_COMPILER_TLS
*key = (belle_sip_thread_key_t)¤t_thread_data;
#else
*key = (belle_sip_thread_key_t)TlsAlloc();
if (*key==TLS_OUT_OF_INDEXES){
belle_sip_error("TlsAlloc(): TLS_OUT_OF_INDEXES.");
return -1;
}
#endif
return 0;
}
int belle_sip_thread_setspecific(belle_sip_thread_key_t key,const void *value){
#ifdef HAVE_COMPILER_TLS
current_thread_data = value;
return 0;
#else
return TlsSetValue((DWORD)key,(void*)value) ? 0 : -1;
#endif
}
const void* belle_sip_thread_getspecific(belle_sip_thread_key_t key){
#ifdef HAVE_COMPILER_TLS
return current_thread_data;
#else
return TlsGetValue((DWORD)key);
#endif
}
int belle_sip_thread_key_delete(belle_sip_thread_key_t key){
#ifdef HAVE_COMPILER_TLS
current_thread_data = NULL;
return 0;
#else
return TlsFree((DWORD)key) ? 0 : -1;
#endif
}
#ifndef BELLE_SIP_WINDOWS_DESKTOP
void belle_sip_sleep(unsigned int ms) {
HANDLE sleepEvent = CreateEventEx(NULL, NULL, CREATE_EVENT_MANUAL_RESET, EVENT_ALL_ACCESS);
if (!sleepEvent)
return;
WaitForSingleObjectEx(sleepEvent, ms, FALSE);
}
#endif
#else
#include
int belle_sip_init_sockets(){
signal(SIGPIPE,SIG_IGN);
return 0;
}
void belle_sip_uninit_sockets(){
}
int belle_sip_socket_set_nonblocking(belle_sip_socket_t sock){
return fcntl (sock, F_SETFL, fcntl(sock,F_GETFL) | O_NONBLOCK);
}
int belle_sip_socket_set_dscp(belle_sip_socket_t sock, int ai_family, int dscp){
int tos;
int proto;
int value_type;
int retval;
tos = (dscp << 2) & 0xFC;
switch (ai_family) {
case AF_INET:
proto=IPPROTO_IP;
value_type=IP_TOS;
break;
case AF_INET6:
proto=IPPROTO_IPV6;
#ifdef IPV6_TCLASS /*seems not defined by my libc*/
value_type=IPV6_TCLASS;
#else
value_type=IP_TOS;
#endif
break;
default:
belle_sip_error("Cannot set DSCP because socket family is unspecified.");
return -1;
}
retval = bctbx_setsockopt(sock, proto, value_type, (const char*)&tos, sizeof(tos));
if (retval==-1)
belle_sip_error("Fail to set DSCP value on socket: %s",belle_sip_get_socket_error_string());
return retval;
}
#endif
int belle_sip_socket_enable_dual_stack(belle_sip_socket_t sock){
int value=0;
int err=bctbx_setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&value, sizeof(value));
if (err==-1){
belle_sip_warning("belle_sip_socket_enable_dual_stack: bctbx_setsockopt(IPV6_ONLY) failed: %s",belle_sip_get_socket_error_string());
}
return err;
}
belle-sip-1.6.3/src/port.h 0000664 0000000 0000000 00000013651 13134375224 0015333 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 .
*/
#ifndef belle_sip_port_h
#define belle_sip_port_h
#include
#ifndef _WIN32
#include
#include
#include
#include
#include
#include
#include
#include
#include