30 #include "secure_wrapper.h"
32 #define MAX_CMD_LEN 128
33 #define MAX_BUF_LEN 256
36 DHCPv4Client hostIf_DHCPv4Client::dhcpClient = {{
'\0'}, {
'\0'}, {
'\0'}};
37 GHashTable *hostIf_DHCPv4Client::dhcpv4ClientHash = NULL;
38 GMutex *hostIf_DHCPv4Client::m_mutex = NULL;
39 GHashTable* hostIf_DHCPv4Client::m_notifyHash = NULL;
53 char buffer[MAX_BUF_LEN]={
'\0'};
54 bBackUpFlags.interface=0;
55 bBackUpFlags.dnsservers=0;
56 bBackUpFlags.ipRouters=0;
57 memset(&backupDhcpClient,
'\0',
sizeof(backupDhcpClient));
58 RDK_LOG(RDK_LOG_DEBUG,LOG_TR69HOSTIF,
"Inside constructor for dev_id:%d\n", dev_id);
61 void hostIf_DHCPv4Client::getLock()
65 m_mutex = g_mutex_new();
67 g_mutex_lock(m_mutex);
70 void hostIf_DHCPv4Client::releaseLock()
72 g_mutex_unlock(m_mutex);
75 GHashTable* hostIf_DHCPv4Client::getNotifyHash()
83 return m_notifyHash = g_hash_table_new(g_str_hash, g_str_equal);
89 RDK_LOG(RDK_LOG_DEBUG,LOG_TR69HOSTIF,
"Entering [%s]\n", __FUNCTION__);
98 dhcpv4ClientHash = g_hash_table_new(NULL, NULL);
106 RDK_LOG(RDK_LOG_WARN,LOG_TR69HOSTIF,
"Caught exception, not able create DHCPv4 client instance..\n");
108 g_hash_table_insert(dhcpv4ClientHash, (gpointer)dev_id, pRet);
114 GList* hostIf_DHCPv4Client::getAllInstances()
117 return g_hash_table_get_keys(dhcpv4ClientHash);
126 g_hash_table_remove(dhcpv4ClientHash, (gconstpointer)pDev->dev_id);
131 hostIf_DHCPv4Client::~hostIf_DHCPv4Client()
135 g_hash_table_destroy(m_notifyHash);
139 void hostIf_DHCPv4Client::closeAllInstances()
143 GList* tmp_list = g_hash_table_get_values (dhcpv4ClientHash);
148 tmp_list = tmp_list->next;
169 int ret = get_Device_DHCPv4_Client_Fields(eDHCPv4Interface);
172 if(bBackUpFlags.interface && pChanged && (strncmp(backupDhcpClient.interface, dhcpClient.interface,
sizeof(backupDhcpClient.interface))))
176 bBackUpFlags.interface = 1;
177 strncpy(backupDhcpClient.interface, dhcpClient.interface, MAX_IF_LEN -1);
178 backupDhcpClient.interface[MAX_IF_LEN-1]=
'\0';
179 strncpy(stMsgData->
paramValue, dhcpClient.interface, TR69HOSTIFMGR_MAX_PARAM_LEN -1);
180 stMsgData->
paramValue[TR69HOSTIFMGR_MAX_PARAM_LEN -1]=
'\0';
181 stMsgData->
paramLen=strlen(dhcpClient.interface);
182 stMsgData->
paramtype = hostIf_StringType;
202 int ret= get_Device_DHCPv4_Client_Fields(eDHCPv4Dnsservers);
205 if(bBackUpFlags.dnsservers && pChanged && (strncmp(backupDhcpClient.dnsservers, dhcpClient.dnsservers,
sizeof(backupDhcpClient.dnsservers))))
209 bBackUpFlags.dnsservers = 1;
210 strncpy(backupDhcpClient.dnsservers, dhcpClient.dnsservers, MAX_DNS_SERVER_LEN -1);
211 backupDhcpClient.dnsservers[MAX_DNS_SERVER_LEN-1]=
'\0';
212 strncpy(stMsgData->
paramValue, dhcpClient.dnsservers, TR69HOSTIFMGR_MAX_PARAM_LEN -1);
213 stMsgData->
paramValue[TR69HOSTIFMGR_MAX_PARAM_LEN -1]=
'\0';
214 stMsgData->
paramLen=strlen(dhcpClient.dnsservers);
215 stMsgData->
paramtype = hostIf_StringType;
235 int ret = get_Device_DHCPv4_Client_Fields(eDHCPv4Iprouters);
239 if(bBackUpFlags.ipRouters && pChanged && (strncmp(backupDhcpClient.ipRouters, dhcpClient.ipRouters,
sizeof(backupDhcpClient.ipRouters))))
243 bBackUpFlags.ipRouters = 1;
244 strncpy(backupDhcpClient.ipRouters, dhcpClient.ipRouters, MAX_IP_ROUTER_LEN - 1);
245 backupDhcpClient.ipRouters[MAX_IP_ROUTER_LEN -1 ] =
'\0';
246 strncpy(stMsgData->
paramValue, dhcpClient.ipRouters, TR69HOSTIFMGR_MAX_PARAM_LEN -1);
247 stMsgData->
paramValue[TR69HOSTIFMGR_MAX_PARAM_LEN -1]=
'\0';
248 stMsgData->
paramLen=strlen(dhcpClient.ipRouters);
249 stMsgData->
paramtype = hostIf_StringType;
254 int hostIf_DHCPv4Client::get_Device_DHCPv4_ClientNumberOfEntries(
HOSTIF_MsgData_t *stMsgData)
257 char cmd[MAX_CMD_LEN]={
'\0'};
259 char buffer[MAX_BUF_LEN]={
'\0'};
261 RDK_LOG(RDK_LOG_DEBUG,LOG_TR69HOSTIF,
"Entering [%s]\n", __FUNCTION__);
262 snprintf(cmd,MAX_CMD_LEN -1,
"ip r | grep default|wc -l");
263 cmdOP=popen(cmd,
"r");
266 fgets(buffer,MAX_BUF_LEN,cmdOP);
267 num = strtol(buffer,NULL,10);
269 stMsgData->
paramtype = hostIf_UnsignedIntType;
270 stMsgData->
paramLen =
sizeof(
unsigned int);
277 bool hostIf_DHCPv4Client::isIfnameInroutetoDNSServer(
char* dnsServer,
char* ifName)
279 char cmd[MAX_CMD_LEN]={
'\0'};
280 char opIfName[8]={
'\0'};
283 snprintf(cmd,MAX_CMD_LEN -1,
"ip route get %s | grep %s | awk 'BEGIN {FR=\" \"} {printf $5}'", dnsServer, dnsServer);
285 cmdOP=v_secure_popen(
"r",
"ip route get %s | grep %s | awk 'BEGIN {FR=\" \"} {printf $5}'", dnsServer, dnsServer);
287 cmdOP=popen(cmd,
"r");
291 fgets(opIfName, 8, cmdOP);
293 v_secure_pclose(cmdOP);
298 if(strncmp(opIfName, ifName,
sizeof(opIfName))==0)
305 int hostIf_DHCPv4Client::get_Device_DHCPv4_Client_Fields(
DHCPv4ClientMembers dhclientMember)
310 char ifname[IFNAMSIZ]={
'\0'};
311 char buffer[MAX_BUF_LEN]={
'\0'};
312 char dupbuf[MAX_BUF_LEN]={
'\0'};
313 char cmd[MAX_CMD_LEN]={
'\0'};
316 int ipNumOfEntries=0;
318 GList *devList =NULL;
322 memset(&msgData, 0,
sizeof(msgData));
323 ret=getInterfaceName(ifname);
328 RDK_LOG(RDK_LOG_DEBUG,LOG_TR69HOSTIF,
"Entering [%s] asking for member %d\n", __FUNCTION__, dhclientMember);
329 switch(dhclientMember)
331 case eDHCPv4Interface:
335 for(index = 1; index<=ipNumOfEntries; index++)
339 if(strncmp(msgData.
paramValue, ifname, strlen(ifname))==0)
341 snprintf(dhcpClient.interface, MAX_IF_LEN - 1,
"Device.IP.Interface.%d", index);
348 case eDHCPv4Dnsservers:
349 memset(dhcpClient.dnsservers,
'\0',
sizeof dhcpClient.dnsservers);
351 snprintf(cmd, MAX_CMD_LEN - 1,
"cat /etc/resolv.conf | grep nameserver | cut -f2 -d' '|awk 'BEGIN { RS=\"\"; FS=\"\\n\"}{ for (i=1; i<=NF; i++) printf $i\",\" }'");
352 cmdOP=popen(cmd,
"r");
355 fgets(buffer, MAX_BUF_LEN, cmdOP);
356 strncpy(dupbuf, buffer, MAX_BUF_LEN - 1);
357 dupbuf[MAX_BUF_LEN-1]=
'\0';
358 memset(dhcpClient.dnsservers, 0,
sizeof(dhcpClient.dnsservers));
359 token=(
char *)strtok_r(dupbuf,
",", &savePtr);
362 if(token!=NULL && isValidIPAddr(token))
364 if((isIfnameInroutetoDNSServer(token, ifname)))
366 snprintf(dhcpClient.dnsservers,
sizeof(dhcpClient.dnsservers),
"%s,", token);
369 while(token=strtok_r(NULL,
",", &savePtr))
371 if((isIfnameInroutetoDNSServer(token, ifname)))
373 snprintf(dhcpClient.dnsservers+len,
sizeof(dhcpClient.dnsservers)-len,
"%s,", token);
374 len+=strlen(token)+1;
377 len=strlen(dhcpClient.dnsservers);
380 dhcpClient.dnsservers[len-1]=
'\0';
387 case eDHCPv4Iprouters:
388 memset(dhcpClient.ipRouters,
'\0',
sizeof(dhcpClient.ipRouters));
389 memset(cmd, 0,
sizeof cmd);
391 snprintf(cmd, MAX_CMD_LEN - 1 ,
"ip r|grep default| grep %s |awk '{printf $3}'",ifname);
393 cmdOP=v_secure_popen(
"r",
"ip r|grep default| grep %s |awk '{printf $3}'",ifname);
395 cmdOP=popen(cmd,
"r");
399 fgets(buffer, MAX_BUF_LEN, cmdOP);
402 snprintf(dhcpClient.ipRouters,
sizeof(dhcpClient.ipRouters),
"%s", buffer);
406 v_secure_pclose(cmdOP);
418 bool hostIf_DHCPv4Client::isValidIPAddr(
char* addr)
422 char temp[MAX_IP_LEN]={0};
423 char *tptr, *tptr1, *savePtr;
431 strncpy(temp, addr, MAX_IP_LEN -1);
432 temp[MAX_IP_LEN-1]=
'\0';
434 for (i=0; temp[i]!=
'\0'; ((temp[i]==
'.')?count++:(isdigit(temp[i])?1:alpha++)), i++);
448 tptr=strtok_r(temp,
".", &savePtr);
452 if(val>255 || val < 0)
459 tptr=strtok_r(NULL,
".", &savePtr);
463 if(val>255 || val < 0)
485 int hostIf_DHCPv4Client::getInterfaceName(
char* ifname){
486 char cmd[MAX_CMD_LEN]={
'\0'};
487 char opIfName[IFNAMSIZ+1]={
'\0'};
491 snprintf(cmd,MAX_CMD_LEN - 1,
"ip r | grep default | sed -n '%dp' | awk '{printf $5}'",this->dev_id);
492 cmdOP=popen(cmd,
"r");
495 fgets(opIfName,IFNAMSIZ,cmdOP);
496 if(opIfName[0]!=
'\0')
498 strncpy(ifname,opIfName,IFNAMSIZ);