ldap: clang format the code

src/modules/ldap/api.h

@@ -25,7 +25,6 @@
 */
 
 
-
 #ifndef LDAP_API_H
 #define LDAP_API_H
 
@@ -37,34 +36,23 @@
 /*
 * LDAP API function types
 */
-typedef int (*ldap_params_search_t)(
-	int* _ld_result_count,
-	char* _lds_name,
-	char* _dn,
-	int _scope,
-	char** _attrs,
-	char* _filter,
-	...); 
-
-typedef int (*ldap_url_search_t)(
-	char* _ldap_url,
-	int* _result_count);
-
-typedef int (*ldap_result_attr_vals_t)(
-	str* _attr_name,
-	struct berval ***_vals);
+typedef int (*ldap_params_search_t)(int *_ld_result_count, char *_lds_name,
+		char *_dn, int _scope, char **_attrs, char *_filter, ...);
+
+typedef int (*ldap_url_search_t)(char *_ldap_url, int *_result_count);
+
+typedef int (*ldap_result_attr_vals_t)(str *_attr_name, struct berval ***_vals);
 
 typedef void (*ldap_value_free_len_t)(struct berval **_vals);
 
 typedef int (*ldap_result_next_t)(void);
 
-typedef int (*ldap_str2scope_t)(char* scope_str);
+typedef int (*ldap_str2scope_t)(char *scope_str);
 
-typedef int (*get_ldap_handle_t)(char* _lds_name, LDAP** _ldap_handle);
+typedef int (*get_ldap_handle_t)(char *_lds_name, LDAP **_ldap_handle);
 
 typedef void (*get_last_ldap_result_t)(
-	LDAP** _last_ldap_handle, 
-	LDAPMessage** _last_ldap_result);
+		LDAP **_last_ldap_handle, LDAPMessage **_last_ldap_result);
 
 typedef int (*ldap_rfc4515_escape_t)(str *sin, str *sout, int url_encode);
 
@@ -72,16 +60,17 @@ typedef int (*ldap_rfc4515_escape_t)(str *sin, str *sout, int url_encode);
 * LDAP module API
 */
 
