path: root/patches/inadyn-1.96.2/inadyn_patch.diff

Extend the program to support more than one dynamic IP provider in one
configuration file.

Patch made by Christian Eyrich, http://www.eyrich-net.org/programmiertes.html

Signed-off-by: (no sign yet, ask upstream)
---
 man/inadyn.8      |    5 
 src/dyndns.c      |  325 ++++++++++++++++++++++++++++++++----------------------
 src/dyndns.h      |   35 +++--
 src/http_client.c |   10 +
 src/http_client.h |    2 
 src/inadyn_cmd.c  |  131 ++++++++++++++-------
 6 files changed, 315 insertions(+), 193 deletions(-)

Index: man/inadyn.8
===================================================================
--- man/inadyn.8.orig
+++ man/inadyn.8
@@ -36,6 +36,8 @@ inadyn \- a client for open DNS servers.
 .I sec
 ] [\-\-forced_update_period
 .I sec
+] [\-\-pid_file
+.I path/name
 ] [\-\-log_file
 .I path/name
 ] [\-\-background] [\-\-verbose
@@ -140,6 +142,9 @@ should be given in seconds.
 .I \-\-log_file
 The name, including the full path, of a log file.
 .TP
+.I \-\-pid_file
+The name, including the full path, of a file which holds inadyn's process id.
+.TP
 .I \-\-background
 run in background. Output is sent to the UNIX syslog facilities 
 or to a log file, if one was specified.
Index: src/dyndns.c
===================================================================
--- src/dyndns.c.orig
+++ src/dyndns.c
@@ -46,15 +46,15 @@ DYNDNS_ORG_SPECIFIC_DATA dyndns_org_dyna
 DYNDNS_ORG_SPECIFIC_DATA dyndns_org_custom = {"custom"};
 DYNDNS_ORG_SPECIFIC_DATA dyndns_org_static = {"statdns"};
 
-static int get_req_for_dyndns_server(DYN_DNS_CLIENT *this, int nr, DYNDNS_SYSTEM *p_sys_info);
-static int get_req_for_freedns_server(DYN_DNS_CLIENT *p_self, int cnt,  DYNDNS_SYSTEM *p_sys_info);
-static int get_req_for_generic_http_dns_server(DYN_DNS_CLIENT *p_self, int cnt,  DYNDNS_SYSTEM *p_sys_info);
-static int get_req_for_noip_http_dns_server(DYN_DNS_CLIENT *p_self, int cnt,  DYNDNS_SYSTEM *p_sys_info);
-
-static BOOL is_dyndns_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, char* p_ok_string);
-static BOOL is_freedns_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, char* p_ok_string);
-static BOOL is_generic_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, char* p_ok_string);
-static BOOL is_zoneedit_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, char* p_ok_string);
+static int get_req_for_dyndns_server(DYN_DNS_CLIENT *this, int infcnt, int alcnt, DYNDNS_SYSTEM *p_sys_info);
+static int get_req_for_freedns_server(DYN_DNS_CLIENT *p_self, int infcnt, int alcnt,  DYNDNS_SYSTEM *p_sys_info);
+static int get_req_for_generic_http_dns_server(DYN_DNS_CLIENT *p_self, int infcnt, int alcnt,  DYNDNS_SYSTEM *p_sys_info);
+static int get_req_for_noip_http_dns_server(DYN_DNS_CLIENT *p_self, int infcnt, int alcnt,  DYNDNS_SYSTEM *p_sys_info);
+
+static BOOL is_dyndns_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, int infcnt, char* p_ok_string);
+static BOOL is_freedns_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, int infcnt, char* p_ok_string);
+static BOOL is_generic_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, int infcnt, char* p_ok_string);
+static BOOL is_zoneedit_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, int infcnt, char* p_ok_string);
 
 DYNDNS_SYSTEM_INFO dns_system_table[] = 
 { 
@@ -156,77 +156,78 @@ static RC_TYPE dyn_dns_wait_for_cmd(DYN_
 	return RC_OK;
 }
 
-static int get_req_for_dyndns_server(DYN_DNS_CLIENT *p_self, int cnt,DYNDNS_SYSTEM *p_sys_info)
+static int get_req_for_dyndns_server(DYN_DNS_CLIENT *p_self, int infcnt, int alcnt, DYNDNS_SYSTEM *p_sys_info)
 {	
     DYNDNS_ORG_SPECIFIC_DATA *p_dyndns_specific = 
 		(DYNDNS_ORG_SPECIFIC_DATA*) p_sys_info->p_specific_data;
+
 	return sprintf(p_self->p_req_buffer, DYNDNS_GET_MY_IP_HTTP_REQUEST_FORMAT,
-        p_self->info.dyndns_server_name.name,
-        p_self->info.dyndns_server_name.port,
-		p_self->info.dyndns_server_url,
+		p_self->info[infcnt].dyndns_server_name.name,
+		p_self->info[infcnt].dyndns_server_name.port,
+		p_self->info[infcnt].dyndns_server_url,
 		p_dyndns_specific->p_system,
-		p_self->alias_info.names[cnt].name,
-		p_self->info.my_ip_address.name,
-		p_self->alias_info.names[cnt].name,
-        p_self->info.dyndns_server_name.name,
-		p_self->info.credentials.p_enc_usr_passwd_buffer
+		p_self->info[infcnt].alias_info[alcnt].names.name,
+		p_self->info[infcnt].my_ip_address.name,
+		p_self->info[infcnt].alias_info[alcnt].names.name,
+		p_self->info[infcnt].dyndns_server_name.name,
+		p_self->info[infcnt].credentials.p_enc_usr_passwd_buffer
 		);
 }
 
-static int get_req_for_freedns_server(DYN_DNS_CLIENT *p_self, int cnt, DYNDNS_SYSTEM *p_sys_info)
+static int get_req_for_freedns_server(DYN_DNS_CLIENT *p_self, int infcnt, int alcnt, DYNDNS_SYSTEM *p_sys_info)
 {
 	(void)p_sys_info;
 	return sprintf(p_self->p_req_buffer, FREEDNS_UPDATE_MY_IP_REQUEST_FORMAT,
-        p_self->info.dyndns_server_name.name,
-        p_self->info.dyndns_server_name.port,
-		p_self->info.dyndns_server_url,
-		p_self->alias_info.hashes[cnt].str,
-        p_self->info.dyndns_server_name.name);
+		p_self->info[infcnt].dyndns_server_name.name,
+		p_self->info[infcnt].dyndns_server_name.port,
+		p_self->info[infcnt].dyndns_server_url,
+		p_self->info[infcnt].alias_info[alcnt].hashes.str,
+		p_self->info[infcnt].dyndns_server_name.name);
 }
 
 
