RDK Documentation (Open Sourced RDK Components)
Device_WiFi_Radio.cpp
1 /*
2  * If not stated otherwise in this file or this component's Licenses.txt file the
3  * following copyright and licenses apply:
4  *
5  * Copyright 2018 RDK Management
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18 */
19 
20 /**
21  * @file Device_MoCA_Interface.cpp
22  *
23  * @brief MoCA_Interface API Implementation.
24  *
25  * This is the implementation of the MoCA_Interface API.
26  *
27  * @par Document
28  * TBD Relevant design or API documentation.
29  *
30  */
31 
32 /** @addtogroup MoCA_Interface Implementation
33  * This is the implementation of the Device Public API.
34  * @{
35  */
36 #ifdef USE_WIFI_PROFILE
37 /*****************************************************************************
38  * STANDARD INCLUDE FILES
39  *****************************************************************************/
40 #include "Device_WiFi_Radio.h"
41 
42 extern "C" {
43  /* #include "c_only_header.h"*/
44 #include "wifi_client_hal.h"
45 #include "wifiSrvMgrIarmIf.h"
46 };
47 
48 GHashTable* hostIf_WiFi_Radio::ifHash = NULL;
49 
50 /*hostIf_WiFi_Radio::hostIf_WiFi_Radio(int dev_id):dev_id(dev_id)
51 {
52 }*/
53 
54 hostIf_WiFi_Radio *hostIf_WiFi_Radio::getInstance(int dev_id)
55 {
56  static hostIf_WiFi_Radio* pRet = NULL;
57 
58  if(ifHash)
59  {
60  pRet = (hostIf_WiFi_Radio *)g_hash_table_lookup(ifHash, (gpointer) dev_id);
61  }
62  else
63  {
64  ifHash = g_hash_table_new(NULL,NULL);
65  }
66 
67  if(!pRet)
68  {
69  try {
70  pRet = new hostIf_WiFi_Radio(dev_id);
71  } catch(int e)
72  {
73  RDK_LOG(RDK_LOG_WARN,LOG_TR69HOSTIF,"Caught exception, not able create hostIf_WiFi_Radio instance..\n");
74  }
75  g_hash_table_insert(ifHash,(gpointer)dev_id, pRet);
76  }
77 
78  return pRet;
79 }
80 
81 /*void* hostIf_WiFi_Radio::getContext()
82 {
83  return ctxt;
84 }*/
85 
86 
87 
88 GList* hostIf_WiFi_Radio::getAllAssociateDevs()
89 {
90  if(ifHash)
91  return g_hash_table_get_keys(ifHash);
92  return NULL;
93 }
94 
95 void hostIf_WiFi_Radio::closeInstance(hostIf_WiFi_Radio *pDev)
96 {
97  if(pDev)
98  {
99  g_hash_table_remove(ifHash, (gconstpointer)pDev->dev_id);
100 // if(pDev->ctxt)
101  delete pDev;
102  }
103 }
104 
105 void hostIf_WiFi_Radio::closeAllInstances()
106 {
107  if(ifHash)
108  {
109  GList* tmp_list = g_hash_table_get_values (ifHash);
110 
111  while(tmp_list)
112  {
113  hostIf_WiFi_Radio* pDev = (hostIf_WiFi_Radio *)tmp_list->data;
114  tmp_list = tmp_list->next;
115  closeInstance(pDev);
116  }
117  }
118 }
119 
120 hostIf_WiFi_Radio::hostIf_WiFi_Radio(int dev_id):
121  dev_id(dev_id),
122  Enable(false),
123  radioFirstExTime(0),
124  LastChange(0),
125  Upstream (false),
126  MaxBitRate(0),
127  Channel(0),
128  AutoChannelSupported(false),
129  AutoChannelEnable(false),
130  AutoChannelRefreshPeriod (0),
131  mcs (0),
132  IEEE80211hSupported (false),
133  IEEE80211hEnabled (false),
134  TransmitPower (0)
135 {
136  memset(Status, 0, sizeof(Status));
137  memset(Alias,0,sizeof(Alias));
138  memset(Name,0,sizeof(Name));
139  memset(LowerLayers,0,sizeof(LowerLayers));
140  memset(SupportedFrequencyBands,0,sizeof(SupportedFrequencyBands));
141  memset(OperatingFrequencyBand,0,sizeof(OperatingFrequencyBand));
142  memset(SupportedStandards, 0, sizeof(SupportedStandards));
143  memset(OperatingStandards, 0, sizeof(OperatingStandards));
144  memset(PossibleChannels, 0, sizeof(PossibleChannels));
145  memset(ChannelsInUse, 0, sizeof(ChannelsInUse));
146  memset(OperatingChannelBandwidth, 0, sizeof(OperatingChannelBandwidth));
147  memset(ExtensionChannel, 0, sizeof(ExtensionChannel));
148  memset(GuardInterval, 0,sizeof(GuardInterval));
149  memset(TransmitPowerSupported, 0, sizeof(TransmitPowerSupported));
150  memset(RegulatoryDomain, 0, sizeof(RegulatoryDomain));
151 }
152 
153 
154 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_Props_Fields(int radioIndex)
155 {
156  IARM_Result_t retVal = IARM_RESULT_SUCCESS;
157  IARM_BUS_WiFi_DiagsPropParam_t param = {0};
158  int ret;
159 
160  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
161  hostIf_WiFi_Radio *pDev = hostIf_WiFi_Radio::getInstance(dev_id);
162  if(pDev)
163  {
164  retVal = IARM_Bus_Call(IARM_BUS_NM_SRV_MGR_NAME, IARM_BUS_WIFI_MGR_API_getRadioProps, (void *)&param, sizeof(param));
165  if (IARM_RESULT_SUCCESS != retVal)
166  {
167  RDK_LOG(RDK_LOG_ERROR,LOG_TR69HOSTIF,"[%s:%s] IARM BUS CALL failed with : %d.\n", __FILE__, __FUNCTION__, retVal);
168  return NOK;
169  }
170  Enable = param.data.radio.params.enable;
171  snprintf(Status,BUFF_LENGTH_64,param.data.radio.params.status);
172  snprintf(Alias,BUFF_LENGTH_64,param.data.radio.params.alias);
173  snprintf(Name,BUFF_LENGTH_64,param.data.radio.params.name);
174  LastChange = param.data.radio.params.lastChange;
175  snprintf(LowerLayers,BUFF_LENGTH_1024,param.data.radio.params.lowerLayers);
176  Upstream = param.data.radio.params.upstream;
177  MaxBitRate = param.data.radio.params.maxBitRate;
178  snprintf(SupportedFrequencyBands,BUFF_LENGTH_256,param.data.radio.params.supportedFrequencyBands);
179  snprintf(OperatingFrequencyBand,BUFF_LENGTH_64,param.data.radio.params.operatingFrequencyBand);
180  snprintf(SupportedStandards,BUFF_LENGTH_64,param.data.radio.params.supportedStandards);
181  snprintf(OperatingStandards,BUFF_LENGTH_64,param.data.radio.params.operatingStandards);
182  snprintf(PossibleChannels,BUFF_LENGTH_256,param.data.radio.params.possibleChannels);
183  snprintf(ChannelsInUse,BUFF_LENGTH_1024,param.data.radio.params.channelsInUse);
184  Channel = param.data.radio.params.channel;
185  AutoChannelSupported = param.data.radio.params.autoChannelSupported;
186  AutoChannelEnable = param.data.radio.params.autoChannelEnable;
187  AutoChannelRefreshPeriod = param.data.radio.params.autoChannelRefreshPeriod;
188  snprintf(OperatingChannelBandwidth,BUFF_LENGTH_1024,param.data.radio.params.operatingChannelBandwidth);
189  snprintf(ExtensionChannel,BUFF_LENGTH_64,param.data.radio.params.extensionChannel);
190  snprintf(GuardInterval,BUFF_LENGTH_64,param.data.radio.params.guardInterval);
191  mcs = param.data.radio.params.mcs;
192  snprintf(TransmitPowerSupported,BUFF_LENGTH_64,param.data.radio.params.transmitPowerSupported);
193  TransmitPower = param.data.radio.params.transmitPower;
194 // IEEE80211hSupported = param.data.radio.params.IEEE80211hSupported;
195 // IEEE80211hEnabled = param.data.radio.params.IEEE80211hEnabled;
196  snprintf(RegulatoryDomain,BUFF_MIN_16,param.data.radio.params.regulatoryDomain);
197  radioFirstExTime = time (NULL);
198  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
199  return OK;
200  }
201  else
202  {
203  RDK_LOG(RDK_LOG_ERROR,LOG_TR69HOSTIF,"[%s:%s]Error! Unable to connect to wifi instance\n", __FILE__, __FUNCTION__);
204  return NOK;
205  }
206 }
207 
208 void hostIf_WiFi_Radio::checkWifiRadioFetch(int radioIndex)
209 {
210  int retVal=NOK;
211  time_t currExTime = time (NULL);
212  if((currExTime - radioFirstExTime ) > QUERY_INTERVAL)
213  {
214  retVal = get_Device_WiFi_Radio_Props_Fields(radioIndex);
215  if( OK != retVal)
216  {
217  RDK_LOG(RDK_LOG_ERROR,LOG_TR69HOSTIF,"[%s:%s] Failed to fetch : %d.\n", __FILE__, __FUNCTION__, retVal);
218  }
219  }
220 }
221 
222 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_Enable(HOSTIF_MsgData_t *stMsgData,int radioIndex )
223 {
224 
225  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
226  checkWifiRadioFetch(radioIndex);
227  put_boolean(stMsgData->paramValue, Enable);
228  stMsgData->paramtype = hostIf_BooleanType;
229  stMsgData->paramLen=1;
230  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
231  return OK;
232 }
233 
234 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_Upstream(HOSTIF_MsgData_t *stMsgData,int radioIndex )
235 {
236 
237  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
238  checkWifiRadioFetch(radioIndex);
239  put_boolean(stMsgData->paramValue, Upstream);
240  stMsgData->paramtype = hostIf_BooleanType;
241  stMsgData->paramLen=1;
242  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
243  return OK;
244 }
245 
246 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_AutoChannelSupported(HOSTIF_MsgData_t *stMsgData,int radioIndex )
247 {
248 
249 
250  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
251  checkWifiRadioFetch(radioIndex);
252  put_boolean(stMsgData->paramValue, AutoChannelSupported);
253  stMsgData->paramtype = hostIf_BooleanType;
254  stMsgData->paramLen=1;
255  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
256  return OK;
257 }
258 
259 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_AutoChannelEnable(HOSTIF_MsgData_t *stMsgData,int radioIndex )
260 {
261 
262 
263  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
264  checkWifiRadioFetch(radioIndex);
265  put_boolean(stMsgData->paramValue, AutoChannelEnable);
266  stMsgData->paramtype = hostIf_BooleanType;
267  stMsgData->paramLen=1;
268  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
269  return OK;
270 }
271 
272 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_IEEE80211hSupported(HOSTIF_MsgData_t *stMsgData,int radioIndex )
273 {
274 
275 
276  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
277  checkWifiRadioFetch(radioIndex);
278  put_boolean(stMsgData->paramValue, IEEE80211hSupported);
279  stMsgData->paramtype = hostIf_BooleanType;
280  stMsgData->paramLen=1;
281  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
282  return OK;
283 }
284 
285 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_IEEE80211hEnabled(HOSTIF_MsgData_t *stMsgData,int radioIndex )
286 {
287 
288 
289  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
290  checkWifiRadioFetch(radioIndex);
291  put_boolean(stMsgData->paramValue, IEEE80211hEnabled);
292  stMsgData->paramtype = hostIf_BooleanType;
293  stMsgData->paramLen=1;
294  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
295  return OK;
296 }
297 
298 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_LastChange(HOSTIF_MsgData_t *stMsgData,int radioIndex )
299 {
300  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
301  checkWifiRadioFetch(radioIndex);
302  put_int(stMsgData->paramValue, LastChange);
303  stMsgData->paramtype = hostIf_UnsignedIntType;
304  stMsgData->paramLen=4;
305  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
306  return OK;
307 }
308 
309 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_MaxBitRate(HOSTIF_MsgData_t *stMsgData,int radioIndex )
310 {
311  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
312  checkWifiRadioFetch(radioIndex);
313  put_int(stMsgData->paramValue, MaxBitRate);
314  stMsgData->paramtype = hostIf_UnsignedIntType;
315  stMsgData->paramLen=4;
316  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
317  return OK;
318 }
319 
320 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_Channel(HOSTIF_MsgData_t *stMsgData,int radioIndex )
321 {
322  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
323  checkWifiRadioFetch(radioIndex);
324  put_int(stMsgData->paramValue, Channel);
325  stMsgData->paramtype = hostIf_UnsignedIntType;
326  stMsgData->paramLen=4;
327  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
328  return OK;
329 }
330 
331 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_AutoChannelRefreshPeriod(HOSTIF_MsgData_t *stMsgData,int radioIndex )
332 {
333  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
334  checkWifiRadioFetch(radioIndex);
335  put_int(stMsgData->paramValue, AutoChannelRefreshPeriod);
336  stMsgData->paramtype = hostIf_UnsignedIntType;
337  stMsgData->paramLen=4;
338  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
339  return OK;
340 }
341 
342 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_MCS(HOSTIF_MsgData_t *stMsgData,int radioIndex )
343 {
344  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
345  checkWifiRadioFetch(radioIndex);
346  put_int(stMsgData->paramValue, mcs);
347  stMsgData->paramtype = hostIf_IntegerType;
348  stMsgData->paramLen=4;
349  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
350  return OK;
351 }
352 
353 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_TransmitPower(HOSTIF_MsgData_t *stMsgData,int radioIndex )
354 {
355  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
356  checkWifiRadioFetch(radioIndex);
357  put_int(stMsgData->paramValue, TransmitPower);
358  stMsgData->paramtype = hostIf_IntegerType;
359  stMsgData->paramLen=4;
360  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
361  return OK;
362 }
363 
364 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_Status(HOSTIF_MsgData_t *stMsgData,int radioIndex )
365 {
366  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
367  checkWifiRadioFetch(radioIndex);
368  strncpy(stMsgData->paramValue, Status,TR69HOSTIFMGR_MAX_PARAM_LEN);
369  stMsgData->paramtype = hostIf_StringType;
370  stMsgData->paramLen = strlen(Status);
371  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
372  return OK;
373 }
374 
375 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_Alias(HOSTIF_MsgData_t *stMsgData,int radioIndex )
376 {
377  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
378  checkWifiRadioFetch(radioIndex);
379  strncpy(stMsgData->paramValue, Alias,TR69HOSTIFMGR_MAX_PARAM_LEN);
380  stMsgData->paramtype = hostIf_StringType;
381  stMsgData->paramLen = strlen(Alias);
382  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
383  return OK;
384 }
385 
386 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_Name(HOSTIF_MsgData_t *stMsgData,int radioIndex )
387 {
388  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
389  checkWifiRadioFetch(radioIndex);
390  strncpy(stMsgData->paramValue, Name,TR69HOSTIFMGR_MAX_PARAM_LEN);
391  stMsgData->paramtype = hostIf_StringType;
392  stMsgData->paramLen = strlen(Name);
393  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
394  return OK;
395 }
396 
397 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_SupportedFrequencyBands(HOSTIF_MsgData_t *stMsgData,int radioIndex )
398 {
399  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
400  checkWifiRadioFetch(radioIndex);
401  strncpy(stMsgData->paramValue, SupportedFrequencyBands,TR69HOSTIFMGR_MAX_PARAM_LEN);
402  stMsgData->paramtype = hostIf_StringType;
403  stMsgData->paramLen = strlen(SupportedFrequencyBands);
404  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
405  return OK;
406 }
407 
408 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_OperatingFrequencyBand(HOSTIF_MsgData_t *stMsgData,int radioIndex )
409 {
410  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
411  checkWifiRadioFetch(radioIndex);
412  strncpy(stMsgData->paramValue, OperatingFrequencyBand,TR69HOSTIFMGR_MAX_PARAM_LEN );
413  stMsgData->paramtype = hostIf_StringType;
414  stMsgData->paramLen = strlen(OperatingFrequencyBand);
415  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
416  return OK;
417 }
418 
419 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_SupportedStandards(HOSTIF_MsgData_t *stMsgData,int radioIndex )
420 {
421  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
422  checkWifiRadioFetch(radioIndex);
423  strncpy(stMsgData->paramValue, SupportedStandards,TR69HOSTIFMGR_MAX_PARAM_LEN );
424  stMsgData->paramtype = hostIf_StringType;
425  stMsgData->paramLen = strlen(SupportedStandards);
426  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
427  return OK;
428 }
429 
430 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_OperatingStandards(HOSTIF_MsgData_t *stMsgData,int radioIndex )
431 {
432  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
433  checkWifiRadioFetch(radioIndex);
434  strncpy(stMsgData->paramValue, OperatingStandards,TR69HOSTIFMGR_MAX_PARAM_LEN );
435  stMsgData->paramtype = hostIf_StringType;
436  stMsgData->paramLen = strlen(OperatingStandards);
437  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
438  return OK;
439 }
440 
441 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_PossibleChannels(HOSTIF_MsgData_t *stMsgData,int radioIndex )
442 {
443  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
444  checkWifiRadioFetch(radioIndex);
445  strncpy(stMsgData->paramValue, PossibleChannels,TR69HOSTIFMGR_MAX_PARAM_LEN);
446  stMsgData->paramtype = hostIf_StringType;
447  stMsgData->paramLen = strlen(PossibleChannels);
448  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
449  return OK;
450 }
451 
452 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_ChannelsInUse(HOSTIF_MsgData_t *stMsgData,int radioIndex )
453 {
454  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
455  checkWifiRadioFetch(radioIndex);
456  strncpy(stMsgData->paramValue, ChannelsInUse,TR69HOSTIFMGR_MAX_PARAM_LEN );
457  stMsgData->paramtype = hostIf_StringType;
458  stMsgData->paramLen = strlen(ChannelsInUse);
459  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
460  return OK;
461 }
462 
463 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_OperatingChannelBandwidth(HOSTIF_MsgData_t *stMsgData,int radioIndex )
464 {
465  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
466  checkWifiRadioFetch(radioIndex);
467  strncpy(stMsgData->paramValue, OperatingChannelBandwidth,TR69HOSTIFMGR_MAX_PARAM_LEN);
468  stMsgData->paramtype = hostIf_StringType;
469  stMsgData->paramLen = strlen(OperatingChannelBandwidth);
470  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
471  return OK;
472 }
473 
474 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_ExtensionChannel(HOSTIF_MsgData_t *stMsgData,int radioIndex )
475 {
476  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
477  checkWifiRadioFetch(radioIndex);
478  strncpy(stMsgData->paramValue, ExtensionChannel,TR69HOSTIFMGR_MAX_PARAM_LEN );
479  stMsgData->paramtype = hostIf_StringType;
480  stMsgData->paramLen = strlen(ExtensionChannel);
481  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
482  return OK;
483 }
484 
485 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_GuardInterval(HOSTIF_MsgData_t *stMsgData,int radioIndex )
486 {
487  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
488  checkWifiRadioFetch(radioIndex);
489  strncpy(stMsgData->paramValue, GuardInterval,TR69HOSTIFMGR_MAX_PARAM_LEN );
490  stMsgData->paramtype = hostIf_StringType;
491  stMsgData->paramLen = strlen(GuardInterval);
492  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
493  return OK;
494 }
495 
496 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_LowerLayers(HOSTIF_MsgData_t *stMsgData,int radioIndex )
497 {
498  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
499  checkWifiRadioFetch(radioIndex);
500  strncpy(stMsgData->paramValue, LowerLayers,TR69HOSTIFMGR_MAX_PARAM_LEN );
501  stMsgData->paramtype = hostIf_StringType;
502  stMsgData->paramLen = strlen(LowerLayers);
503  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
504  return OK;
505 }
506 
507 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_TransmitPowerSupported(HOSTIF_MsgData_t *stMsgData,int radioIndex )
508 {
509  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
510  checkWifiRadioFetch(radioIndex);
511  strncpy(stMsgData->paramValue, TransmitPowerSupported,TR69HOSTIFMGR_MAX_PARAM_LEN );
512  stMsgData->paramtype = hostIf_StringType;
513  stMsgData->paramLen = strlen(TransmitPowerSupported);
514  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
515  return OK;
516 }
517 
518 int hostIf_WiFi_Radio::get_Device_WiFi_Radio_RegulatoryDomain(HOSTIF_MsgData_t *stMsgData,int radioIndex )
519 {
520  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
521  checkWifiRadioFetch(radioIndex);
522  strncpy(stMsgData->paramValue, RegulatoryDomain,TR69HOSTIFMGR_MAX_PARAM_LEN);
523  stMsgData->paramtype = hostIf_StringType;
524  stMsgData->paramLen = strlen(RegulatoryDomain);
525  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
526  return OK;
527 }
528 
529 
530 #endif /* #ifdef USE_WIFI_PROFILE */
hostIf_WiFi_Radio::get_Device_WiFi_Radio_Upstream
int get_Device_WiFi_Radio_Upstream(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
hostIf_WiFi_Radio::get_Device_WiFi_Radio_Name
int get_Device_WiFi_Radio_Name(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
hostIf_WiFi_Radio::get_Device_WiFi_Radio_AutoChannelSupported
int get_Device_WiFi_Radio_AutoChannelSupported(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
hostIf_WiFi_Radio::get_Device_WiFi_Radio_SupportedStandards
int get_Device_WiFi_Radio_SupportedStandards(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
hostIf_WiFi_Radio::get_Device_WiFi_Radio_PossibleChannels
int get_Device_WiFi_Radio_PossibleChannels(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
hostIf_WiFi_Radio::get_Device_WiFi_Radio_Enable
int get_Device_WiFi_Radio_Enable(HOSTIF_MsgData_t *stMsgData, int radioIndex)
Enables or disables the radio.
hostIf_WiFi_Radio::get_Device_WiFi_Radio_AutoChannelEnable
int get_Device_WiFi_Radio_AutoChannelEnable(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
IARM_Bus_Call
IARM_Result_t IARM_Bus_Call(const char *ownerName, const char *methodName, void *arg, size_t argLen)
This API is used to Invoke RPC method by its application name and method name.
Definition: iarm_bus.c:57
hostIf_WiFi_Radio::get_Device_WiFi_Radio_OperatingStandards
int get_Device_WiFi_Radio_OperatingStandards(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
hostIf_WiFi_Radio::get_Device_WiFi_Radio_OperatingFrequencyBand
int get_Device_WiFi_Radio_OperatingFrequencyBand(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
_HostIf_MsgData_t
Definition: hostIf_tr69ReqHandler.h:170
hostIf_WiFi_Radio::get_Device_WiFi_Radio_Channel
int get_Device_WiFi_Radio_Channel(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
hostIf_WiFi_Radio::get_Device_WiFi_Radio_Status
int get_Device_WiFi_Radio_Status(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
put_boolean
void put_boolean(char *ptr, bool val)
This function converts the input data to Boolean type.
Definition: hostIf_utils.cpp:191
hostIf_WiFi_Radio::get_Device_WiFi_Radio_LowerLayers
int get_Device_WiFi_Radio_LowerLayers(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
Device_WiFi_Radio.h
TR-069 Device.WiFi.Radio object Public API.
hostIf_WiFi_Radio::get_Device_WiFi_Radio_Alias
int get_Device_WiFi_Radio_Alias(HOSTIF_MsgData_t *stMsgData, int radioIndex)
A non-volatile handle used to reference this instance. Alias provides a mechanism for an ACS to label...
_IARM_BUS_WiFi_DiagsPropParam_t
Definition: wifiSrvMgrIarmIf.h:396
_HostIf_MsgData_t::paramtype
HostIf_ParamType_t paramtype
Definition: hostIf_tr69ReqHandler.h:177
RDK_LOG
#define RDK_LOG
Definition: rdk_debug.h:258
hostIf_WiFi_Radio::get_Device_WiFi_Radio_LastChange
int get_Device_WiFi_Radio_LastChange(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
hostIf_WiFi_Radio
Definition: Device_WiFi_Radio.h:107
hostIf_WiFi_Radio::get_Device_WiFi_Radio_ChannelsInUse
int get_Device_WiFi_Radio_ChannelsInUse(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
_HostIf_MsgData_t::paramValue
char paramValue[(4 *1024)]
Definition: hostIf_tr69ReqHandler.h:172
IARM_BUS_WIFI_MGR_API_getRadioProps
#define IARM_BUS_WIFI_MGR_API_getRadioProps
Definition: wifiSrvMgrIarmIf.h:82
hostIf_WiFi_Radio::get_Device_WiFi_Radio_MaxBitRate
int get_Device_WiFi_Radio_MaxBitRate(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
hostIf_WiFi_Radio::get_Device_WiFi_Radio_SupportedFrequencyBands
int get_Device_WiFi_Radio_SupportedFrequencyBands(HOSTIF_MsgData_t *stMsgData, int radioIndex)
get_Device_WiFi_Radio_Status
put_int
void put_int(char *ptr, int val)
This function converts the input data to integer type.
Definition: hostIf_utils.cpp:152
_HostIf_MsgData_t::paramLen
short paramLen
Definition: hostIf_tr69ReqHandler.h:175