-typedef struct ldap_api {
-	ldap_params_search_t    ldap_params_search;
-	ldap_url_search_t       ldap_url_search;
+typedef struct ldap_api
+{
+	ldap_params_search_t ldap_params_search;
+	ldap_url_search_t ldap_url_search;
 	ldap_result_attr_vals_t ldap_result_attr_vals;
-	ldap_value_free_len_t   ldap_value_free_len;
-	ldap_result_next_t      ldap_result_next;
-	ldap_str2scope_t        ldap_str2scope;
-	ldap_rfc4515_escape_t   ldap_rfc4515_escape;
-	get_ldap_handle_t       get_ldap_handle;
-	get_last_ldap_result_t	get_last_ldap_result;
+	ldap_value_free_len_t ldap_value_free_len;
+	ldap_result_next_t ldap_result_next;
+	ldap_str2scope_t ldap_str2scope;
+	ldap_rfc4515_escape_t ldap_rfc4515_escape;
+	get_ldap_handle_t get_ldap_handle;
+	get_last_ldap_result_t get_last_ldap_result;
 } ldap_api_t;
 
 
@@ -93,14 +82,12 @@ static inline int load_ldap_api(ldap_api_t *api)
 {
 	load_ldap_t load_ldap;
 
-	if (!(load_ldap = (load_ldap_t) find_export("load_ldap", 0, 0)))
-	{
+	if(!(load_ldap = (load_ldap_t)find_export("load_ldap", 0, 0))) {
 		LM_ERR("can't import load_ldap\n");
 		return -1;
 	}
 
-	if (load_ldap(api) == -1)
-	{
+	if(load_ldap(api) == -1) {
 		return -1;
 	}
 

src/modules/ldap/iniparser.h

@@ -68,42 +68,42 @@ extern "C" {
 #endif
 
 
-	typedef struct _dictionary_ {
-		/** Number of entries in dictionary */
-		int n;
-		/** Storage size */
-		int size;
-		/** List of string values */
-		char **val;
-		/** List of string keys */
-		char **key ;
-		/** List of hash values for keys */
-		unsigned *hash;
-	} dictionary ;
-
-
-	/* generated by genproto */
-
-	dictionary * iniparser_new(char *ininame);
-	void iniparser_free(dictionary * d);
-
-	int iniparser_getnsec(dictionary * d);
-	char * iniparser_getsecname(dictionary * d, int n);
-	void iniparser_dump(dictionary * d, FILE * f);
-	void iniparser_dump_ini(dictionary * d, FILE * f);
-	char * iniparser_getkey(dictionary *d, char *section, char *key);
-	char * iniparser_getstr(dictionary * d, char * key);
-	char * iniparser_getstring(dictionary * d, char * key, char * def);
-	int iniparser_getint(dictionary * d, char * key, int notfound);
-	double iniparser_getdouble(dictionary * d, char * key, double notfound);
-	int iniparser_getboolean(dictionary * d, char * key, int notfound);
-	int iniparser_find_entry(dictionary  *   ini, char        *   entry);
-	int iniparser_setstr(dictionary * ini, char * entry, char * val);
-	void iniparser_unset(dictionary * ini, char * entry);
+typedef struct _dictionary_
+{
+	/** Number of entries in dictionary */
+	int n;
+	/** Storage size */
+	int size;
+	/** List of string values */
+	char **val;
+	/** List of string keys */
+	char **key;
+	/** List of hash values for keys */
+	unsigned *hash;
+} dictionary;
+
+
+/* generated by genproto */
+
+dictionary *iniparser_new(char *ininame);
+void iniparser_free(dictionary *d);
+
+int iniparser_getnsec(dictionary *d);
+char *iniparser_getsecname(dictionary *d, int n);
+void iniparser_dump(dictionary *d, FILE *f);
+void iniparser_dump_ini(dictionary *d, FILE *f);
+char *iniparser_getkey(dictionary *d, char *section, char *key);
+char *iniparser_getstr(dictionary *d, char *key);
+char *iniparser_getstring(dictionary *d, char *key, char *def);
+int iniparser_getint(dictionary *d, char *key, int notfound);
+double iniparser_getdouble(dictionary *d, char *key, double notfound);
+int iniparser_getboolean(dictionary *d, char *key, int notfound);
+int iniparser_find_entry(dictionary *ini, char *entry);
+int iniparser_setstr(dictionary *ini, char *entry, char *val);
+void iniparser_unset(dictionary *ini, char *entry);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif
-

src/modules/ldap/ld_session.c

@@ -31,36 +31,33 @@
 #include "../../core/sr_module.h"
 
 
-static struct ld_session* ld_sessions = NULL;
+static struct ld_session *ld_sessions = NULL;
 static char ini_key_name[512];
 
-int add_ld_session(char* _name, LDAP* _ldh, dictionary* _d)
+int add_ld_session(char *_name, LDAP *_ldh, dictionary *_d)
 {
-	struct ld_session* current = ld_sessions;
-	struct ld_session* new_lds = NULL;
+	struct ld_session *current = ld_sessions;
+	struct ld_session *new_lds = NULL;
 	char *host_name, *bind_dn, *bind_pwd;
 	int client_search_timeout_ms, client_bind_timeout_ms, network_timeout_ms;
-	
-	new_lds = (struct ld_session*)pkg_malloc(sizeof(struct ld_session));
-	if (new_lds == NULL)
-	{
+
+	new_lds = (struct ld_session *)pkg_malloc(sizeof(struct ld_session));
+	if(new_lds == NULL) {
 		LM_ERR("no memory\n");
 		return -1;
 	}
-	memset( new_lds, 0, sizeof(struct ld_session));
+	memset(new_lds, 0, sizeof(struct ld_session));
 
 	/* name */
 	strncpy(new_lds->name, _name, 255);
 	/* handle */
 	new_lds->handle = _ldh;
-	
+
 	/* host_name */
 	host_name = iniparser_getstring(
-		_d,
-		get_ini_key_name(_name, CFG_N_LDAP_HOST),
-		CFG_DEF_HOST_NAME);
-	new_lds->host_name = (char*)pkg_malloc(strlen(host_name)+1);
-	if (new_lds->host_name == NULL) {
+			_d, get_ini_key_name(_name, CFG_N_LDAP_HOST), CFG_DEF_HOST_NAME);
+	new_lds->host_name = (char *)pkg_malloc(strlen(host_name) + 1);
+	if(new_lds->host_name == NULL) {
 		LM_ERR("no memory\n");
 		pkg_free(new_lds);
 		return -1;
@@ -68,55 +65,45 @@ int add_ld_session(char* _name, LDAP* _ldh, dictionary* _d)
 	strcpy(new_lds->host_name, host_name);
 
 	/* version */
-	new_lds->version = iniparser_getint(
-		_d,
-		get_ini_key_name(_name, CFG_N_LDAP_VERSION),
-		CFG_DEF_LDAP_VERSION);
-	
+	new_lds->version = iniparser_getint(_d,
+			get_ini_key_name(_name, CFG_N_LDAP_VERSION), CFG_DEF_LDAP_VERSION);
+
 	/* client_search_timeout */
-	client_search_timeout_ms = iniparser_getint(
-		_d,
-		get_ini_key_name(_name, CFG_N_LDAP_CLIENT_SEARCH_TIMEOUT),
-		CFG_DEF_LDAP_CLIENT_SEARCH_TIMEOUT);
-	if (client_search_timeout_ms < CFG_LDAP_CLIENT_SEARCH_TIMEOUT_MIN)
-	{
+	client_search_timeout_ms = iniparser_getint(_d,
+			get_ini_key_name(_name, CFG_N_LDAP_CLIENT_SEARCH_TIMEOUT),
+			CFG_DEF_LDAP_CLIENT_SEARCH_TIMEOUT);
+	if(client_search_timeout_ms < CFG_LDAP_CLIENT_SEARCH_TIMEOUT_MIN) {
 		LM_INFO("[%s = %d ms] is below allowed min"
-			" [%d ms] - [%s] set to [%d ms]\n",
-			CFG_N_LDAP_CLIENT_SEARCH_TIMEOUT,
-			client_search_timeout_ms,
-			CFG_LDAP_CLIENT_SEARCH_TIMEOUT_MIN,
-			CFG_N_LDAP_CLIENT_SEARCH_TIMEOUT,
-			CFG_LDAP_CLIENT_SEARCH_TIMEOUT_MIN);
+				" [%d ms] - [%s] set to [%d ms]\n",
+				CFG_N_LDAP_CLIENT_SEARCH_TIMEOUT, client_search_timeout_ms,
+				CFG_LDAP_CLIENT_SEARCH_TIMEOUT_MIN,
+				CFG_N_LDAP_CLIENT_SEARCH_TIMEOUT,
+				CFG_LDAP_CLIENT_SEARCH_TIMEOUT_MIN);
 		client_search_timeout_ms = CFG_LDAP_CLIENT_SEARCH_TIMEOUT_MIN;
 	}
 	new_lds->client_search_timeout.tv_sec = client_search_timeout_ms / 1000;
 	new_lds->client_search_timeout.tv_usec =
-									(client_search_timeout_ms % 1000) * 1000;
+			(client_search_timeout_ms % 1000) * 1000;
 
 	/* client_bind_timeout */
-	client_bind_timeout_ms = iniparser_getint(
-		_d,
-		get_ini_key_name(_name, CFG_N_LDAP_CLIENT_BIND_TIMEOUT),
-		CFG_DEF_LDAP_CLIENT_BIND_TIMEOUT);
+	client_bind_timeout_ms = iniparser_getint(_d,
+			get_ini_key_name(_name, CFG_N_LDAP_CLIENT_BIND_TIMEOUT),
+			CFG_DEF_LDAP_CLIENT_BIND_TIMEOUT);
 	new_lds->client_bind_timeout.tv_sec = client_bind_timeout_ms / 1000;
-	new_lds->client_bind_timeout.tv_usec = 
-									(client_bind_timeout_ms % 1000) * 1000;
-	
+	new_lds->client_bind_timeout.tv_usec =
+			(client_bind_timeout_ms % 1000) * 1000;
+
 	/* network_timeout */
-	network_timeout_ms = iniparser_getint(
-		_d,
-		get_ini_key_name(_name, CFG_N_LDAP_NETWORK_TIMEOUT),
-		LDAP_NO_LIMIT);
+	network_timeout_ms = iniparser_getint(_d,
+			get_ini_key_name(_name, CFG_N_LDAP_NETWORK_TIMEOUT), LDAP_NO_LIMIT);
 	new_lds->network_timeout.tv_sec = network_timeout_ms / 1000;
 	new_lds->network_timeout.tv_usec = (network_timeout_ms % 1000) * 1000;
 
 	/* bind_dn */
-	bind_dn = iniparser_getstring(
-		_d,
-		get_ini_key_name(_name, CFG_N_LDAP_BIND_DN),
-		CFG_DEF_LDAP_BIND_DN);
-	new_lds->bind_dn = (char*)pkg_malloc(strlen(bind_dn)+1);
-	if (new_lds->bind_dn == NULL) {
+	bind_dn = iniparser_getstring(_d,
+			get_ini_key_name(_name, CFG_N_LDAP_BIND_DN), CFG_DEF_LDAP_BIND_DN);
+	new_lds->bind_dn = (char *)pkg_malloc(strlen(bind_dn) + 1);
+	if(new_lds->bind_dn == NULL) {
 		LM_ERR("no memory\n");
 		pkg_free(new_lds->host_name);
 		pkg_free(new_lds);
@@ -125,12 +112,11 @@ int add_ld_session(char* _name, LDAP* _ldh, dictionary* _d)
 	strcpy(new_lds->bind_dn, bind_dn);
 
 	/* bind_pwd */
-	bind_pwd = iniparser_getstring(
-		_d,
-		get_ini_key_name(_name, CFG_N_LDAP_BIND_PWD),
-		CFG_DEF_LDAP_BIND_PWD);
-	new_lds->bind_pwd = (char*)pkg_malloc(strlen(bind_pwd)+1);
-	if (new_lds->bind_pwd == NULL) {
+	bind_pwd = iniparser_getstring(_d,
+			get_ini_key_name(_name, CFG_N_LDAP_BIND_PWD),
+			CFG_DEF_LDAP_BIND_PWD);
+	new_lds->bind_pwd = (char *)pkg_malloc(strlen(bind_pwd) + 1);
+	if(new_lds->bind_pwd == NULL) {
 		LM_ERR("no memory\n");
 		pkg_free(new_lds->bind_dn);
 		pkg_free(new_lds->host_name);
@@ -140,18 +126,17 @@ int add_ld_session(char* _name, LDAP* _ldh, dictionary* _d)
 	strcpy(new_lds->bind_pwd, bind_pwd);
 
 	/* calculate_ha1 */
-	new_lds->calculate_ha1 = iniparser_getboolean(
-		_d, 
-		get_ini_key_name(_name, CFG_N_CALCULATE_HA1), 
-		CFG_DEF_CALCULATE_HA1);
-	
-	
-	if (current == NULL)
-	{
+	new_lds->calculate_ha1 = iniparser_getboolean(_d,
+			get_ini_key_name(_name, CFG_N_CALCULATE_HA1),
+			CFG_DEF_CALCULATE_HA1);
+
+
+	if(current == NULL) {
 		ld_sessions = new_lds;
-	} else
-	{
-		while (current->next != NULL) { current = current->next; };
+	} else {
+		while(current->next != NULL) {
+			current = current->next;
+		};
 		current->next = new_lds;
 	}
 
@@ -159,19 +144,16 @@ int add_ld_session(char* _name, LDAP* _ldh, dictionary* _d)
 }
 
 
-struct ld_session* get_ld_session(char* _name)
+struct ld_session *get_ld_session(char *_name)
 {
-	struct ld_session* current = ld_sessions;
-	
-	if (_name == NULL)
-	{
+	struct ld_session *current = ld_sessions;
+
+	if(_name == NULL) {
 		LM_ERR("lds_name == NULL\n");
 		return NULL;
 	}
-	while (current != NULL)
-	{
-		if (strcmp(current->name, _name) == 0)
-		{
+	while(current != NULL) {
+		if(strcmp(current->name, _name) == 0) {
 			return current;
 		}
 		current = current->next;
@@ -183,42 +165,36 @@ struct ld_session* get_ld_session(char* _name)
 
 int free_ld_sessions(void)
 {
-	struct ld_session* current = ld_sessions;
-	struct ld_session* tmp;
+	struct ld_session *current = ld_sessions;
+	struct ld_session *tmp;
 
-	while (current != NULL)
-	{
+	while(current != NULL) {
 		tmp = current->next;
 
-		if (current->handle != NULL)
-		{
+		if(current->handle != NULL) {
 			ldap_unbind_ext(current->handle, NULL, NULL);
 		}
-		if (current->host_name != NULL)
-		{
+		if(current->host_name != NULL) {
 			pkg_free(current->host_name);
 		}
-		if (current->bind_dn != NULL)
-		{
+		if(current->bind_dn != NULL) {
 			pkg_free(current->bind_dn);
 		}
-		if (current->bind_pwd != NULL)
-		{
+		if(current->bind_pwd != NULL) {
 			pkg_free(current->bind_pwd);
 		}
-		
+
 		pkg_free(current);
 		current = tmp;
 	}
-	
+
 	ld_sessions = NULL;
 
 	return 0;
 }
 
-char* get_ini_key_name(char* _section, char* _key)
+char *get_ini_key_name(char *_section, char *_key)
 {
 	sprintf(ini_key_name, "%s:%s", _section, _key);
 	return ini_key_name;
 }
-

src/modules/ldap/ld_session.h

@@ -34,19 +34,20 @@
 #include "iniparser.h"
 
 
-struct ld_session {
-	char                    name[256];
-	LDAP*                   handle;
-	char*                   host_name;
-	int                     version;
-	int                     server_search_timeout;
-	struct timeval          client_search_timeout;
-	struct timeval		client_bind_timeout;
-	struct timeval          network_timeout;
-	char*                   bind_dn;
-	char*                   bind_pwd;
-	int                     calculate_ha1;
-	struct ld_session*      next;
+struct ld_session
+{
+	char name[256];
+	LDAP *handle;
+	char *host_name;
+	int version;
+	int server_search_timeout;
+	struct timeval client_search_timeout;
+	struct timeval client_bind_timeout;
+	struct timeval network_timeout;
+	char *bind_dn;
+	char *bind_pwd;
+	int calculate_ha1;
+	struct ld_session *next;
 };
 
 #define CFG_N_LDAP_HOST "ldap_server_url"
@@ -72,11 +73,10 @@ struct ld_session {
 
 #define CFG_LDAP_CLIENT_SEARCH_TIMEOUT_MIN 2000
 
-extern int add_ld_session(char* _name, LDAP* _ldh, dictionary* _d);
-extern struct ld_session* get_ld_session(char* _name);
+extern int add_ld_session(char *_name, LDAP *_ldh, dictionary *_d);
+extern struct ld_session *get_ld_session(char *_name);
 extern int free_ld_sessions(void);
 
-extern char* get_ini_key_name(char* _section, char* _key);
+extern char *get_ini_key_name(char *_section, char *_key);
 
 #endif /* LD_SESSION_H */
-

src/modules/ldap/ldap_api_fn.c

@@ -38,82 +38,66 @@
 #include "ldap_escape.h"
 #include "ld_session.h"
 
-static LDAP* last_ldap_handle = NULL;
-static LDAPMessage* last_ldap_result_holder = NULL;
-static LDAPMessage* last_ldap_result = NULL;
-
-int get_connected_ldap_session(
-	char* _lds_name, 
-	struct ld_session** _lds);
-	int lds_search(char* _lds_name,
-	char* _dn,
-	int _scope,
-	char* _filter,
-	char** _attrs,
-	struct timeval* _search_timeout,
-	int* _ld_result_count,
-	int* _ld_error);
+static LDAP *last_ldap_handle = NULL;
+static LDAPMessage *last_ldap_result_holder = NULL;
+static LDAPMessage *last_ldap_result = NULL;
+
+int get_connected_ldap_session(char *_lds_name, struct ld_session **_lds);
+int lds_search(char *_lds_name, char *_dn, int _scope, char *_filter,
+		char **_attrs, struct timeval *_search_timeout, int *_ld_result_count,
+		int *_ld_error);
 
 
 int load_ldap(ldap_api_t *api)
 {
-	if (api == NULL)
-	{
+	if(api == NULL) {
 		return -1;
 	}
 
-	api->ldap_params_search    = ldap_params_search;
-	api->ldap_url_search       = ldap_url_search;
+	api->ldap_params_search = ldap_params_search;
+	api->ldap_url_search = ldap_url_search;
 	api->ldap_result_attr_vals = ldap_get_attr_vals;
-	api->ldap_value_free_len   = ldap_value_free_len;
-	api->ldap_result_next      = ldap_inc_result_pointer;
-	api->ldap_str2scope        = ldap_str2scope;
-	api->ldap_rfc4515_escape   = ldap_rfc4515_escape;
-	api->get_ldap_handle       = get_ldap_handle;
-	api->get_last_ldap_result  = get_last_ldap_result;
+	api->ldap_value_free_len = ldap_value_free_len;
+	api->ldap_result_next = ldap_inc_result_pointer;
+	api->ldap_str2scope = ldap_str2scope;
+	api->ldap_rfc4515_escape = ldap_rfc4515_escape;
+	api->get_ldap_handle = get_ldap_handle;
+	api->get_last_ldap_result = get_last_ldap_result;
 
 	return 1;
 }
 
-int get_ldap_handle(char* _lds_name, LDAP** _ldap_handle)
+int get_ldap_handle(char *_lds_name, LDAP **_ldap_handle)
 {
 	int rc;
-	struct ld_session* lds;
+	struct ld_session *lds;
 
 	rc = get_connected_ldap_session(_lds_name, &lds);
-	if (rc == 0)
-	{
+	if(rc == 0) {
 		*_ldap_handle = lds->handle;
 	}
 	return rc;
 }
 
-int get_connected_ldap_session(char* _lds_name, struct ld_session** _lds)
-{	
+int get_connected_ldap_session(char *_lds_name, struct ld_session **_lds)
+{
 	/*
 	* get ld session
 	*/
-	if ((*_lds = get_ld_session(_lds_name)) == NULL)
-	{
+	if((*_lds = get_ld_session(_lds_name)) == NULL) {
 		LM_ERR("[%s]: ldap_session not found\n", _lds_name);
 		return -1;
 	}
 
 	/* try to reconnect if ldap session handle is NULL */
-	if ((*_lds)->handle == NULL)
-	{
-		if (ldap_reconnect(_lds_name) == 0)
-		{
-			if ((*_lds = get_ld_session(_lds_name)) == NULL)
-			{
+	if((*_lds)->handle == NULL) {
+		if(ldap_reconnect(_lds_name) == 0) {
+			if((*_lds = get_ld_session(_lds_name)) == NULL) {
 				LM_ERR("[%s]: ldap_session not found\n", _lds_name);
 				return -1;
 			}
-		}
-		else
-		{
-			if (last_ldap_result_holder != NULL)
-			{
+		} else {
+			if(last_ldap_result_holder != NULL) {
 				ldap_msgfree(last_ldap_result_holder);
 				last_ldap_result_holder = NULL;
 				last_ldap_result = NULL;
@@ -134,24 +118,19 @@ int get_connected_ldap_session(char* _lds_name, struct ld_session** _lds)
 		last_ldap_result = NULL;
 	}
 	*/
-	
+
 	return 0;
 }
 
-void get_last_ldap_result(LDAP** _last_ldap_handle, LDAPMessage** _last_ldap_result)
+void get_last_ldap_result(
+		LDAP **_last_ldap_handle, LDAPMessage **_last_ldap_result)
 {
 	*_last_ldap_handle = last_ldap_handle;
 	*_last_ldap_result = last_ldap_result;
 }
 
-int ldap_params_search(
-	int* _ld_result_count,
-	char* _lds_name,
-	char* _dn,
-	int _scope,
-	char** _attrs,
-	char* _filter,
-	...)
+int ldap_params_search(int *_ld_result_count, char *_lds_name, char *_dn,
+		int _scope, char **_attrs, char *_filter, ...)
 {
 	int rc;
 	static char filter_str[LDAP_MAX_FILTER_LEN];
@@ -161,36 +140,30 @@ int ldap_params_search(
 	/*
 	* check _scope
 	*/
-	switch (_scope)
-	{
-	case LDAP_SCOPE_ONELEVEL:
-	case LDAP_SCOPE_BASE:
-	case LDAP_SCOPE_SUBTREE:
-		break;
-	default:
-		LM_ERR("[%s]: invalid scope argument [%d]\n", _lds_name, _scope);
-		return -1;
+	switch(_scope) {
+		case LDAP_SCOPE_ONELEVEL:
+		case LDAP_SCOPE_BASE:
+		case LDAP_SCOPE_SUBTREE:
+			break;
+		default:
+			LM_ERR("[%s]: invalid scope argument [%d]\n", _lds_name, _scope);
+			return -1;
 	}
 
-	if (_filter) {
+	if(_filter) {
 		/*
 		* vsnprintf
 		*/
 		va_start(filter_vars, _filter);
-		rc = vsnprintf(filter_str, (size_t)LDAP_MAX_FILTER_LEN, _filter,
-				filter_vars);
+		rc = vsnprintf(
+				filter_str, (size_t)LDAP_MAX_FILTER_LEN, _filter, filter_vars);
 		va_end(filter_vars);
 
-		if (rc >= LDAP_MAX_FILTER_LEN)
-		{
-			LM_ERR(	"[%s]: filter string too long (len [%d], max len [%d])\n",
-				_lds_name,
-				rc,
-				LDAP_MAX_FILTER_LEN);
+		if(rc >= LDAP_MAX_FILTER_LEN) {
+			LM_ERR("[%s]: filter string too long (len [%d], max len [%d])\n",
+					_lds_name, rc, LDAP_MAX_FILTER_LEN);
 			return -1;
-		}
-		else if (rc < 0)
-		{
+		} else if(rc < 0) {
 			LM_ERR("vsnprintf failed\n");
 			return -1;
 		}
@@ -200,81 +173,51 @@ int ldap_params_search(
 	/*
 	* ldap search
 	*/
-	if (lds_search(_lds_name,
-			_dn,
-			_scope,
-			filter_ptr,
-			_attrs,
-			NULL,
-			_ld_result_count,
-			&rc)
-		!= 0)
-	{
+	if(lds_search(_lds_name, _dn, _scope, filter_ptr, _attrs, NULL,
+			   _ld_result_count, &rc)
+			!= 0) {
 		/* try again if LDAP API ERROR */
-		if (LDAP_API_ERROR(rc) && 
-				(lds_search(_lds_name,
-						_dn,
-						_scope,
-						filter_str,
-						_attrs,
-						NULL,
-						_ld_result_count,
-						&rc) != 0))
-		{
-			LM_ERR(	"[%s]: LDAP search (dn [%s], scope [%d],"
-				" filter [%s]) failed: %s\n",
-				_lds_name,
-				_dn,
-				_scope,
-				filter_str,
-				ldap_err2string(rc));
+		if(LDAP_API_ERROR(rc) && (lds_search(_lds_name, _dn, _scope, filter_str,
+										  _attrs, NULL, _ld_result_count, &rc)
+										 != 0)) {
+			LM_ERR("[%s]: LDAP search (dn [%s], scope [%d],"
+				   " filter [%s]) failed: %s\n",
+					_lds_name, _dn, _scope, filter_str, ldap_err2string(rc));
 			return -1;
 		}
 	}
-	
-	LM_DBG(	"[%s]: [%d] LDAP entries found\n", 
-		_lds_name,
-		*_ld_result_count);
-	
+
+	LM_DBG("[%s]: [%d] LDAP entries found\n", _lds_name, *_ld_result_count);
+
 	return 0;
 }
 
 
-int ldap_url_search(
-	char* _ldap_url,
-	int* _ld_result_count)
+int ldap_url_search(char *_ldap_url, int *_ld_result_count)
 {
 	LDAPURLDesc *ludp;
 	int rc;
 
-	if (ldap_url_parse(_ldap_url, &ludp) != 0) {
+	if(ldap_url_parse(_ldap_url, &ludp) != 0) {
 		LM_ERR("invalid LDAP URL [%s]\n", ZSW(_ldap_url));
-		if (ludp != NULL) {
+		if(ludp != NULL) {
 			ldap_free_urldesc(ludp);
 		}
 		return -2;
 	}
-	if (ludp->lud_host == NULL)
-	{
-		LM_ERR(	"no ldap session name found in ldap URL [%s]\n",
-			ZSW(_ldap_url));
+	if(ludp->lud_host == NULL) {
+		LM_ERR("no ldap session name found in ldap URL [%s]\n", ZSW(_ldap_url));
 		return -2;
 	}
 
 
-	LM_DBG(	"LDAP URL parsed into session_name"
-		" [%s], base [%s], scope [%d], filter [%s]\n",
-		ZSW(ludp->lud_host),
-		ZSW(ludp->lud_dn),
-		ludp->lud_scope,
-		ZSW(ludp->lud_filter));
+	LM_DBG("LDAP URL parsed into session_name"
+		   " [%s], base [%s], scope [%d], filter [%s]\n",
+			ZSW(ludp->lud_host), ZSW(ludp->lud_dn), ludp->lud_scope,
+			ZSW(ludp->lud_filter));
 
-	rc = ldap_params_search(_ld_result_count,
-		ludp->lud_host,
-		ludp->lud_dn,
-		ludp->lud_scope,
-		ludp->lud_attrs,
-		ludp->lud_filter);
+	rc = ldap_params_search(_ld_result_count, ludp->lud_host, ludp->lud_dn,
+			ludp->lud_scope, ludp->lud_attrs, ludp->lud_filter);
 	ldap_free_urldesc(ludp);
 	return rc;
 }
@@ -287,12 +230,11 @@ int ldap_inc_result_pointer(void)
 	/*
 	* check for last_ldap_result
 	*/
-	if (last_ldap_result == NULL) {
+	if(last_ldap_result == NULL) {
 		LM_ERR("last_ldap_result == NULL\n");
 		return -1;
 	}
-	if (last_ldap_handle == NULL)
-	{
+	if(last_ldap_handle == NULL) {
 		LM_ERR("last_ldap_handle == NULL\n");
 		return -1;
 	}
@@ -300,9 +242,8 @@ int ldap_inc_result_pointer(void)
 	/*
 	* get next LDAP result pointer
 	*/
-	if ((next_result = ldap_next_entry(last_ldap_handle, last_ldap_result))
-			== NULL)
-	{
+	if((next_result = ldap_next_entry(last_ldap_handle, last_ldap_result))
+			== NULL) {
 		/* no more LDAP entries */
 		return 1;
 	}
@@ -319,12 +260,11 @@ int ldap_get_attr_vals(str *_attr_name, struct berval ***_vals)
 	/*
 	* check for last_ldap_result
 	*/
-	if (last_ldap_result == NULL) {
+	if(last_ldap_result == NULL) {
 		LM_ERR("last_ldap_result == NULL\n");
 		return -1;
 	}
-	if (last_ldap_handle == NULL)
-	{
+	if(last_ldap_handle == NULL) {
 		LM_ERR("last_ldap_handle == NULL\n");
 		return -1;
 	}
@@ -333,80 +273,64 @@ int ldap_get_attr_vals(str *_attr_name, struct berval ***_vals)
 	* search for attribute named _attr_name
 	*/
 	*_vals = NULL;
-	for (a = ldap_first_attribute(last_ldap_handle,
-			last_ldap_result,
-			&ber);
-		a != NULL;
-		a = ldap_next_attribute(last_ldap_handle,
-			last_ldap_result,
-			ber))
-	{
-		if (strncmp(a, _attr_name->s, _attr_name->len) == 0) {
-			*_vals = ldap_get_values_len(
-				last_ldap_handle,
-				last_ldap_result,
-				a);
+	for(a = ldap_first_attribute(last_ldap_handle, last_ldap_result, &ber);
+			a != NULL;
+			a = ldap_next_attribute(last_ldap_handle, last_ldap_result, ber)) {
+		if(strncmp(a, _attr_name->s, _attr_name->len) == 0) {
+			*_vals = ldap_get_values_len(last_ldap_handle, last_ldap_result, a);
 			ldap_memfree(a);
 			break;
 		}
 		ldap_memfree(a);
 	}
 
-	if (ber != NULL) {
+	if(ber != NULL) {
 		ber_free(ber, 0);
 	}
 
-	if (*_vals != NULL)
-	{
+	if(*_vals != NULL) {
 		return 0;
 	} else {
 		return 1;
 	}
 }
 
-int ldap_str2scope(char* scope_str)
+int ldap_str2scope(char *scope_str)
 {
-	if ( strcasecmp( scope_str, "one" ) == 0 ) {
+	if(strcasecmp(scope_str, "one") == 0) {
 		return LDAP_SCOPE_ONELEVEL;
 
-	} else if ( strcasecmp( scope_str, "onelevel" ) == 0 ) {
+	} else if(strcasecmp(scope_str, "onelevel") == 0) {
 		return LDAP_SCOPE_ONELEVEL;
 
-	} else if ( strcasecmp( scope_str, "base" ) == 0 ) {
+	} else if(strcasecmp(scope_str, "base") == 0) {
 		return LDAP_SCOPE_BASE;
 
-	} else if ( strcasecmp( scope_str, "sub" ) == 0 ) {
+	} else if(strcasecmp(scope_str, "sub") == 0) {
 		return LDAP_SCOPE_SUBTREE;
 
-	} else if ( strcasecmp( scope_str, "subtree" ) == 0 ) {
+	} else if(strcasecmp(scope_str, "subtree") == 0) {
 		return LDAP_SCOPE_SUBTREE;
 	};
 
-	return( -1 );
+	return (-1);
 }
 /*
  * sets last_ldap_result and last_ldap_handle
  */
-int lds_search(
-	char* _lds_name,
-	char* _dn,
-	int _scope,
-	char* _filter,
-	char** _attrs,
-	struct timeval* _search_timeout,
-	int* _ld_result_count,
-	int* _ld_error)
+int lds_search(char *_lds_name, char *_dn, int _scope, char *_filter,
+		char **_attrs, struct timeval *_search_timeout, int *_ld_result_count,
+		int *_ld_error)
 {
-	struct ld_session* lds;
+	struct ld_session *lds;
 #ifdef LDAP_PERF
-	struct timeval before_search = { 0, 0 }, after_search = { 0, 0 };
+	struct timeval before_search = {0, 0}, after_search = {0, 0};
 #endif
 
 	/*
 	 * get ld_handle
 	 */
-	if (get_connected_ldap_session(_lds_name, &lds) != 0)
-	{
+	if(get_connected_ldap_session(_lds_name, &lds) != 0) {
 		LM_ERR("[%s]: couldn't get ldap session\n", _lds_name);
 		return -1;
 	}
@@ -414,22 +338,19 @@ int lds_search(
 	/*
 	 * free last_ldap_result
 	 */
-        if (last_ldap_result_holder != NULL) {
-                ldap_msgfree(last_ldap_result_holder);
-                last_ldap_result_holder = NULL;
+	if(last_ldap_result_holder != NULL) {
+		ldap_msgfree(last_ldap_result_holder);
+		last_ldap_result_holder = NULL;
 		last_ldap_result = NULL;
-        }
-
-	
-	LM_DBG(	"[%s]: performing LDAP search: dn [%s],"
-		" scope [%d], filter [%s], client_timeout [%d] usecs\n",
-		_lds_name,
-		_dn,
-		_scope,
-		_filter,
-		(int)(lds->client_search_timeout.tv_sec * 1000000 
-			+ lds->client_search_timeout.tv_usec));
-	
+	}
+
+
+	LM_DBG("[%s]: performing LDAP search: dn [%s],"
+		   " scope [%d], filter [%s], client_timeout [%d] usecs\n",
+			_lds_name, _dn, _scope, _filter,
+			(int)(lds->client_search_timeout.tv_sec * 1000000
+					+ lds->client_search_timeout.tv_usec));
+
 #ifdef LDAP_PERF
 	gettimeofday(&before_search, NULL);
 #endif
@@ -437,51 +358,38 @@ int lds_search(
 	/*
 	 * perform ldap search
 	 */
-	*_ld_error = ldap_search_ext_s(
-		lds->handle,
-		_dn,
-		_scope,
-		_filter,
-		_attrs,
-		0,
-		NULL,
-		NULL,
-		&lds->client_search_timeout,
-		0,
-		&last_ldap_result_holder);
+	*_ld_error = ldap_search_ext_s(lds->handle, _dn, _scope, _filter, _attrs, 0,
+			NULL, NULL, &lds->client_search_timeout, 0,
+			&last_ldap_result_holder);
 
 #ifdef LDAP_PERF
 	gettimeofday(&after_search, NULL);
 
-	LM_INFO("[%s]: LDAP search took [%d] usecs\n",
-		_lds_name,
-		(int)((after_search.tv_sec * 1000000 + after_search.tv_usec)
-		- (before_search.tv_sec * 1000000 + before_search.tv_usec)));
+	LM_INFO("[%s]: LDAP search took [%d] usecs\n", _lds_name,
+			(int)((after_search.tv_sec * 1000000 + after_search.tv_usec)
+					- (before_search.tv_sec * 1000000
+							  + before_search.tv_usec)));
 #endif
 
-	if (*_ld_error != LDAP_SUCCESS)
-	{
-		if (last_ldap_result_holder != NULL)
-		{
+	if(*_ld_error != LDAP_SUCCESS) {
+		if(last_ldap_result_holder != NULL) {
 			ldap_msgfree(last_ldap_result_holder);
 			last_ldap_result_holder = NULL;
 		}
 
-		if (LDAP_API_ERROR(*_ld_error))
-		{
+		if(LDAP_API_ERROR(*_ld_error)) {
 			ldap_disconnect(_lds_name);
 		}
-		
-		LM_DBG( "[%s]: ldap_search_ext_st failed: %s\n",
-			_lds_name,
-			ldap_err2string(*_ld_error));
+
+		LM_DBG("[%s]: ldap_search_ext_st failed: %s\n", _lds_name,
+				ldap_err2string(*_ld_error));
 		return -1;
 	}
 
 	last_ldap_handle = lds->handle;
-	*_ld_result_count = ldap_count_entries(lds->handle, last_ldap_result_holder);
-	if (*_ld_result_count < 0)
-	{
+	*_ld_result_count =
+			ldap_count_entries(lds->handle, last_ldap_result_holder);
+	if(*_ld_result_count < 0) {
 		LM_DBG("[%s]: ldap_count_entries failed\n", _lds_name);
 		return -1;
 	}
@@ -490,4 +398,3 @@ int lds_search(
 
 	return 0;
 }
-

src/modules/ldap/ldap_api_fn.h

@@ -38,30 +38,20 @@
 /*
 * LDAP API functions
 */
-int ldap_params_search(
-	int* _ld_result_count,
-	char* _lds_name,
-	char* _dn,
-	int _scope,
-	char** _attrs,
-	char* _filter,
-	...);
+int ldap_params_search(int *_ld_result_count, char *_lds_name, char *_dn,
+		int _scope, char **_attrs, char *_filter, ...);
 
-int ldap_url_search(
-	char* _ldap_url,
-	int* _ld_result_count);
+int ldap_url_search(char *_ldap_url, int *_ld_result_count);
 
-int ldap_get_attr_vals(
-	str *_attr_name,
-	struct berval ***_vals);
+int ldap_get_attr_vals(str *_attr_name, struct berval ***_vals);
 
 int ldap_inc_result_pointer(void);
 
-int ldap_str2scope(char* scope_str);
+int ldap_str2scope(char *scope_str);
 
-int get_ldap_handle(char* _lds_name, LDAP** _ldap_handle);
+int get_ldap_handle(char *_lds_name, LDAP **_ldap_handle);
 
-void get_last_ldap_result(LDAP** _last_ldap_handle, 
-		LDAPMessage** _last_ldap_result);
+void get_last_ldap_result(
+		LDAP **_last_ldap_handle, LDAPMessage **_last_ldap_result);
 
 #endif /* LDAP_API_FN_H */

src/modules/ldap/ldap_connect.c

@@ -36,7 +36,7 @@
 #include "../../core/mem/mem.h"
 #include "../../core/ut.h"
 
-int ldap_connect_ex(char* _ld_name, int llevel)
+int ldap_connect_ex(char *_ld_name, int llevel)
 {
 	int rc;
 	int ldap_bind_result_code;
@@ -44,66 +44,56 @@ int ldap_connect_ex(char* _ld_name, int llevel)
 	int ldap_proto_version;
 	int msgid;
 	LDAPMessage *result;
-	struct ld_session* lds;
+	struct ld_session *lds;
 	struct berval ldap_cred;
 
 	/*
 	* get ld session and session config parameters
 	*/
-	
-	if ((lds = get_ld_session(_ld_name)) == NULL)
-	{
+
+	if((lds = get_ld_session(_ld_name)) == NULL) {
 		LM_ERR("ld_session [%s] not found\n", _ld_name);
 		return -1;
 	}
-	
+
 	/*
 	 * ldap_initialize
 	 */
 
 	rc = ldap_initialize(&lds->handle, lds->host_name);
-	if (rc != LDAP_SUCCESS)
-	{
-		LM_ERR(	"[%s]: ldap_initialize (%s) failed: %s\n",
-			_ld_name,
-			lds->host_name,
-			ldap_err2string(rc));
+	if(rc != LDAP_SUCCESS) {
+		LM_ERR("[%s]: ldap_initialize (%s) failed: %s\n", _ld_name,
+				lds->host_name, ldap_err2string(rc));
 		return -1;
 	}
-	
+
 	/*
 	 * set LDAP OPTIONS
 	 */
 
 	/* LDAP_OPT_PROTOCOL_VERSION */
-	switch (lds->version) {
-	case 2:
-		ldap_proto_version = LDAP_VERSION2;
-		break;
-	case 3:
-		ldap_proto_version = LDAP_VERSION3;
-		break;
-	default:
-		LM_ERR(	"[%s]: Invalid LDAP protocol version [%d]\n",
-			_ld_name, 
-			lds->version);
-		return -1;
+	switch(lds->version) {
+		case 2:
+			ldap_proto_version = LDAP_VERSION2;
+			break;
+		case 3:
+			ldap_proto_version = LDAP_VERSION3;
+			break;
+		default:
+			LM_ERR("[%s]: Invalid LDAP protocol version [%d]\n", _ld_name,
+					lds->version);
+			return -1;
 	}
-	if (ldap_set_option(lds->handle,
-				LDAP_OPT_PROTOCOL_VERSION,
-				&ldap_proto_version)
-			!= LDAP_OPT_SUCCESS) 
-	{
-		LM_ERR(	"[%s]: Could not set LDAP_OPT_PROTOCOL_VERSION [%d]\n",
-			_ld_name, 
-			ldap_proto_version);
+	if(ldap_set_option(
+			   lds->handle, LDAP_OPT_PROTOCOL_VERSION, &ldap_proto_version)
+			!= LDAP_OPT_SUCCESS) {
+		LM_ERR("[%s]: Could not set LDAP_OPT_PROTOCOL_VERSION [%d]\n", _ld_name,
+				ldap_proto_version);
 		return -1;
 	}
 
 	/* LDAP_OPT_RESTART */
-	if (ldap_set_option(lds->handle,
-				LDAP_OPT_RESTART,
-				LDAP_OPT_ON)
+	if(ldap_set_option(lds->handle, LDAP_OPT_RESTART, LDAP_OPT_ON)
 			!= LDAP_OPT_SUCCESS) {
 		LM_ERR("[%s]: Could not set LDAP_OPT_RESTART to ON\n", _ld_name);
 		return -1;
@@ -122,23 +112,20 @@ int ldap_connect_ex(char* _ld_name, int llevel)
 		}
 	}
 	*/
-	
+
 	/* LDAP_OPT_NETWORK_TIMEOUT */
-	if ((lds->network_timeout.tv_sec > 0) || (lds->network_timeout.tv_usec > 0))
-	{
-		if (ldap_set_option(lds->handle,
-					LDAP_OPT_NETWORK_TIMEOUT,
-					(const void *)&lds->network_timeout)
-				!= LDAP_OPT_SUCCESS)
-		{
-			LM_ERR(	"[%s]: Could not set"
-				" LDAP_NETWORK_TIMEOUT to [%d.%d]\n",
-				_ld_name, 
-				(int)lds->network_timeout.tv_sec,
-				(int)lds->network_timeout.tv_usec);
+	if((lds->network_timeout.tv_sec > 0)
+			|| (lds->network_timeout.tv_usec > 0)) {
+		if(ldap_set_option(lds->handle, LDAP_OPT_NETWORK_TIMEOUT,
+				   (const void *)&lds->network_timeout)
+				!= LDAP_OPT_SUCCESS) {
+			LM_ERR("[%s]: Could not set"
+				   " LDAP_NETWORK_TIMEOUT to [%d.%d]\n",
+					_ld_name, (int)lds->network_timeout.tv_sec,
+					(int)lds->network_timeout.tv_usec);
 		}
 	}
-	
+
 	/*
 	  * ldap_sasl_bind (LDAP_SASL_SIMPLE)
 	 */
@@ -146,73 +133,44 @@ int ldap_connect_ex(char* _ld_name, int llevel)
 
 	ldap_cred.bv_val = lds->bind_pwd;
 	ldap_cred.bv_len = strlen(lds->bind_pwd);
-	rc = ldap_sasl_bind(
-		lds->handle,
-		lds->bind_dn,
-		LDAP_SASL_SIMPLE,
-		&ldap_cred,
-		NULL,
-		NULL,
-		&msgid);
-	if (rc != LDAP_SUCCESS)
-	{
-		LM_ERR(	"[%s]: ldap bind failed: %s\n",
-			_ld_name,
-			ldap_err2string(rc));
+	rc = ldap_sasl_bind(lds->handle, lds->bind_dn, LDAP_SASL_SIMPLE, &ldap_cred,
+			NULL, NULL, &msgid);
+	if(rc != LDAP_SUCCESS) {
+		LM_ERR("[%s]: ldap bind failed: %s\n", _ld_name, ldap_err2string(rc));
 		return -1;
 	}
 
 
-
-	
-	if ((lds->client_bind_timeout.tv_sec == 0) 
-			&& (lds->client_bind_timeout.tv_usec == 0))
-	{
+	if((lds->client_bind_timeout.tv_sec == 0)
+			&& (lds->client_bind_timeout.tv_usec == 0)) {
 		rc = ldap_result(lds->handle, msgid, 1, NULL, &result);
-	} else
-	{
-		rc = ldap_result(lds->handle, msgid, 1, &lds->client_bind_timeout,
-				&result);
+	} else {
+		rc = ldap_result(
+				lds->handle, msgid, 1, &lds->client_bind_timeout, &result);
 	}
 
 
-	if (rc == -1)
-	{
+	if(rc == -1) {
 		ldap_get_option(lds->handle, LDAP_OPT_ERROR_NUMBER, &rc);
 		ldap_err_str = ldap_err2string(rc);
-		LM_ERR(	"[%s]: ldap_result failed: %s\n",
-			_ld_name,
-			ldap_err_str);
+		LM_ERR("[%s]: ldap_result failed: %s\n", _ld_name, ldap_err_str);
 		return -1;
-	} 
-	else if (rc == 0)
-	{
+	} else if(rc == 0) {
 		LM_ERR("[%s]: bind operation timed out\n", _ld_name);
 		return -1;
 	}
 
 
-	rc = ldap_parse_result(
-		lds->handle,
-		result,
-		&ldap_bind_result_code,
-		NULL,
-		NULL,
-		NULL,
-		NULL,
-		1);
-	if (rc != LDAP_SUCCESS)
-	{
-		LM_ERR(	"[%s]: ldap_parse_result failed: %s\n",
-			_ld_name, 
-			ldap_err2string(rc));
+	rc = ldap_parse_result(lds->handle, result, &ldap_bind_result_code, NULL,
+			NULL, NULL, NULL, 1);
+	if(rc != LDAP_SUCCESS) {
+		LM_ERR("[%s]: ldap_parse_result failed: %s\n", _ld_name,
+				ldap_err2string(rc));
 		return -1;
 	}
-	if (ldap_bind_result_code != LDAP_SUCCESS)
-	{
-		LM_ERR(	"[%s]: ldap bind failed: %s\n",
-			_ld_name, 
-			ldap_err2string(ldap_bind_result_code));
+	if(ldap_bind_result_code != LDAP_SUCCESS) {
+		LM_ERR("[%s]: ldap bind failed: %s\n", _ld_name,
+				ldap_err2string(ldap_bind_result_code));
 		return -1;
 	}
 
@@ -221,33 +179,31 @@ int ldap_connect_ex(char* _ld_name, int llevel)
 	/* ldap_msgfree(result); */
 
 
-	LOG(llevel, "[%s]: LDAP bind successful (ldap_host [%s])\n",
-		_ld_name, 
-		lds->host_name);
+	LOG(llevel, "[%s]: LDAP bind successful (ldap_host [%s])\n", _ld_name,
+			lds->host_name);
 
 	return 0;
 }
 
-int ldap_connect(char* _ld_name)
+int ldap_connect(char *_ld_name)
 {
 	return ldap_connect_ex(_ld_name, L_DBG);
 }
 
-int ldap_disconnect(char* _ld_name)
+int ldap_disconnect(char *_ld_name)
 {
-	struct ld_session* lds;
+	struct ld_session *lds;
 
 	/*
 		* get ld session
 		*/
 
-	if ((lds = get_ld_session(_ld_name)) == NULL)
-	{
+	if((lds = get_ld_session(_ld_name)) == NULL) {
 		LM_ERR("ld_session [%s] not found\n", _ld_name);
 		return -1;
 	}
 
-	if (lds->handle == NULL) {
+	if(lds->handle == NULL) {
 		return 0;
 	}
 
@@ -257,30 +213,24 @@ int ldap_disconnect(char* _ld_name)
 	return 0;
 }
 
-int ldap_reconnect(char* _ld_name)
+int ldap_reconnect(char *_ld_name)
 {
 	int rc;
-	
-	if (ldap_disconnect(_ld_name) != 0)
-	{
+
+	if(ldap_disconnect(_ld_name) != 0) {
 		LM_ERR("[%s]: disconnect failed\n", _ld_name);
 		return -1;
 	}
 
-	if ((rc = ldap_connect_ex(_ld_name, L_INFO)) != 0)
-	{
-		LM_ERR("[%s]: reconnect failed\n",
-				_ld_name);
-	}
-	else
-	{
-		LM_NOTICE("[%s]: LDAP reconnect successful\n",
-				_ld_name);
+	if((rc = ldap_connect_ex(_ld_name, L_INFO)) != 0) {
+		LM_ERR("[%s]: reconnect failed\n", _ld_name);
+	} else {
+		LM_NOTICE("[%s]: LDAP reconnect successful\n", _ld_name);
 	}
 	return rc;
 }
 
-int ldap_get_vendor_version(char** _version)
+int ldap_get_vendor_version(char **_version)
 {
 	static char version[128];
 	LDAPAPIInfo api;
@@ -291,17 +241,15 @@ int ldap_get_vendor_version(char** _version)
 #else
 	api.ldapai_info_version = 1;
 #endif
-	
-	if (ldap_get_option(NULL, LDAP_OPT_API_INFO, &api) != LDAP_SUCCESS)
-	{
+
+	if(ldap_get_option(NULL, LDAP_OPT_API_INFO, &api) != LDAP_SUCCESS) {
 		LM_ERR("ldap_get_option(API_INFO) failed\n");
 		return -1;
 	}
 
 	rc = snprintf(version, 128, "%s - %d", api.ldapai_vendor_name,
 			api.ldapai_vendor_version);
-	if ((rc >= 128) || (rc < 0))
-	{
+	if((rc >= 128) || (rc < 0)) {
 		LM_ERR("snprintf failed\n");
 		return -1;
 	}

src/modules/ldap/ldap_connect.h

@@ -31,10 +31,9 @@
 #include "../../core/str.h"
 #include "../../core/dprint.h"
 
-extern int ldap_connect(char* _ld_name);
-extern int ldap_disconnect(char* _ld_name);
-extern int ldap_reconnect(char* _ld_name);
-extern int ldap_get_vendor_version(char** _version);
+extern int ldap_connect(char *_ld_name);
+extern int ldap_disconnect(char *_ld_name);
+extern int ldap_reconnect(char *_ld_name);
+extern int ldap_get_vendor_version(char **_version);
 
 #endif /* LDAP_CONNECT_H */
-

src/modules/ldap/ldap_escape.c

@@ -47,52 +47,47 @@ int ldap_rfc4515_escape(str *sin, str *sout, int url_encode)
 {
 	char *src, *dst;
 
-	if (sin == NULL || sout == NULL || sin->s == NULL || sout->s == NULL
-			|| sin->len <= 0 || sout->len < 3*sin->len+1)
-	{
+	if(sin == NULL || sout == NULL || sin->s == NULL || sout->s == NULL
+			|| sin->len <= 0 || sout->len < 3 * sin->len + 1) {
 		return -1;
 	}
 
 	src = sin->s;
 	dst = sout->s;
 
-	while (src < (sin->s + sin->len))
-	{
-		switch (*src)
-		{
-		case '*':
-			*dst++ = '\\';
-			*dst++ = '2';
-			*dst = 'a';
-			break;
-		case '(':
-			*dst++ = '\\';
-			*dst++ = '2';
-			*dst = '8';
-			break;
-		case ')':
-			*dst++ = '\\';
-			*dst++ = '2';
-			*dst = '9';
-			break;
-		case '\\':
-			*dst++ = '\\';
-			*dst++ = '5';
-			*dst = 'c';
-			break;
-		case '?':
-			if (url_encode)
-			{
-				*dst++ = '%';
-				*dst++ = '3';
-				*dst = 'F';
-			} else
-			{
+	while(src < (sin->s + sin->len)) {
+		switch(*src) {
+			case '*':
+				*dst++ = '\\';
+				*dst++ = '2';
+				*dst = 'a';
+				break;
+			case '(':
+				*dst++ = '\\';
+				*dst++ = '2';
+				*dst = '8';
+				break;
+			case ')':
+				*dst++ = '\\';
+				*dst++ = '2';
+				*dst = '9';
+				break;
+			case '\\':
+				*dst++ = '\\';
+				*dst++ = '5';
+				*dst = 'c';
+				break;
+			case '?':
+				if(url_encode) {
+					*dst++ = '%';
+					*dst++ = '3';
+					*dst = 'F';
+				} else {
+					*dst = *src;
+				}
+				break;
+			default:
 				*dst = *src;
-			}
-			break;
-		default:
-			*dst = *src;
 		}
 
 		src++;

src/modules/ldap/ldap_exp_fn.c

@@ -50,24 +50,22 @@ static char esc_buf[ESC_BUF_SIZE];
 
 /*
 * exported functions
-*/ 
+*/
 
-int ldap_search_impl(
-	struct sip_msg* _msg,
-	pv_elem_t* _ldap_url)
+int ldap_search_impl(struct sip_msg *_msg, pv_elem_t *_ldap_url)
 {
 	str ldap_url;
 	int ld_result_count = 0;
-	
+
 	/*
 	* do variable substitution for _ldap_url (pv_printf_s)
 	*/
-	if (_ldap_url==NULL) {
+	if(_ldap_url == NULL) {
 		LM_ERR("empty ldap_url\n");
 		return -2;
 	}
-	if ( _ldap_url->spec!=NULL && _ldap_url->spec->getf!=NULL) {
-		if (pv_printf_s( _msg, _ldap_url, &ldap_url)!=0 || ldap_url.len<=0) {
+	if(_ldap_url->spec != NULL && _ldap_url->spec->getf != NULL) {
+		if(pv_printf_s(_msg, _ldap_url, &ldap_url) != 0 || ldap_url.len <= 0) {
 			LM_ERR("pv_printf_s failed\n");
 			return -2;
 		}
@@ -78,13 +76,11 @@ int ldap_search_impl(
 	/*
 	* perform LDAP search
 	*/
-	if (ldap_url_search(ldap_url.s, &ld_result_count) != 0)
-	{
+	if(ldap_url_search(ldap_url.s, &ld_result_count) != 0) {
 		/* LDAP search error */
 		return -2;
 	}
-	if (ld_result_count < 1)
-	{
+	if(ld_result_count < 1) {
 		/* no LDAP entry found */
 		LM_INFO("no LDAP entry found\n");
 		return -1;
@@ -92,35 +88,28 @@ int ldap_search_impl(
 	return ld_result_count;
 }
 
-int ldap_write_result(
-	struct sip_msg* _msg,
-	struct ldap_result_params* _lrp,
-	struct subst_expr* _se)
+int ldap_write_result(struct sip_msg *_msg, struct ldap_result_params *_lrp,
+		struct subst_expr *_se)
 {
-	int_str                    dst_avp_name, dst_avp_val;
-	unsigned short             dst_avp_type;
-	int                        nmatches, rc, i, added_avp_count = 0;
-	struct berval              **attr_vals;
-	str                        avp_val_str, *subst_result = NULL;
-	int                        avp_val_int;
-	
+	int_str dst_avp_name, dst_avp_val;
+	unsigned short dst_avp_type;
+	int nmatches, rc, i, added_avp_count = 0;
+	struct berval **attr_vals;
+	str avp_val_str, *subst_result = NULL;
+	int avp_val_int;
+
 	/*
 	* get dst AVP name (dst_avp_name)
 	*/
-	
-	if (pv_get_avp_name(	_msg,
-				&(_lrp->dst_avp_spec.pvp), 
-				&dst_avp_name, 
-				&dst_avp_type)
-			!= 0) 
-	{
+
+	if(pv_get_avp_name(
+			   _msg, &(_lrp->dst_avp_spec.pvp), &dst_avp_name, &dst_avp_type)
+			!= 0) {
 		LM_ERR("error getting dst AVP name\n");
 		return -2;
 	}
-	if (dst_avp_type & AVP_NAME_STR)
-	{
-		if (dst_avp_name.s.len >= STR_BUF_SIZE)
-		{
+	if(dst_avp_type & AVP_NAME_STR) {
+		if(dst_avp_name.s.len >= STR_BUF_SIZE) {
 			LM_ERR("dst AVP name too long\n");
 			return -2;
 		}
@@ -132,9 +121,8 @@ int ldap_write_result(
 	/*
 	* get LDAP attr values
 	*/
-	if ((rc = ldap_get_attr_vals(&_lrp->ldap_attr_name, &attr_vals)) != 0)
-	{
-		if (rc > 0) {
+	if((rc = ldap_get_attr_vals(&_lrp->ldap_attr_name, &attr_vals)) != 0) {
+		if(rc > 0) {
 			return -1;
 		} else {
 			return -2;
@@ -144,52 +132,42 @@ int ldap_write_result(
 	/*
 	* add AVPs
 	*/
-	for (i = 0; attr_vals[i] != NULL; i++)
-	{
-		if (_se == NULL)
-		{
+	for(i = 0; attr_vals[i] != NULL; i++) {
+		if(_se == NULL) {
 			avp_val_str.s = attr_vals[i]->bv_val;
 			avp_val_str.len = attr_vals[i]->bv_len;
-		}
-		else
-		{
-			subst_result = subst_str(attr_vals[i]->bv_val, _msg, _se,
-					&nmatches);
-			if ((subst_result == NULL) || (nmatches < 1))
-			{
+		} else {
+			subst_result =
+					subst_str(attr_vals[i]->bv_val, _msg, _se, &nmatches);
+			if((subst_result == NULL) || (nmatches < 1)) {
 				continue;
 			}
 			avp_val_str = *subst_result;
 		}
 
-		if (_lrp->dst_avp_val_type == 1)
-		{
+		if(_lrp->dst_avp_val_type == 1) {
 			/* try to convert ldap value to integer */
-			if (!str2sint(&avp_val_str, &avp_val_int)) 
-			{
+			if(!str2sint(&avp_val_str, &avp_val_int)) {
 				dst_avp_val.n = avp_val_int;
 				rc = add_avp(dst_avp_type, dst_avp_name, dst_avp_val);
-			} else
-			{
+			} else {
 				continue;
 			}
-		} else
-		{
+		} else {
 			/* save ldap value as string */
 			dst_avp_val.s = avp_val_str;
-			rc = add_avp(dst_avp_type|AVP_VAL_STR, dst_avp_name, dst_avp_val);
+			rc = add_avp(dst_avp_type | AVP_VAL_STR, dst_avp_name, dst_avp_val);
 		}
-		
-		if (subst_result != NULL) {
-			if (subst_result->s != 0) {
+
+		if(subst_result != NULL) {
+			if(subst_result->s != 0) {
 				pkg_free(subst_result->s);
 			}
 			pkg_free(subst_result);
 			subst_result = NULL;
 		}
-		
-		if (rc < 0) 
-		{
+
+		if(rc < 0) {
 			LM_ERR("failed to create new AVP\n");
 			ldap_value_free_len(attr_vals);
 			return -2;
@@ -197,12 +175,10 @@ int ldap_write_result(
 		added_avp_count++;
 	}
 	ldap_value_free_len(attr_vals);
-	
-	if (added_avp_count > 0)
-	{
+
+	if(added_avp_count > 0) {
 		return added_avp_count;
-	} else
-	{
+	} else {
 		return -1;
 	}
 }
@@ -212,22 +188,19 @@ int ldap_result_next(void)
 	int rc;
 
 	rc = ldap_inc_result_pointer();
-	switch (rc)
-	{
-	case 1:
-		return -1;
-	case 0:
-		return 1;
-	case -1:
-	default:
-		return -2;
+	switch(rc) {
+		case 1:
+			return -1;
+		case 0:
+			return 1;
+		case -1:
+		default:
+			return -2;
 	}
 }
 
-int ldap_result_check(
-	struct sip_msg* _msg,
-	struct ldap_result_check_params* _lrp,
-	struct subst_expr* _se)
+int ldap_result_check(struct sip_msg *_msg,
+		struct ldap_result_check_params *_lrp, struct subst_expr *_se)
 {
 	str check_str, *subst_result = NULL;
 	int rc, i, nmatches;
@@ -237,29 +210,25 @@ int ldap_result_check(
 	/*
 	* do variable substitution for check_str 
 	*/
-	
-	if (_lrp->check_str_elem_p)
-	{
-		if (pv_printf_s(_msg, _lrp->check_str_elem_p, &check_str) != 0)
-		{
+
+	if(_lrp->check_str_elem_p) {
+		if(pv_printf_s(_msg, _lrp->check_str_elem_p, &check_str) != 0) {
 			LM_ERR("pv_printf_s failed\n");
 			return -2;
 		}
-	} else 
-	{
+	} else {
 		LM_ERR("empty check string\n");
 		return -2;
 	}
 
 	LM_DBG("check_str [%s]\n", check_str.s);
-	
+
 	/*
 	* get LDAP attr values
 	*/
-	
-	if ((rc = ldap_get_attr_vals(&_lrp->ldap_attr_name, &attr_vals)) != 0)
-	{
-		if (rc > 0) {
+
+	if((rc = ldap_get_attr_vals(&_lrp->ldap_attr_name, &attr_vals)) != 0) {
+		if(rc > 0) {
 			return -1;
 		} else {
 			return -2;
@@ -269,31 +238,25 @@ int ldap_result_check(
 	/*
 	* loop through attribute values
 	*/
-	
-	for (i = 0; attr_vals[i] != NULL; i++)
-	{
-		if (_se == NULL)
-		{
+
+	for(i = 0; attr_vals[i] != NULL; i++) {
+		if(_se == NULL) {
 			attr_val = attr_vals[i]->bv_val;
-		} else
-		{	
-			subst_result = subst_str(attr_vals[i]->bv_val, _msg, _se,
-					&nmatches);
-			if ((subst_result == NULL) || (nmatches < 1))
-			{
+		} else {
+			subst_result =
+					subst_str(attr_vals[i]->bv_val, _msg, _se, &nmatches);
+			if((subst_result == NULL) || (nmatches < 1)) {
 				continue;
 			}
 			attr_val = subst_result->s;
 		}
-		
+
 		LM_DBG("attr_val [%s]\n", attr_val);
 		rc = strncmp(check_str.s, attr_val, check_str.len);
-		if (_se != NULL) 
-		{
+		if(_se != NULL) {
 			pkg_free(subst_result->s);
 		}
-		if (rc == 0)
-		{
+		if(rc == 0) {
 			ldap_value_free_len(attr_vals);
 			return 1;
 		}
@@ -303,20 +266,18 @@ int ldap_result_check(
 	return -1;
 }
 
-int ldap_filter_url_encode(
-	struct sip_msg* _msg,
-	pv_elem_t* _filter_component,
-	pv_spec_t* _dst_avp_spec)
+int ldap_filter_url_encode(struct sip_msg *_msg, pv_elem_t *_filter_component,
+		pv_spec_t *_dst_avp_spec)
 {
-	str             filter_component_str, esc_str;	
-	int_str         dst_avp_name;
-	unsigned short  dst_avp_type;
+	str filter_component_str, esc_str;
+	int_str dst_avp_name;
+	unsigned short dst_avp_type;
 
 	/*
 	* variable substitution for _filter_component
 	*/
-	if (_filter_component) {
-		if (pv_printf_s(_msg, _filter_component, &filter_component_str) != 0) {
+	if(_filter_component) {
+		if(pv_printf_s(_msg, _filter_component, &filter_component_str) != 0) {
 			LM_ERR("pv_printf_s failed\n");
 			return -1;
 		}
@@ -328,16 +289,14 @@ int ldap_filter_url_encode(
 	/*
 	* get dst AVP name (dst_avp_name)
 	*/
-	if (pv_get_avp_name(_msg, &(_dst_avp_spec->pvp), &dst_avp_name,
-				&dst_avp_type) != 0)
-	{
+	if(pv_get_avp_name(
+			   _msg, &(_dst_avp_spec->pvp), &dst_avp_name, &dst_avp_type)
+			!= 0) {
 		LM_ERR("error getting dst AVP name\n");
 		return -1;
 	}
-	if (dst_avp_type & AVP_NAME_STR)
-	{
-		if (dst_avp_name.s.len >= STR_BUF_SIZE)
-		{
+	if(dst_avp_type & AVP_NAME_STR) {
+		if(dst_avp_name.s.len >= STR_BUF_SIZE) {
 			LM_ERR("dst AVP name too long\n");
 			return -1;
 		}
@@ -351,8 +310,7 @@ int ldap_filter_url_encode(
 	*/
 	esc_str.s = esc_buf;
 	esc_str.len = ESC_BUF_SIZE;
-	if (ldap_rfc4515_escape(&filter_component_str, &esc_str, 1) != 0)
-	{
+	if(ldap_rfc4515_escape(&filter_component_str, &esc_str, 1) != 0) {
 		LM_ERR("ldap_rfc4515_escape() failed\n");
 		return -1;
 	}
@@ -360,8 +318,8 @@ int ldap_filter_url_encode(
 	/*
 	* add dst AVP
 	*/
-	if (add_avp(dst_avp_type|AVP_VAL_STR, dst_avp_name, (int_str)esc_str) != 0)
-	{
+	if(add_avp(dst_avp_type | AVP_VAL_STR, dst_avp_name, (int_str)esc_str)
+			!= 0) {
 		LM_ERR("failed to add new AVP\n");
 		return -1;
 	}

src/modules/ldap/ldap_exp_fn.h

@@ -36,41 +36,30 @@
 
 struct ldap_result_params
 {
-	str         ldap_attr_name;
-	int         dst_avp_val_type; /* 0: str, 1: int */
-	pv_spec_t   dst_avp_spec;
+	str ldap_attr_name;
+	int dst_avp_val_type; /* 0: str, 1: int */
+	pv_spec_t dst_avp_spec;
 };
 
 struct ldap_result_check_params
 {
-	str          ldap_attr_name;
-	pv_elem_p    check_str_elem_p;
+	str ldap_attr_name;
+	pv_elem_p check_str_elem_p;
 };
 
-int ldap_search_impl(
-	struct sip_msg* _msg, 
-	pv_elem_t* _ldap_url);
+int ldap_search_impl(struct sip_msg *_msg, pv_elem_t *_ldap_url);
 
-int ldap_write_result(
-	struct sip_msg* _msg,
-	struct ldap_result_params* _lrp,
-	struct subst_expr* _se);
+int ldap_write_result(struct sip_msg *_msg, struct ldap_result_params *_lrp,
+		struct subst_expr *_se);
 
 int ldap_result_next(void);
 
-int ldap_filter_url_encode(
-	struct sip_msg* _msg,
-	pv_elem_t* _filter_component,
-	pv_spec_t* _dst_avp_spec);
+int ldap_filter_url_encode(struct sip_msg *_msg, pv_elem_t *_filter_component,
+		pv_spec_t *_dst_avp_spec);
 
-int rfc2254_escape(
-	struct sip_msg* _msg,
-	char* _value,
-	char* _avp_name);
+int rfc2254_escape(struct sip_msg *_msg, char *_value, char *_avp_name);
 
-int ldap_result_check(
-	struct sip_msg* _msg,
-	struct ldap_result_check_params* _lrp,
-	struct subst_expr* _se);
+int ldap_result_check(struct sip_msg *_msg,
+		struct ldap_result_check_params *_lrp, struct subst_expr *_se);
 
 #endif /* LDAP_EXP_FN_H */

src/modules/ldap/ldap_mod.c

@@ -54,29 +54,29 @@ static int child_init(int rank);
 /*
 * fixup functions
 */
-static int ldap_search_fixup(void** param, int param_no);
-static int ldap_result_fixup(void** param, int param_no);
-static int ldap_filter_url_encode_fixup(void** param, int param_no);
-static int ldap_result_check_fixup(void** param, int param_no);
+static int ldap_search_fixup(void **param, int param_no);
+static int ldap_result_fixup(void **param, int param_no);
+static int ldap_filter_url_encode_fixup(void **param, int param_no);
+static int ldap_result_check_fixup(void **param, int param_no);
 
 /*
 * exported functions
 */
 
-static int w_ldap_search(struct sip_msg* msg, char* ldap_url, char* param);
-static int w_ldap_result1(struct sip_msg* msg, char* src, char* param);
-static int w_ldap_result2(struct sip_msg* msg, char* src, char* subst);
-static int w_ldap_result_next(struct sip_msg* msg, char* foo, char *bar);
-static int w_ldap_filter_url_encode(struct sip_msg* msg, 
-		char* filter_component, char* dst_avp_name);
-static int w_ldap_result_check_1(struct sip_msg* msg, 
-		char* attr_name_check_str, char* param);
-static int w_ldap_result_check_2(struct sip_msg* msg,
-		char* attr_name_check_str, char* attr_val_re);
+static int w_ldap_search(struct sip_msg *msg, char *ldap_url, char *param);
+static int w_ldap_result1(struct sip_msg *msg, char *src, char *param);
+static int w_ldap_result2(struct sip_msg *msg, char *src, char *subst);
+static int w_ldap_result_next(struct sip_msg *msg, char *foo, char *bar);
+static int w_ldap_filter_url_encode(
+		struct sip_msg *msg, char *filter_component, char *dst_avp_name);
+static int w_ldap_result_check_1(
+		struct sip_msg *msg, char *attr_name_check_str, char *param);
+static int w_ldap_result_check_2(
+		struct sip_msg *msg, char *attr_name_check_str, char *attr_val_re);
 
 
-/* 
-* Default module parameter values 
+/*
+* Default module parameter values
 */
 #define DEF_LDAP_CONFIG "/usr/local/etc/kamailio/ldap.cfg"
 
@@ -84,36 +84,36 @@ static int w_ldap_result_check_2(struct sip_msg* msg,
 * Module parameter variables
 */
 str ldap_config = str_init(DEF_LDAP_CONFIG);
-static dictionary* config_vals = NULL;
+static dictionary *config_vals = NULL;
 
 /*
-* Exported functions
-*/
+ * Exported functions
+ */
+/* clang-format off */
 static cmd_export_t cmds[] = {
-	{"ldap_search",            (cmd_function)w_ldap_search,            1, 
+	{"ldap_search",            (cmd_function)w_ldap_search,            1,
 		ldap_search_fixup, 0,
 		REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
-	{"ldap_result",            (cmd_function)w_ldap_result1,           1, 
+	{"ldap_result",            (cmd_function)w_ldap_result1,           1,
 		ldap_result_fixup, 0,
 		REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
-	{"ldap_result",            (cmd_function)w_ldap_result2,           2, 
+	{"ldap_result",            (cmd_function)w_ldap_result2,           2,
 		ldap_result_fixup, 0,
 		REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
-	{"ldap_result_next",       (cmd_function)w_ldap_result_next,       0, 
+	{"ldap_result_next",       (cmd_function)w_ldap_result_next,       0,
 		0, 0,
 		REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
-	{"ldap_result_check",      (cmd_function)w_ldap_result_check_1,    1, 
+	{"ldap_result_check",      (cmd_function)w_ldap_result_check_1,    1,
 		ldap_result_check_fixup, 0,
 		REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
-	{"ldap_result_check",      (cmd_function)w_ldap_result_check_2,    2, 
+	{"ldap_result_check",      (cmd_function)w_ldap_result_check_2,    2,
 		ldap_result_check_fixup, 0,
 		REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
-	{"ldap_filter_url_encode", (cmd_function)w_ldap_filter_url_encode, 2, 
+	{"ldap_filter_url_encode", (cmd_function)w_ldap_filter_url_encode, 2,
 		ldap_filter_url_encode_fixup, 0,
 		REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
 	{"load_ldap",              (cmd_function)load_ldap,  0,
-		0, 0,
-		0},
+		0, 0, 0},
 	{0, 0, 0, 0, 0, 0}
 };
 
@@ -132,7 +132,7 @@ static param_export_t params[] = {
 * Module interface
 */
 struct module_exports exports = {
-	"ldap", 
+	"ldap",
 	DEFAULT_DLFLAGS, /* dlopen flags */
 	cmds,       /* Exported functions */
 	params,     /* Exported parameters */
@@ -145,42 +145,36 @@ struct module_exports exports = {
 	destroy,    /* destroy function */
 	child_init  /* child initialization function */
 };
+/* clang-format on */
 
 
 static int child_init(int rank)
 {
 	int i = 0, ld_count = 0;
-	char* ld_name;
-	
+	char *ld_name;
+
 	/* don't do anything for non-worker processes */
-	if (rank==PROC_INIT || rank==PROC_MAIN || rank==PROC_TCP_MAIN)
+	if(rank == PROC_INIT || rank == PROC_MAIN || rank == PROC_TCP_MAIN)
 		return 0;
 
 	/*
 	* build ld_sessions and connect all sessions
 	*/
 	ld_count = iniparser_getnsec(config_vals);
-	for (i = 0; i < ld_count; i++)
-	{
+	for(i = 0; i < ld_count; i++) {
 		ld_name = iniparser_getsecname(config_vals, i);
-		if (add_ld_session(ld_name,
-					NULL,
-					config_vals)
-				!= 0)
-		{
+		if(add_ld_session(ld_name, NULL, config_vals) != 0) {
 			LM_ERR("[%s]: add_ld_session failed\n", ld_name);
 			return -1;
 		}
 
-		if (ldap_connect(ld_name) != 0)
-		{
+		if(ldap_connect(ld_name) != 0) {
 			LM_ERR("[%s]: failed to connect to LDAP host(s)\n", ld_name);
 			ldap_disconnect(ld_name);
 			return -1;
 		}
-		
 	}
-	
+
 	return 0;
 }
 
@@ -188,53 +182,45 @@ static int child_init(int rank)
 static int mod_init(void)
 {
 	int ld_count = 0, i = 0;
-	char* section_name;
-	char* ldap_version;
-	
+	char *section_name;
+	char *ldap_version;
+
 	/*
 	* read config file
 	*/
-	if (ldap_config.len <= 0)
-	{
+	if(ldap_config.len <= 0) {
 		LM_ERR("config_file is empty - this module param is mandatory\n");
 		return -2;
 	}
-	if ((config_vals = iniparser_new(ldap_config.s)) == NULL)
-	{
+	if((config_vals = iniparser_new(ldap_config.s)) == NULL) {
 		LM_ERR("failed to read config_file [%s]\n", ldap_config.s);
 		return -2;
 	}
-	if ((ld_count = iniparser_getnsec(config_vals)) < 1)
-	{
+	if((ld_count = iniparser_getnsec(config_vals)) < 1) {
 		LM_ERR("no section found in config_file [%s]\n", ldap_config.s);
 		return -2;
 	}
 	/* check if mandatory settings are present */
-	for (i = 0; i < ld_count; i++)
-	{
+	for(i = 0; i < ld_count; i++) {
 		section_name = iniparser_getsecname(config_vals, i);
-		if (strlen(section_name) > 255)
-		{
-			LM_ERR(	"config_file section name [%s]"
-				" longer than allowed 255 characters",
-				section_name);
+		if(strlen(section_name) > 255) {
+			LM_ERR("config_file section name [%s]"
+				   " longer than allowed 255 characters",
+					section_name);
 			return -2;
 		}
-		if (!iniparser_find_entry(config_vals,
-					get_ini_key_name(section_name, CFG_N_LDAP_HOST)))
-		{
-			LM_ERR(	"mandatory %s not defined in [%s]\n", 
-				CFG_N_LDAP_HOST, 
-				section_name);
+		if(!iniparser_find_entry(config_vals,
+				   get_ini_key_name(section_name, CFG_N_LDAP_HOST))) {
+			LM_ERR("mandatory %s not defined in [%s]\n", CFG_N_LDAP_HOST,
+					section_name);
 			return -2;
 		}
-	}	
-	
+	}
+
 	/*
 	* print ldap version string
 	*/
-	if (ldap_get_vendor_version(&ldap_version) != 0)
-	{
+	if(ldap_get_vendor_version(&ldap_version) != 0) {
 		LM_ERR("ldap_get_vendor_version failed\n");
 		return -2;
 	}
@@ -258,153 +244,146 @@ static void destroy(void)
 * EXPORTED functions
 */
 
-static int w_ldap_search(struct sip_msg* msg, char* ldap_url, char* param)
+static int w_ldap_search(struct sip_msg *msg, char *ldap_url, char *param)
 {
-	return ldap_search_impl(msg, (pv_elem_t*)ldap_url);
+	return ldap_search_impl(msg, (pv_elem_t *)ldap_url);
 }
 
-static int w_ldap_result1(struct sip_msg* msg, char* src, char* param)
+static int w_ldap_result1(struct sip_msg *msg, char *src, char *param)
 {
-	return ldap_write_result(msg, (struct ldap_result_params*)src, NULL);
+	return ldap_write_result(msg, (struct ldap_result_params *)src, NULL);
 }
 
-static int w_ldap_result2(struct sip_msg* msg, char* src, char* subst)
+static int w_ldap_result2(struct sip_msg *msg, char *src, char *subst)
 {
-	return ldap_write_result(msg, (struct ldap_result_params*)src,
-			(struct subst_expr*)subst);
+	return ldap_write_result(
+			msg, (struct ldap_result_params *)src, (struct subst_expr *)subst);
 }
 
-static int w_ldap_result_next(struct sip_msg* msg, char* foo, char *bar)
+static int w_ldap_result_next(struct sip_msg *msg, char *foo, char *bar)
 {
 	return ldap_result_next();
 }
 
-static int w_ldap_filter_url_encode(struct sip_msg* msg,
-		char* filter_component, char* dst_avp_name)
+static int w_ldap_filter_url_encode(
+		struct sip_msg *msg, char *filter_component, char *dst_avp_name)
 {
-	return ldap_filter_url_encode(msg, (pv_elem_t*)filter_component,
-			(pv_spec_t*)dst_avp_name);
+	return ldap_filter_url_encode(
+			msg, (pv_elem_t *)filter_component, (pv_spec_t *)dst_avp_name);
 }
 
-static int w_ldap_result_check_1(struct sip_msg* msg,
-		char* attr_name_check_str, char* param)
+static int w_ldap_result_check_1(
+		struct sip_msg *msg, char *attr_name_check_str, char *param)
 {
-	return ldap_result_check(msg,
-			(struct ldap_result_check_params*)attr_name_check_str, NULL);
+	return ldap_result_check(
+			msg, (struct ldap_result_check_params *)attr_name_check_str, NULL);
 }
 
-static int w_ldap_result_check_2(struct sip_msg* msg,
-		char* attr_name_check_str, char* attr_val_re)
+static int w_ldap_result_check_2(
+		struct sip_msg *msg, char *attr_name_check_str, char *attr_val_re)
 {
-	return ldap_result_check( msg, 
-		(struct ldap_result_check_params*)attr_name_check_str, 
-		(struct subst_expr*)attr_val_re);
+	return ldap_result_check(msg,
+			(struct ldap_result_check_params *)attr_name_check_str,
+			(struct subst_expr *)attr_val_re);
 }
 
 /*
 * FIXUP functions
 */
 
-static int ldap_search_fixup(void** param, int param_no)
+static int ldap_search_fixup(void **param, int param_no)
 {
 	pv_elem_t *model;
 	str s;
 
-	if (param_no == 1) {
-		s.s = (char*)*param;
+	if(param_no == 1) {
+		s.s = (char *)*param;
 		s.len = strlen(s.s);
-		if (s.len==0) {
+		if(s.len == 0) {
 			LM_ERR("ldap url is empty string!\n");
 			return E_CFG;
 		}
-		if ( pv_parse_format(&s,&model) || model==NULL) {
+		if(pv_parse_format(&s, &model) || model == NULL) {
 			LM_ERR("wrong format [%s] for ldap url!\n", s.s);
 			return E_CFG;
 		}
-		*param = (void*)model;
+		*param = (void *)model;
 	}
 
 	return 0;
 }
 
-static int ldap_result_fixup(void** param, int param_no)
+static int ldap_result_fixup(void **param, int param_no)
 {
-	struct ldap_result_params* lp;
-	struct subst_expr* se;
+	struct ldap_result_params *lp;
+	struct subst_expr *se;
 	str subst;
 	char *arg_str, *dst_avp_str, *dst_avp_val_type_str;
 	char *p;
 	str s;
 	int dst_avp_val_type = 0;
-	
-	if (param_no == 1) {
-		arg_str = (char*)*param;
-		if ((dst_avp_str = strchr(arg_str, '/')) == 0) 
-		{
+
+	if(param_no == 1) {
+		arg_str = (char *)*param;
+		if((dst_avp_str = strchr(arg_str, '/')) == 0) {
 			/* no / found in arg_str */
 			LM_ERR("invalid first argument [%s]\n", arg_str);
 			return E_UNSPEC;
 		}
 		*(dst_avp_str++) = 0;
 
-		if ((dst_avp_val_type_str = strchr(dst_avp_str, '/')))
-		{
+		if((dst_avp_val_type_str = strchr(dst_avp_str, '/'))) {
 			*(dst_avp_val_type_str++) = 0;
-			if (!strcmp(dst_avp_val_type_str, "int"))
-			{
+			if(!strcmp(dst_avp_val_type_str, "int")) {
 				dst_avp_val_type = 1;
-			}
-			else if (strcmp(dst_avp_val_type_str, "str"))
-			{
-				LM_ERR(	"invalid avp_type [%s]\n",
-					dst_avp_val_type_str);
+			} else if(strcmp(dst_avp_val_type_str, "str")) {
+				LM_ERR("invalid avp_type [%s]\n", dst_avp_val_type_str);
 				return E_UNSPEC;
 			}
 		}
 
-		lp = (struct ldap_result_params*)pkg_malloc(sizeof(struct ldap_result_params));
-		if (lp == NULL) {
+		lp = (struct ldap_result_params *)pkg_malloc(
+				sizeof(struct ldap_result_params));
+		if(lp == NULL) {
 			LM_ERR("no memory\n");
 			return E_OUT_OF_MEM;
 		}
 		memset(lp, 0, sizeof(struct ldap_result_params));
-		
+
 		lp->ldap_attr_name.s = arg_str;
 		lp->ldap_attr_name.len = strlen(arg_str);
 
 		lp->dst_avp_val_type = dst_avp_val_type;
-		s.s = dst_avp_str; s.len = strlen(s.s);
+		s.s = dst_avp_str;
+		s.len = strlen(s.s);
 		p = pv_parse_spec(&s, &lp->dst_avp_spec);
-		if (p == 0) {
+		if(p == 0) {
 			pkg_free(lp);
-			LM_ERR("parse error for [%s]\n",
-					dst_avp_str);
+			LM_ERR("parse error for [%s]\n", dst_avp_str);
 			return E_UNSPEC;
 		}
-		if (lp->dst_avp_spec.type != PVT_AVP) {
+		if(lp->dst_avp_spec.type != PVT_AVP) {
 			pkg_free(lp);
-			LM_ERR(	"bad attribute name [%s]\n",
-				dst_avp_str);
+			LM_ERR("bad attribute name [%s]\n", dst_avp_str);
 			return E_UNSPEC;
 		}
-		*param = (void*)lp;
-		
-	} else if (param_no == 2) {
+		*param = (void *)lp;
+
+	} else if(param_no == 2) {
 		subst.s = *param;
 		subst.len = strlen(*param);
 		se = subst_parser(&subst);
-		if (se == 0) {
-			LM_ERR("bad subst re [%s]\n",
-			(char*)*param);
+		if(se == 0) {
+			LM_ERR("bad subst re [%s]\n", (char *)*param);
 			return E_BAD_RE;
 		}
-		*param = (void*)se;
+		*param = (void *)se;
 	}
 
 	return 0;
 }
 
-static int ldap_result_check_fixup(void** param, int param_no)
+static int ldap_result_check_fixup(void **param, int param_no)
 {
 	struct ldap_result_check_params *lp;
 	struct subst_expr *se;
@@ -412,22 +391,20 @@ static int ldap_result_check_fixup(void** param, int param_no)
 	str s;
 	char *arg_str, *check_str;
 	int arg_str_len;
-	
-	if (param_no == 1)
-	{
-		arg_str = (char*)*param;
+
+	if(param_no == 1) {
+		arg_str = (char *)*param;
 		arg_str_len = strlen(arg_str);
-		if ((check_str = strchr(arg_str, '/')) == 0)
-		{
+		if((check_str = strchr(arg_str, '/')) == 0) {
 			/* no / found in arg_str */
-			LM_ERR(	"invalid first argument [%s] (no '/' found)\n",
-				arg_str);
+			LM_ERR("invalid first argument [%s] (no '/' found)\n", arg_str);
 			return E_UNSPEC;
 		}
 		*(check_str++) = 0;
-		
-		lp = (struct ldap_result_check_params*)pkg_malloc(sizeof(struct ldap_result_check_params));
-		if (lp == NULL) {
+
+		lp = (struct ldap_result_check_params *)pkg_malloc(
+				sizeof(struct ldap_result_check_params));
+		if(lp == NULL) {
 			LM_ERR("no memory\n");
 			return E_OUT_OF_MEM;
 		}
@@ -436,81 +413,72 @@ static int ldap_result_check_fixup(void** param, int param_no)
 		lp->ldap_attr_name.s = arg_str;
 		lp->ldap_attr_name.len = strlen(arg_str);
 
-		if (lp->ldap_attr_name.len + 1 == arg_str_len)
-		{
+		if(lp->ldap_attr_name.len + 1 == arg_str_len) {
 			/* empty check_str */
 			lp->check_str_elem_p = 0;
-		}
-		else
-		{
-			s.s = check_str; s.len = strlen(s.s);
-			if (pv_parse_format(&s, &(lp->check_str_elem_p)) < 0)
-			{
+		} else {
+			s.s = check_str;
+			s.len = strlen(s.s);
+			if(pv_parse_format(&s, &(lp->check_str_elem_p)) < 0) {
 				LM_ERR("pv_parse_format failed\n");
 				pkg_free(lp);
 				return E_OUT_OF_MEM;
 			}
-		}	
-		*param = (void*)lp;
-	}
-	else if (param_no == 2)
-	{
+		}
+		*param = (void *)lp;
+	} else if(param_no == 2) {
 		subst.s = *param;
 		subst.len = strlen(*param);
 		se = subst_parser(&subst);
-		if (se == 0) {
-			LM_ERR(	"bad subst re [%s]\n",
-				(char*)*param);
+		if(se == 0) {
+			LM_ERR("bad subst re [%s]\n", (char *)*param);
 			return E_BAD_RE;
 		}
-		*param = (void*)se;
+		*param = (void *)se;
 	}
 
-	return 0;	
+	return 0;
 }
 
-static int ldap_filter_url_encode_fixup(void** param, int param_no)
+static int ldap_filter_url_encode_fixup(void **param, int param_no)
 {
 	pv_elem_t *elem_p;
 	pv_spec_t *spec_p;
 	str s;
 
-	if (param_no == 1) {
-		s.s = (char*)*param;
-		if (s.s==0 || s.s[0]==0) {
+	if(param_no == 1) {
+		s.s = (char *)*param;
+		if(s.s == 0 || s.s[0] == 0) {
 			elem_p = 0;
 		} else {
 			s.len = strlen(s.s);
-			if (pv_parse_format(&s, &elem_p) < 0) {
+			if(pv_parse_format(&s, &elem_p) < 0) {
 				LM_ERR("pv_parse_format failed\n");
 				return E_OUT_OF_MEM;
 			}
 		}
-		*param = (void*)elem_p;
-	}
-	else if (param_no == 2)
-	{
-		spec_p = (pv_spec_t*)pkg_malloc(sizeof(pv_spec_t));
-		if (spec_p == NULL) {
+		*param = (void *)elem_p;
+	} else if(param_no == 2) {
+		spec_p = (pv_spec_t *)pkg_malloc(sizeof(pv_spec_t));
+		if(spec_p == NULL) {
 			LM_ERR("no memory\n");
 			return E_OUT_OF_MEM;
 		}
-		s.s = (char*)*param; s.len = strlen(s.s);
-		if (pv_parse_spec(&s, spec_p)
-				== 0)
-		{
+		s.s = (char *)*param;
+		s.len = strlen(s.s);
+		if(pv_parse_spec(&s, spec_p) == 0) {
 			pkg_free(spec_p);
-			LM_ERR("parse error for [%s]\n",
-				(char*)*param);
+			LM_ERR("parse error for [%s]\n", (char *)*param);
 			return E_UNSPEC;
 		}
-		if (spec_p->type != PVT_AVP) {
+		if(spec_p->type != PVT_AVP) {
 			pkg_free(spec_p);
 			LM_ERR("bad attribute name"
-				" [%s]\n", (char*)*param);
+				   " [%s]\n",
+					(char *)*param);
 			return E_UNSPEC;
 		}
-		*param = (void*)spec_p;
+		*param = (void *)spec_p;
 	}
 
 	return 0;