-static int get_req_for_generic_http_dns_server(DYN_DNS_CLIENT *p_self, int cnt, DYNDNS_SYSTEM *p_sys_info)
+static int get_req_for_generic_http_dns_server(DYN_DNS_CLIENT *p_self, int infcnt, int alcnt, DYNDNS_SYSTEM *p_sys_info)
 {
 	(void)p_sys_info;
 	return sprintf(p_self->p_req_buffer, GENERIC_DNS_BASIC_AUTH_MY_IP_REQUEST_FORMAT,
-        p_self->info.dyndns_server_name.name,
-        p_self->info.dyndns_server_name.port,
-		p_self->info.dyndns_server_url,		
-		p_self->alias_info.names[cnt].name,
-        p_self->info.credentials.p_enc_usr_passwd_buffer,
-		p_self->info.dyndns_server_name.name);
+		p_self->info[infcnt].dyndns_server_name.name,
+		p_self->info[infcnt].dyndns_server_name.port,
+		p_self->info[infcnt].dyndns_server_url,
+		p_self->info[infcnt].alias_info[alcnt].names.name,
+		p_self->info[infcnt].credentials.p_enc_usr_passwd_buffer,
+		p_self->info[infcnt].dyndns_server_name.name);
 }
-static int get_req_for_noip_http_dns_server(DYN_DNS_CLIENT *p_self, int cnt,  DYNDNS_SYSTEM *p_sys_info)
+static int get_req_for_noip_http_dns_server(DYN_DNS_CLIENT *p_self, int infcnt, int alcnt,  DYNDNS_SYSTEM *p_sys_info)
 {
 	(void)p_sys_info;
 	return sprintf(p_self->p_req_buffer, GENERIC_NOIP_AUTH_MY_IP_REQUEST_FORMAT,
-        p_self->info.dyndns_server_name.name,
-        p_self->info.dyndns_server_name.port,
-		p_self->info.dyndns_server_url,		
-		p_self->alias_info.names[cnt].name,
-		p_self->info.my_ip_address.name,
-        p_self->info.credentials.p_enc_usr_passwd_buffer,
-		p_self->info.dyndns_server_name.name		
+		p_self->info[infcnt].dyndns_server_name.name,
+		p_self->info[infcnt].dyndns_server_name.port,
+		p_self->info[infcnt].dyndns_server_url,
+		p_self->info[infcnt].alias_info[alcnt].names.name,
+		p_self->info[infcnt].my_ip_address.name,
+		p_self->info[infcnt].credentials.p_enc_usr_passwd_buffer,
+		p_self->info[infcnt].dyndns_server_name.name
 		);
 }
 
-static int get_req_for_ip_server(DYN_DNS_CLIENT *p_self, void *p_specific_data)
+static int get_req_for_ip_server(DYN_DNS_CLIENT *p_self, int infcnt, void *p_specific_data)
 {
     return sprintf(p_self->p_req_buffer, DYNDNS_GET_MY_IP_HTTP_REQUEST,
-        p_self->info.ip_server_name.name, p_self->info.ip_server_name.port, p_self->info.ip_server_url);
+        p_self->info[infcnt].ip_server_name.name, p_self->info[infcnt].ip_server_name.port, p_self->info[infcnt].ip_server_url);
 }
 
 /* 
 	Send req to IP server and get the response
 */
-static RC_TYPE do_ip_server_transaction(DYN_DNS_CLIENT *p_self)
+static RC_TYPE do_ip_server_transaction(DYN_DNS_CLIENT *p_self, int servernum)
 {
 	RC_TYPE rc = RC_OK;
 	HTTP_CLIENT *p_http;
 
-	p_http = &p_self->http_to_ip_server;
+	p_http = &p_self->http_to_ip_server[servernum];
 
-	rc = http_client_init(&p_self->http_to_ip_server);
+	rc = http_client_init(p_http);
 	if (rc != RC_OK)
 	{
 		return rc;
@@ -239,7 +240,8 @@ static RC_TYPE do_ip_server_transaction(
 			HTTP_TRANSACTION *p_tr = &p_self->http_tr;
 
             p_tr->req_len = get_req_for_ip_server((DYN_DNS_CLIENT*) p_self,
-                                                     p_self->info.p_dns_system->p_specific_data);
+				servernum,
+				p_self->info[servernum].p_dns_system->p_specific_data);
 			if (p_self->dbg.level > 2) 
 			{
 				DBG_PRINTF((LOG_DEBUG, "The request for IP server:\n%s\n",p_self->p_req_buffer));
@@ -249,14 +251,14 @@ static RC_TYPE do_ip_server_transaction(
 			p_tr->max_rsp_len = p_self->work_buffer_size - 1;/*save place for a \0 at the end*/
 			p_tr->rsp_len = 0;
 
-			rc = http_client_transaction(&p_self->http_to_ip_server, &p_self->http_tr);		
+			rc = http_client_transaction(p_http, &p_self->http_tr);		
 			p_self->p_work_buffer[p_tr->rsp_len] = 0;
 		}
 	}
 	while(0);
 
 	/*close*/
-	http_client_shutdown(&p_self->http_to_ip_server);
+	http_client_shutdown(p_http);
 	
 	return rc;
 }
@@ -268,10 +270,10 @@ static RC_TYPE do_ip_server_transaction(
     Note:
         it updates the flag: info->'my_ip_has_changed' if the old address was different 
 */
-static RC_TYPE do_parse_my_ip_address(DYN_DNS_CLIENT *p_self)
+static RC_TYPE do_parse_my_ip_address(DYN_DNS_CLIENT *p_self, int servernum)
 {
 	int ip1 = 0, ip2 = 0, ip3 = 0, ip4 = 0;
-	int count;
+	int count, i;
 	char *p_ip;
 	char *p_current_str = p_self->http_tr.p_rsp;
 	BOOL found;
@@ -314,9 +316,14 @@ static RC_TYPE do_parse_my_ip_address(DY
 
 	if (found)
 	{        
+		i = 0;
+		do
+		{
         sprintf(new_ip_str, DYNDNS_IP_ADDR_FORMAT, ip1, ip2, ip3, ip4);
-        p_self->info.my_ip_has_changed = (strcmp(new_ip_str, p_self->info.my_ip_address.name) != 0);
-		strcpy(p_self->info.my_ip_address.name, new_ip_str);
+			p_self->info[i].my_ip_has_changed = (strcmp(new_ip_str, p_self->info[i].my_ip_address.name) != 0);
+			strcpy(p_self->info[i].my_ip_address.name, new_ip_str);
+		}
+		while(++i < p_self->info_count);
 		return RC_OK;
 	}
 	else
@@ -336,20 +343,26 @@ static RC_TYPE do_parse_my_ip_address(DY
 */
 static RC_TYPE do_check_alias_update_table(DYN_DNS_CLIENT *p_self)
 {
-	int i;	
+	int i, j;
 
-    if (p_self->info.my_ip_has_changed ||
+	/*uses fix test if ip of server 0 has changed */
+	/*that should be ok even if changes dyn_dns_update_ip to */
+	/*iterate over servernum, but not if it's fix set to =! 0 */
+	if (p_self->info[0].my_ip_has_changed ||
         p_self->force_addr_update ||
 	(p_self->times_since_last_update > p_self->forced_update_times)
        )
     {
-        for (i = 0; i < p_self->alias_info.count; ++i)
+		for (i = 0; i < p_self->info_count; i++)
 	    {
-            p_self->alias_info.update_required[i] = TRUE;
+			for (j = 0; j < p_self->info[i].alias_count; j++)
+			{
+				p_self->info[i].alias_info[j].update_required = TRUE;
 			{
 				DBG_PRINTF((LOG_WARNING,"I:" MODULE_TAG "IP address for alias '%s' needs update to '%s'\n",
-					p_self->alias_info.names[i].name,
-					p_self->info.my_ip_address.name ));
+						p_self->info[i].alias_info[j].names.name,
+						p_self->info[i].my_ip_address.name));
+				}
 			}
         }
     }
@@ -360,7 +373,7 @@ static RC_TYPE do_check_alias_update_tab
 /* DynDNS org.specific response validator.
     'good' or 'nochange' are the good answers,
 */
-static BOOL is_dyndns_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, char* p_ok_string)
+static BOOL is_dyndns_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, int infnr, char* p_ok_string)
 {
 	(void) p_ok_string;
     return ( (strstr(p_rsp, DYNDNS_OK_RESPONSE) != NULL) ||
@@ -372,17 +385,17 @@ static BOOL is_dyndns_server_rsp_ok( DYN
     fail blabla and n.n.n.n
     are the good answers. We search our own IP address in response and that's enough.
 */
-static BOOL is_freedns_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, char* p_ok_string)
+static BOOL is_freedns_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, int infnr, char* p_ok_string)
 {
 	(void) p_ok_string;
-    return (strstr(p_rsp, p_self->info.my_ip_address.name) != NULL);
+    return (strstr(p_rsp, p_self->info[infnr].my_ip_address.name) != NULL);
 }
 
 /** generic http dns server ok parser 
 	parses a given string. If found is ok,
 	Example : 'SUCCESS CODE='
 */
-static BOOL is_generic_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, char* p_ok_string)
+static BOOL is_generic_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, int infnr, char* p_ok_string)
 {
 	if (p_ok_string == NULL)
 	{
@@ -396,7 +409,7 @@ static BOOL is_generic_server_rsp_ok( DY
 		CODE=200
 		CODE=707, for duplicated updates
 */
-BOOL is_zoneedit_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, char* p_ok_string)
+BOOL is_zoneedit_server_rsp_ok( DYN_DNS_CLIENT *p_self, char*p_rsp, int infnr, char* p_ok_string)
 {
 	return 
 	(		
@@ -407,19 +420,21 @@ BOOL is_zoneedit_server_rsp_ok( DYN_DNS_
 
 static RC_TYPE do_update_alias_table(DYN_DNS_CLIENT *p_self)
 {
-	int i;
+	int i, j;
 	RC_TYPE rc = RC_OK;
 	
 	do 
 	{			
-		for (i = 0; i < p_self->alias_info.count; ++i)
+		for (i = 0; i < p_self->info_count; i++)
 		{
-			if (p_self->alias_info.update_required[i] != TRUE)
+			for (j = 0; j < p_self->info[i].alias_count; j++)
+		{
+				if (p_self->info[i].alias_info[j].update_required != TRUE)
 			{
 				continue;
 			}	
 			
-			rc = http_client_init(&p_self->http_to_dyndns);
+				rc = http_client_init(&p_self->http_to_dyndns[i]);
 			if (rc != RC_OK)
 			{
 				break;
@@ -428,9 +443,9 @@ static RC_TYPE do_update_alias_table(DYN
 			/*build dyndns transaction*/
 			{
 				HTTP_TRANSACTION http_tr;
-				http_tr.req_len = p_self->info.p_dns_system->p_dns_update_req_func(
-                        (struct _DYN_DNS_CLIENT*) p_self,i,
-						(struct DYNDNS_SYSTEM*) p_self->info.p_dns_system);
+					http_tr.req_len = p_self->info[i].p_dns_system->p_dns_update_req_func(
+						(struct _DYN_DNS_CLIENT*) p_self, i, j,
+						(struct DYNDNS_SYSTEM*) p_self->info[i].p_dns_system);
 				http_tr.p_req = (char*) p_self->p_req_buffer;
 				http_tr.p_rsp = (char*) p_self->p_work_buffer;
 				http_tr.max_rsp_len = p_self->work_buffer_size - 1;/*save place for a \0 at the end*/
@@ -438,7 +453,7 @@ static RC_TYPE do_update_alias_table(DYN
 				p_self->p_work_buffer[http_tr.rsp_len+1] = 0;
 				
 				/*send it*/
-				rc = http_client_transaction(&p_self->http_to_dyndns, &http_tr);					
+					rc = http_client_transaction(&p_self->http_to_dyndns[i], &http_tr);					
 
 				if (p_self->dbg.level > 2)
 				{
@@ -449,18 +464,18 @@ static RC_TYPE do_update_alias_table(DYN
 				if (rc == RC_OK)
 				{
 					BOOL update_ok = 
-                        p_self->info.p_dns_system->p_rsp_ok_func((struct _DYN_DNS_CLIENT*)p_self, 
+							p_self->info[i].p_dns_system->p_rsp_ok_func((struct _DYN_DNS_CLIENT*)p_self, 
                             http_tr.p_rsp, 
-							p_self->info.p_dns_system->p_success_string);
+							i,
+							p_self->info[i].p_dns_system->p_success_string);
 					if (update_ok)
 					{
-			                        p_self->alias_info.update_required[i] = FALSE;
+							p_self->info[i].alias_info[j].update_required = FALSE;
 
 						DBG_PRINTF((LOG_WARNING,"I:" MODULE_TAG "Alias '%s' to IP '%s' updated successful.\n", 
-							p_self->alias_info.names[i].name,
-							p_self->info.my_ip_address.name));                        
+								p_self->info[i].alias_info[j].names.name,
+								p_self->info[i].my_ip_address.name));                        
 						p_self->times_since_last_update = 0;
-							
 					}
 					else
 					{
@@ -476,7 +491,7 @@ static RC_TYPE do_update_alias_table(DYN
 			}
 			
 			{
-				RC_TYPE rc2 = http_client_shutdown(&p_self->http_to_dyndns);
+					RC_TYPE rc2 = http_client_shutdown(&p_self->http_to_dyndns[i]);
 				if (rc == RC_OK)
 				{
 					rc = rc2;
@@ -488,6 +503,7 @@ static RC_TYPE do_update_alias_table(DYN
 			}
 			os_sleep_ms(1000);
 		}
+		}
 		if (rc != RC_OK)
 		{
 			break;
@@ -504,8 +520,8 @@ RC_TYPE get_default_config_data(DYN_DNS_
 
 	do
 	{
-        p_self->info.p_dns_system = get_dns_system_by_id(DYNDNS_MY_DNS_SYSTEM);	
-        if (p_self->info.p_dns_system == NULL)
+		p_self->info[0].p_dns_system = get_dns_system_by_id(DYNDNS_MY_DNS_SYSTEM);	
+		if (p_self->info[0].p_dns_system == NULL)
         {
             rc = RC_DYNDNS_INVALID_DNS_SYSTEM_DEFAULT;
             break;
@@ -527,13 +543,15 @@ static RC_TYPE get_encoded_user_passwd(D
 	RC_TYPE rc = RC_OK;
 	const char* format = "%s:%s";
 	char *p_tmp_buff = NULL;
-	int size = strlen(p_self->info.credentials.my_password) + 
-			   strlen(p_self->info.credentials.my_username) + 
-			   strlen(format) + 1;
-	int actual_len;
+	int size, actual_len;
+	int i = 0;
 
 	do
 	{
+		size = strlen(p_self->info[i].credentials.my_password) + 
+			strlen(p_self->info[i].credentials.my_username) + 
+			strlen(format) + 1;
+
 		p_tmp_buff = (char *) malloc(size);
 		if (p_tmp_buff == NULL)
 		{
@@ -542,8 +560,8 @@ static RC_TYPE get_encoded_user_passwd(D
 		}
 
 		actual_len = sprintf(p_tmp_buff, format, 
-				p_self->info.credentials.my_username, 
-				p_self->info.credentials.my_password);
+				p_self->info[i].credentials.my_username, 
+				p_self->info[i].credentials.my_password);
 		if (actual_len >= size)
 		{
 			rc = RC_OUT_BUFFER_OVERFLOW;
@@ -551,16 +569,23 @@ static RC_TYPE get_encoded_user_passwd(D
 		}
 
 		/*encode*/
-		p_self->info.credentials.p_enc_usr_passwd_buffer = b64encode(p_tmp_buff);	
-		p_self->info.credentials.encoded = 
-			(p_self->info.credentials.p_enc_usr_passwd_buffer != NULL);
-		p_self->info.credentials.size = strlen(p_self->info.credentials.p_enc_usr_passwd_buffer);
+		p_self->info[i].credentials.p_enc_usr_passwd_buffer = b64encode(p_tmp_buff);	
+		p_self->info[i].credentials.encoded = 
+			(p_self->info[i].credentials.p_enc_usr_passwd_buffer != NULL);
+		p_self->info[i].credentials.size = strlen(p_self->info[i].credentials.p_enc_usr_passwd_buffer);
+
+		if (p_tmp_buff != NULL)
+		{
+			free(p_tmp_buff);
+			p_tmp_buff = NULL;
 	}
-	while(0);
+	}
+	while(++i < p_self->info_count);
 
 	if (p_tmp_buff != NULL)
 	{
 		free(p_tmp_buff);
+		p_tmp_buff = NULL;
 	}
 	return rc;	
 }
@@ -585,6 +610,7 @@ RC_TYPE dyn_dns_construct(DYN_DNS_CLIENT
 	DYN_DNS_CLIENT *p_self;
     BOOL http_to_dyndns_constructed = FALSE;
     BOOL http_to_ip_constructed = FALSE;
+	int i;
 
 	if (pp_self == NULL)
 	{
@@ -620,21 +646,28 @@ RC_TYPE dyn_dns_construct(DYN_DNS_CLIENT
 			break;
 		}
 		
-        
-		rc = http_client_construct(&p_self->http_to_ip_server);
+		i = 0;		
+		while(i < DYNDNS_MAX_SERVER_NUMBER)
+		{
+			rc = http_client_construct(&p_self->http_to_ip_server[i++]);
 		if (rc != RC_OK)
 		{	
 			rc = RC_OUT_OF_MEMORY;
 			break;
 		}
+		}
         http_to_ip_constructed = TRUE;
 	
-		rc = http_client_construct(&p_self->http_to_dyndns);
+		i = 0;
+		while(i < DYNDNS_MAX_SERVER_NUMBER)
+		{
+			rc = http_client_construct(&p_self->http_to_dyndns[i++]);
 		if (rc != RC_OK)
 		{		
 			rc = RC_OUT_OF_MEMORY;
 			break;
 		}
+		}
         http_to_dyndns_constructed = TRUE;
 	
 		(p_self)->cmd = NO_CMD;
@@ -642,8 +675,11 @@ RC_TYPE dyn_dns_construct(DYN_DNS_CLIENT
 		(p_self)->total_iterations = DYNDNS_DEFAULT_ITERATIONS;	
 		(p_self)->initialized = FALSE;
 	
-		p_self->info.credentials.p_enc_usr_passwd_buffer = NULL;
-
+		i = 0;		
+		while(i < DYNDNS_MAX_SERVER_NUMBER)
+		{
+			p_self->info[i++].credentials.p_enc_usr_passwd_buffer = NULL;
+		}
 	}
 	while(0);
 
@@ -663,11 +699,11 @@ RC_TYPE dyn_dns_construct(DYN_DNS_CLIENT
         }
         if (http_to_dyndns_constructed) 
         {
-            http_client_destruct(&p_self->http_to_dyndns);
+			http_client_destruct(p_self->http_to_dyndns, DYNDNS_MAX_SERVER_NUMBER);
         }
         if (http_to_ip_constructed) 
         {
-            http_client_destruct(&p_self->http_to_ip_server);
+			http_client_destruct(p_self->http_to_ip_server, DYNDNS_MAX_SERVER_NUMBER);
         }            
     }
 
@@ -680,6 +716,7 @@ RC_TYPE dyn_dns_construct(DYN_DNS_CLIENT
 */	
 RC_TYPE dyn_dns_destruct(DYN_DNS_CLIENT *p_self)
 {
+	int i;
 	RC_TYPE rc;
 	if (p_self == NULL)
 	{
@@ -691,13 +728,13 @@ RC_TYPE dyn_dns_destruct(DYN_DNS_CLIENT 
 		dyn_dns_shutdown(p_self);
 	}
 
-	rc = http_client_destruct(&p_self->http_to_ip_server);
+	rc = http_client_destruct(p_self->http_to_ip_server, DYNDNS_MAX_SERVER_NUMBER);
 	if (rc != RC_OK)
 	{		
 		
 	}
 
-	rc = http_client_destruct(&p_self->http_to_dyndns);
+	rc = http_client_destruct(p_self->http_to_dyndns, DYNDNS_MAX_SERVER_NUMBER);
 	if (rc != RC_OK)
 	{	
 		
@@ -715,13 +752,17 @@ RC_TYPE dyn_dns_destruct(DYN_DNS_CLIENT 
 		p_self->p_req_buffer = NULL;
 	}
 
-	if (p_self->info.credentials.p_enc_usr_passwd_buffer != NULL)
+	i = 0;		
+	while(i < DYNDNS_MAX_SERVER_NUMBER)
+	{
+		if (p_self->info[i].credentials.p_enc_usr_passwd_buffer != NULL)
 	{
-		free(p_self->info.credentials.p_enc_usr_passwd_buffer);
-		p_self->info.credentials.p_enc_usr_passwd_buffer = NULL;
+			free(p_self->info[i].credentials.p_enc_usr_passwd_buffer);
+			p_self->info[i].credentials.p_enc_usr_passwd_buffer = NULL;
+		}
+		i++;
 	}
 
-
 	free(p_self);
 	p_self = NULL;
 
@@ -736,6 +777,8 @@ RC_TYPE dyn_dns_destruct(DYN_DNS_CLIENT 
 */
 RC_TYPE dyn_dns_init(DYN_DNS_CLIENT *p_self)
 {
+	int i = 0;
+
 	if (p_self == NULL)
 	{
 		return RC_INVALID_POINTER;
@@ -749,22 +792,26 @@ RC_TYPE dyn_dns_init(DYN_DNS_CLIENT *p_s
 	p_self->abort_on_network_errors = FALSE;
 	p_self->force_addr_update = FALSE;
 
-    if (strlen(p_self->info.proxy_server_name.name) > 0)
+	do
     {
-        http_client_set_port(&p_self->http_to_ip_server, p_self->info.proxy_server_name.port);
-        http_client_set_remote_name(&p_self->http_to_ip_server, p_self->info.proxy_server_name.name);
+		if (strlen(p_self->info[i].proxy_server_name.name) > 0)
+		{
+			http_client_set_port(&p_self->http_to_ip_server[i], p_self->info[i].proxy_server_name.port);
+			http_client_set_remote_name(&p_self->http_to_ip_server[i], p_self->info[i].proxy_server_name.name);
 
-        http_client_set_port(&p_self->http_to_dyndns, p_self->info.proxy_server_name.port);
-        http_client_set_remote_name(&p_self->http_to_dyndns, p_self->info.proxy_server_name.name);
+			http_client_set_port(&p_self->http_to_dyndns[i], p_self->info[i].proxy_server_name.port);
+			http_client_set_remote_name(&p_self->http_to_dyndns[i], p_self->info[i].proxy_server_name.name);
     }
     else
     {
-        http_client_set_port(&p_self->http_to_ip_server, p_self->info.ip_server_name.port);
-        http_client_set_remote_name(&p_self->http_to_ip_server, p_self->info.ip_server_name.name);
+			http_client_set_port(&p_self->http_to_ip_server[i], p_self->info[i].ip_server_name.port);
+			http_client_set_remote_name(&p_self->http_to_ip_server[i], p_self->info[i].ip_server_name.name);
 
-        http_client_set_port(&p_self->http_to_dyndns, p_self->info.dyndns_server_name.port);
-        http_client_set_remote_name(&p_self->http_to_dyndns, p_self->info.dyndns_server_name.name);    
+			http_client_set_port(&p_self->http_to_dyndns[i], p_self->info[i].dyndns_server_name.port);
+			http_client_set_remote_name(&p_self->http_to_dyndns[i], p_self->info[i].dyndns_server_name.name);    
+		}
     }
+	while(++i < p_self->info_count);
 
 	p_self->cmd = NO_CMD;
     if (p_self->cmd_check_period == 0)
@@ -807,6 +854,8 @@ RC_TYPE dyn_dns_shutdown(DYN_DNS_CLIENT 
 */
 RC_TYPE dyn_dns_update_ip(DYN_DNS_CLIENT *p_self)
 {
+	int servernum = 0; /* server to use for requesting IP */
+                     /*use server 0 by default, should be always exist */
 	RC_TYPE rc;
 
 	if (p_self == NULL)
@@ -817,7 +866,7 @@ RC_TYPE dyn_dns_update_ip(DYN_DNS_CLIENT
 	do
 	{
 		/*ask IP server something so he will respond and give me my IP */
-		rc = do_ip_server_transaction(p_self);
+		rc = do_ip_server_transaction(p_self, servernum);
 		if (rc != RC_OK)
 		{
 			DBG_PRINTF((LOG_WARNING,"W: DYNDNS: Error '%s' (0x%x) when talking to IP server\n",
@@ -830,7 +879,7 @@ RC_TYPE dyn_dns_update_ip(DYN_DNS_CLIENT
 		}
 
 		/*extract my IP, check if different than previous one*/
-		rc = do_parse_my_ip_address(p_self);
+		rc = do_parse_my_ip_address(p_self, servernum);
 		if (rc != RC_OK)
 		{	
 			break;
@@ -838,7 +887,7 @@ RC_TYPE dyn_dns_update_ip(DYN_DNS_CLIENT
 		
 		if (p_self->dbg.level > 1)
 		{
-			DBG_PRINTF((LOG_WARNING,"W: DYNDNS: My IP address: %s\n", p_self->info.my_ip_address.name));		
+			DBG_PRINTF((LOG_WARNING,"W: DYNDNS: My IP address: %s\n", p_self->info[servernum].my_ip_address.name));		
 		}
 
 		/*step through aliases list, resolve them and check if they point to my IP*/
@@ -909,19 +958,6 @@ int dyn_dns_main(DYN_DNS_CLIENT *p_dyndn
         }
 	}
 
-	if (p_dyndns->change_persona)
-	{
-		OS_USER_INFO os_usr_info;
-		memset(&os_usr_info, 0, sizeof(os_usr_info));
-		os_usr_info.gid = p_dyndns->sys_usr_info.gid;
-		os_usr_info.uid = p_dyndns->sys_usr_info.uid;
-		rc = os_change_persona(&os_usr_info);
-		if (rc != RC_OK)
-		{
-			return rc;
-		}
-	}
-
     /*if silent required, close console window*/
     if (p_dyndns->run_in_background == TRUE)
     {
@@ -936,6 +972,39 @@ int dyn_dns_main(DYN_DNS_CLIENT *p_dyndn
         }
     }
 
+	/*if pid-file wanted, create it*/
+	if (p_dyndns->p_pidfilename && strlen(p_dyndns->p_pidfilename) != 0)
+	{
+		FILE *fp;
+		int obj;
+		char pid[7];
+		if ((fp = fopen(p_dyndns->p_pidfilename, "w")))
+		{
+			sprintf(pid, "%d\n", getpid());
+			obj = fwrite(pid, strlen(pid), 1, fp);
+			fclose(fp);
+		}
+		free(p_dyndns->p_pidfilename);
+		p_dyndns->p_pidfilename = NULL;
+		if (!fp || obj != 1)
+		{
+			return RC_FILE_IO_OPEN_ERROR;
+		}
+	}
+
+	if (p_dyndns->change_persona)
+	{
+		OS_USER_INFO os_usr_info;
+		memset(&os_usr_info, 0, sizeof(os_usr_info));
+		os_usr_info.gid = p_dyndns->sys_usr_info.gid;
+		os_usr_info.uid = p_dyndns->sys_usr_info.uid;
+		rc = os_change_persona(&os_usr_info);
+		if (rc != RC_OK)
+		{
+			return rc;
+		}
+	}
+
     dyn_dns_print_hello(NULL);
 
 	/* the real work here */
Index: src/dyndns.h
===================================================================
--- src/dyndns.h.orig
+++ src/dyndns.h
@@ -25,7 +25,7 @@ Foundation, Inc., 59 Temple Place - Suit
 #include "http_client.h"
 #include "debug_if.h"
 
-#define DYNDNS_VERSION_STRING  "1.96.2"
+#define DYNDNS_VERSION_STRING  "1.96.2 with multi services- & pid-patch"
 #define DYNDNS_AGENT_NAME  "inadyn/" DYNDNS_VERSION_STRING
 #define DYNDNS_EMAIL_ADDR	"inarcis2002@hotpop.com"
 
@@ -133,7 +133,8 @@ typedef enum
 #define DYNDNS_DEFAULT_ITERATIONS	0 /*forever*/
 #define DYNDNS_HTTP_RESPONSE_BUFFER_SIZE	(2500) /*Bytes*/
 #define DYNDNS_HTTP_REQUEST_BUFFER_SIZE		(2500) /*Bytes*/
-#define DYNDNS_MAX_ALIAS_NUMBER		10 /*maximum number of aliases that can be maintained*/
+#define DYNDNS_MAX_ALIAS_NUMBER		10 /*maximum number of aliases per server that can be maintained*/
+#define DYNDNS_MAX_SERVER_NUMBER	5 /*maximum number of servers that can be maintained*/
 
 /*local configs*/
 #define DYNDNS_MY_IP_ADDRESS_LENGTH	20 /*chars*/
@@ -154,8 +155,8 @@ struct DYNDNS_SYSTEM;
 /** Function to prepare DNS system specific server requests 
 */
 
-typedef int (*DNS_SYSTEM_REQUEST_FUNC)(struct _DYN_DNS_CLIENT *this, int nr, struct DYNDNS_SYSTEM *p_sys_info);
-typedef int (*DNS_SYSTEM_SRV_RESPONSE_OK_FUNC)(struct _DYN_DNS_CLIENT *this, char *p_rsp, const char*p_ok_str);
+typedef int (*DNS_SYSTEM_SRV_RESPONSE_OK_FUNC)(struct _DYN_DNS_CLIENT *this, char *p_rsp, int infnr, const char*p_ok_str);
+typedef int (*DNS_SYSTEM_REQUEST_FUNC)(struct _DYN_DNS_CLIENT *this, int infnr, int alnr, struct DYNDNS_SYSTEM *p_sys_info);
 typedef struct 
 {
     const char* p_key;
@@ -209,6 +210,13 @@ typedef struct 
 
 typedef struct 
 {
+	DYNDNS_SERVER_NAME names;
+	int update_required;
+	DYNDNS_HASH_TYPE hashes; 
+} DYNDNS_ALIAS_INFO;
+
+typedef struct 
+{
     BOOL my_ip_has_changed;
 	DYNDNS_SERVER_NAME my_ip_address;
 	DYNDNS_CREDENTIALS credentials;
@@ -218,18 +226,12 @@ typedef struct 
 	DYNDNS_SERVER_NAME ip_server_name;
 	char ip_server_url[DYNDNS_SERVER_URL_LENGTH];
 	DYNDNS_SERVER_NAME proxy_server_name;
+	DYNDNS_ALIAS_INFO alias_info[DYNDNS_MAX_ALIAS_NUMBER];
+	int alias_count;
 } DYNDNS_INFO_TYPE;
 
 typedef struct 
 {
-	DYNDNS_SERVER_NAME names[DYNDNS_MAX_ALIAS_NUMBER];
-	int update_required[DYNDNS_MAX_ALIAS_NUMBER];
-	DYNDNS_HASH_TYPE hashes[DYNDNS_MAX_ALIAS_NUMBER]; 
-	int count;
-} DYNDNS_ALIAS_INFO;
-
-typedef struct
-{
 	int uid;
 	int gid;
 } USER_INFO;
@@ -248,8 +250,8 @@ typedef struct DYN_DNS_CLIENT
 	BOOL debug_to_syslog;
 	BOOL change_persona;
 
-	HTTP_CLIENT http_to_ip_server;
-	HTTP_CLIENT http_to_dyndns;
+	HTTP_CLIENT http_to_ip_server[DYNDNS_MAX_SERVER_NUMBER];
+	HTTP_CLIENT http_to_dyndns[DYNDNS_MAX_SERVER_NUMBER];
 	HTTP_TRANSACTION http_tr;
 	char *p_work_buffer; /* for HTTP responses*/
 	int work_buffer_size;
@@ -258,14 +260,15 @@ typedef struct DYN_DNS_CLIENT
 
 
 	USER_INFO sys_usr_info; /*info about the current account running inadyn*/
-	DYNDNS_INFO_TYPE info; /*servers, names, passwd*/
-	DYNDNS_ALIAS_INFO alias_info;
+	DYNDNS_INFO_TYPE info[DYNDNS_MAX_SERVER_NUMBER]; /*servers, names, passwd*/
+	int info_count;
 
 	BOOL abort_on_network_errors;
 	BOOL force_addr_update;
     BOOL use_proxy;
 	BOOL abort;
 
+	char *p_pidfilename;
 	/*dbg*/
 	DBG_TYPE dbg;
 } DYN_DNS_CLIENT;
Index: src/http_client.c
===================================================================
--- src/http_client.c.orig
+++ src/http_client.c
@@ -56,10 +56,16 @@ RC_TYPE http_client_construct(HTTP_CLIEN
 /*
 	Resource free.
 */	
-RC_TYPE http_client_destruct(HTTP_CLIENT *p_self)
+RC_TYPE http_client_destruct(HTTP_CLIENT *p_self, int num)
 {
+	int i = 0, rv;
+
 	/*free*/
-	return super_destruct(&p_self->super);
+	while(i < num)
+	{
+		rv = super_destruct(&p_self[i++].super);
+	}
+	return rv;
 }
 
 
Index: src/http_client.h
===================================================================
--- src/http_client.h.orig
+++ src/http_client.h
@@ -61,7 +61,7 @@ RC_TYPE http_client_construct(HTTP_CLIEN
 /*
 	Resource free.
 */	
-RC_TYPE http_client_destruct(HTTP_CLIENT *p_self);
+RC_TYPE http_client_destruct(HTTP_CLIENT *p_self, int num);
 
 /* 
 	Sets up the object.
Index: src/inadyn_cmd.c
===================================================================
--- src/inadyn_cmd.c.orig
+++ src/inadyn_cmd.c
@@ -39,6 +39,8 @@ Foundation, Inc., 59 Temple Place - Suit
 #include "base64.h"
 #include "get_cmd.h"
 
+static int curr_info;
+
 /* command line options */
 #define DYNDNS_INPUT_FILE_OPT_STRING "--input_file"
 
@@ -54,6 +56,7 @@ static RC_TYPE get_update_period_handler
 static RC_TYPE get_update_period_sec_handler(CMD_DATA *p_cmd, int current_nr, void *p_context);
 static RC_TYPE get_forced_update_period_handler(CMD_DATA *p_cmd, int current_nr, void *p_context);
 static RC_TYPE get_logfile_name(CMD_DATA *p_cmd, int current_nr, void *p_context);
+static RC_TYPE get_pidfile_name(CMD_DATA *p_cmd, int current_nr, void *p_context);
 static RC_TYPE set_silent_handler(CMD_DATA *p_cmd, int current_nr, void *p_context);
 static RC_TYPE set_verbose_handler(CMD_DATA *p_cmd, int current_nr, void *p_context);
 static RC_TYPE get_proxy_server_handler(CMD_DATA *p_cmd, int current_nr, void *p_context);
@@ -113,6 +116,7 @@ static CMD_DESCRIPTION_TYPE cmd_options_
 	{"--forced_update_period", 1,   {get_forced_update_period_handler, NULL},"how often the IP is updated even if it is not changed. [in sec]"},
 
 	{"--log_file",	1,	{get_logfile_name, NULL},		"log file path abd name"},
+	{"--pid_file",	1,	{get_pidfile_name, NULL},		"pid file path abd name"},
 	{"--background", 0,	{set_silent_handler, NULL},		"run in background. output to log file or to syslog"},
 
 	{"--verbose",	1,	{set_verbose_handler, NULL},	"set dbg level. 0 to 5"},
@@ -211,7 +215,6 @@ static RC_TYPE set_silent_handler(CMD_DA
 	return RC_OK;
 }
 
-
 static RC_TYPE get_logfile_name(CMD_DATA *p_cmd, int current_nr, void *p_context)
 {
 	DYN_DNS_CLIENT *p_self = (DYN_DNS_CLIENT *) p_context;
@@ -228,6 +231,22 @@ static RC_TYPE get_logfile_name(CMD_DATA
 	return RC_OK;
 }
 
+static RC_TYPE get_pidfile_name(CMD_DATA *p_cmd, int current_nr, void *p_context)
+{
+	DYN_DNS_CLIENT *p_self = (DYN_DNS_CLIENT *) p_context;
+	if (p_self == NULL)
+	{
+		return RC_INVALID_POINTER;
+	}
+
+	p_self->p_pidfilename = (char *)malloc(strlen(p_cmd->argv[current_nr]) + 1);
+	if (p_self->p_pidfilename == NULL)
+	{
+		return  RC_OUT_OF_MEMORY;
+	}
+	strcpy(p_self->p_pidfilename, p_cmd->argv[current_nr]);
+	return RC_OK;
+}
 
 static RC_TYPE get_username_handler(CMD_DATA *p_cmd, int current_nr, void *p_context)
 {
@@ -238,11 +257,11 @@ static RC_TYPE get_username_handler(CMD_
 	}
 
 	/*user*/
-	if (sizeof(p_self->info.credentials.my_username) < strlen(p_cmd->argv[current_nr]))
+	if (sizeof(p_self->info[curr_info].credentials.my_username) < strlen(p_cmd->argv[current_nr]))
 	{
 		return  RC_DYNDNS_BUFFER_TOO_SMALL;
 	}
-	strcpy(p_self->info.credentials.my_username, p_cmd->argv[current_nr]);
+	strcpy(p_self->info[curr_info].credentials.my_username, p_cmd->argv[current_nr]);
 
 	return RC_OK;
 }
@@ -255,13 +274,13 @@ static RC_TYPE get_password_handler(CMD_
 		return RC_INVALID_POINTER;
 	}
 
-	/*user*/
-	if (sizeof(p_self->info.credentials.my_password) < strlen(p_cmd->argv[current_nr]))
+	/*password*/
+	if (sizeof(p_self->info[curr_info].credentials.my_password) < strlen(p_cmd->argv[current_nr]))
 	{
 		return  RC_DYNDNS_BUFFER_TOO_SMALL;
 	}
 
-	strcpy(p_self->info.credentials.my_password, (p_cmd->argv[current_nr]));
+	strcpy(p_self->info[curr_info].credentials.my_password, (p_cmd->argv[current_nr]));
 	return RC_OK;
 }
 
@@ -282,7 +301,7 @@ static RC_TYPE get_alias_handler(CMD_DAT
 		return RC_INVALID_POINTER;
 	}
 
-	if (p_self->alias_info.count >= DYNDNS_MAX_ALIAS_NUMBER)
+	if (p_self->info[curr_info].alias_count >= DYNDNS_MAX_ALIAS_NUMBER)
 	{
 		return RC_DYNDNS_TOO_MANY_ALIASES;
 	}
@@ -291,23 +310,23 @@ static RC_TYPE get_alias_handler(CMD_DAT
         p_hash = strstr(p_cmd->argv[current_nr],",");
         if (p_hash)
 	{
-	    if (sizeof(*p_self->alias_info.hashes) < strlen(p_hash))
+	    if (sizeof(p_self->info[curr_info].alias_info[p_self->info[curr_info].alias_count].hashes) < strlen(p_hash))
 	    {
 		return RC_DYNDNS_BUFFER_TOO_SMALL;
 	    }
-	    strcpy(p_self->alias_info.hashes[p_self->alias_info.count].str, p_hash);
+	    strcpy(p_self->info[curr_info].alias_info[p_self->info[curr_info].alias_count].hashes.str, p_hash);
 	    *p_hash = '\0';
 	}
 
 
 	/*user*/
-	if (sizeof(p_self->alias_info.names[p_self->alias_info.count]) < strlen(p_cmd->argv[current_nr]))
+	if (sizeof(p_self->info[curr_info].alias_info[p_self->info[curr_info].alias_count].names) < strlen(p_cmd->argv[current_nr]))
 	{
 		return  RC_DYNDNS_BUFFER_TOO_SMALL;
 	}
-	strcpy(p_self->alias_info.names[p_self->alias_info.count].name, (p_cmd->argv[current_nr]));
+	strcpy(p_self->info[curr_info].alias_info[p_self->info[curr_info].alias_count].names.name, (p_cmd->argv[current_nr]));
 
-	p_self->alias_info.count ++;
+	p_self->info[curr_info].alias_count++;
 	return RC_OK;
 }
 
@@ -349,24 +368,24 @@ static RC_TYPE get_ip_server_name_handle
 		return RC_INVALID_POINTER;
 	}
 
-	/*user*/
-	if (sizeof(p_self->info.ip_server_name) < strlen(p_cmd->argv[current_nr]) + 1)
+	/*ip_server_name*/
+	if (sizeof(p_self->info[curr_info].ip_server_name) < strlen(p_cmd->argv[current_nr]) + 1)
 	{
 		return  RC_DYNDNS_BUFFER_TOO_SMALL;
 	}
 
-    p_self->info.ip_server_name.port = HTTP_DEFAULT_PORT;
-    rc = get_name_and_port(p_cmd->argv[current_nr], p_self->info.ip_server_name.name, &port);
+    p_self->info[curr_info].ip_server_name.port = HTTP_DEFAULT_PORT;
+    rc = get_name_and_port(p_cmd->argv[current_nr], p_self->info[curr_info].ip_server_name.name, &port);
     if (rc == RC_OK && port != -1)
     {
-        p_self->info.ip_server_name.port = port;
+        p_self->info[curr_info].ip_server_name.port = port;
     }        
 
-	if (sizeof(p_self->info.ip_server_url) < strlen(p_cmd->argv[current_nr + 1]) + 1)
+	if (sizeof(p_self->info[curr_info].ip_server_url) < strlen(p_cmd->argv[current_nr + 1]) + 1)
 	{
 		return  RC_DYNDNS_BUFFER_TOO_SMALL;
 	}
-	strcpy(p_self->info.ip_server_url, p_cmd->argv[current_nr + 1]);
+	strcpy(p_self->info[curr_info].ip_server_url, p_cmd->argv[current_nr + 1]);
 
 	return rc;
 }
@@ -382,17 +401,17 @@ static RC_TYPE get_dns_server_name_handl
 		return RC_INVALID_POINTER;
 	}
 
-	/*user*/
-	if (sizeof(p_self->info.dyndns_server_name) < strlen(p_cmd->argv[current_nr]))
+	/*dyndns_server_name*/
+	if (sizeof(p_self->info[curr_info].dyndns_server_name) < strlen(p_cmd->argv[current_nr]))
 	{
 		return  RC_DYNDNS_BUFFER_TOO_SMALL;
 	}
     
-    p_self->info.dyndns_server_name.port = HTTP_DEFAULT_PORT;
-    rc = get_name_and_port(p_cmd->argv[current_nr], p_self->info.dyndns_server_name.name, &port);
+    p_self->info[curr_info].dyndns_server_name.port = HTTP_DEFAULT_PORT;
+    rc = get_name_and_port(p_cmd->argv[current_nr], p_self->info[curr_info].dyndns_server_name.name, &port);
     if (rc == RC_OK && port != -1)
     {
-        p_self->info.dyndns_server_name.port = port;
+        p_self->info[curr_info].dyndns_server_name.port = port;
     }                                   
 	return rc;
 }
@@ -405,12 +424,12 @@ RC_TYPE get_dns_server_url_handler(CMD_D
 		return RC_INVALID_POINTER;
 	}
 
-	/*name*/
-	if (sizeof(p_self->info.dyndns_server_url) < strlen(p_cmd->argv[current_nr]))
+	/*dyndns_server_url*/
+	if (sizeof(p_self->info[curr_info].dyndns_server_url) < strlen(p_cmd->argv[current_nr]))
 	{
 		return  RC_DYNDNS_BUFFER_TOO_SMALL;
 	}
-	strcpy(p_self->info.dyndns_server_url, p_cmd->argv[current_nr]);
+	strcpy(p_self->info[curr_info].dyndns_server_url, p_cmd->argv[current_nr]);
 	return RC_OK;
 }
 
@@ -427,17 +446,17 @@ static RC_TYPE get_proxy_server_handler(
 		return RC_INVALID_POINTER;
 	}
 
-	/*user*/
-	if (sizeof(p_self->info.proxy_server_name) < strlen(p_cmd->argv[current_nr]))
+	/*proxy_server_name*/
+	if (sizeof(p_self->info[curr_info].proxy_server_name) < strlen(p_cmd->argv[current_nr]))
 	{
 		return  RC_DYNDNS_BUFFER_TOO_SMALL;
 	}
     
-    p_self->info.proxy_server_name.port = HTTP_DEFAULT_PORT;
-    rc = get_name_and_port(p_cmd->argv[current_nr], p_self->info.proxy_server_name.name, &port);
+    p_self->info[curr_info].proxy_server_name.port = HTTP_DEFAULT_PORT;
+    rc = get_name_and_port(p_cmd->argv[current_nr], p_self->info[curr_info].proxy_server_name.name, &port);
     if (rc == RC_OK && port != -1)
     {
-        p_self->info.proxy_server_name.port = port;
+        p_self->info[curr_info].proxy_server_name.port = port;
     }                                   
 	return rc;    
 }
@@ -571,6 +590,7 @@ static RC_TYPE get_dyndns_system_handler
 {
     DYNDNS_SYSTEM *p_dns_system = NULL;
 	DYN_DNS_CLIENT *p_self = (DYN_DNS_CLIENT *) p_context;
+
 	if (p_self == NULL)
 	{
 		return RC_INVALID_POINTER;
@@ -592,7 +612,21 @@ static RC_TYPE get_dyndns_system_handler
         return RC_DYNDNS_INVALID_OPTION;
     }
 
-    p_self->info.p_dns_system = p_dns_system;
+	for (curr_info = 0; curr_info < p_self->info_count &&
+	     curr_info < DYNDNS_MAX_SERVER_NUMBER &&
+	     p_self->info[curr_info].p_dns_system != p_dns_system; curr_info++)
+	{
+	}
+	if (curr_info >= p_self->info_count)
+	{
+		if (curr_info < DYNDNS_MAX_SERVER_NUMBER)
+		{
+			p_self->info_count++;
+			p_self->info[curr_info].p_dns_system = p_dns_system;
+		}
+	   	else
+			return RC_DYNDNS_BUFFER_TOO_SMALL;
+	}
 	
 	return RC_OK;
 }
@@ -886,6 +920,7 @@ static RC_TYPE get_options_from_file_han
 */
 RC_TYPE get_config_data(DYN_DNS_CLIENT *p_self, int argc, char** argv)
 {
+	int i;
 	RC_TYPE rc = RC_OK;
 	
 	do
@@ -929,49 +964,53 @@ RC_TYPE get_config_data(DYN_DNS_CLIENT *
 		}	
 
         /*settings that may change due to cmd line options*/
+	i = 0;
+	do
         {
     		/*ip server*/
-            if (strlen(p_self->info.ip_server_name.name) == 0)
+            if (strlen(p_self->info[i].ip_server_name.name) == 0)
             {
-                if (sizeof(p_self->info.ip_server_name.name) < strlen(p_self->info.p_dns_system->p_ip_server_name))
+                if (sizeof(p_self->info[i].ip_server_name.name) < strlen(p_self->info[i].p_dns_system->p_ip_server_name))
                 {
                     rc = RC_DYNDNS_BUFFER_TOO_SMALL;
                     break;
                 }
-                strcpy(p_self->info.ip_server_name.name, p_self->info.p_dns_system->p_ip_server_name);
+                strcpy(p_self->info[i].ip_server_name.name, p_self->info[i].p_dns_system->p_ip_server_name);
 
-                if (sizeof(p_self->info.ip_server_url) < strlen(p_self->info.p_dns_system->p_ip_server_url))
+                if (sizeof(p_self->info[i].ip_server_url) < strlen(p_self->info[i].p_dns_system->p_ip_server_url))
                 {
                     rc = RC_DYNDNS_BUFFER_TOO_SMALL;
                     break;
                 }
-                strcpy(p_self->info.ip_server_url, p_self->info.p_dns_system->p_ip_server_url);				
+                strcpy(p_self->info[i].ip_server_url, p_self->info[i].p_dns_system->p_ip_server_url);				
             }
             
     		/*dyndns server*/
-            if (strlen(p_self->info.dyndns_server_name.name) == 0)
+            if (strlen(p_self->info[i].dyndns_server_name.name) == 0)
             {
-        		if (sizeof(p_self->info.dyndns_server_name.name) < strlen(p_self->info.p_dns_system->p_dyndns_server_name))
+		if (sizeof(p_self->info[i].dyndns_server_name.name) < strlen(p_self->info[i].p_dns_system->p_dyndns_server_name))
         		{
         			rc = RC_DYNDNS_BUFFER_TOO_SMALL;
         			break;
         		}
-        		strcpy(p_self->info.dyndns_server_name.name, p_self->info.p_dns_system->p_dyndns_server_name);
+		strcpy(p_self->info[i].dyndns_server_name.name, p_self->info[i].p_dns_system->p_dyndns_server_name);
 
-        		if (sizeof(p_self->info.dyndns_server_url) < strlen(p_self->info.p_dns_system->p_dyndns_server_url))
+		if (sizeof(p_self->info[i].dyndns_server_url) < strlen(p_self->info[i].p_dns_system->p_dyndns_server_url))
         		{
         			rc = RC_DYNDNS_BUFFER_TOO_SMALL;
         			break;
         		}
-        		strcpy(p_self->info.dyndns_server_url, p_self->info.p_dns_system->p_dyndns_server_url);
+		strcpy(p_self->info[i].dyndns_server_url, p_self->info[i].p_dns_system->p_dyndns_server_url);
             }
         }
+	while(++i < p_self->info_count);
 
 		/*check if the neccessary params have been provided*/
 		if ( 
-			(strlen(p_self->info.dyndns_server_name.name) == 0)  ||
-			(strlen(p_self->info.ip_server_name.name)	  == 0)  ||
-			(p_self->alias_info.count == 0)
+			(p_self->info_count == 0) ||
+			(p_self->info[0].alias_count == 0) ||
+			(strlen(p_self->info[0].dyndns_server_name.name) == 0)  ||
+			(strlen(p_self->info[0].ip_server_name.name)	 == 0)
 			)
 		{
 			rc = RC_DYNDNS_INVALID_OR_MISSING_PARAMETERS;