RDK Documentation (Open Sourced RDK Components)
hostIf_IARM_ReqHandler.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 2016 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 /**
22 * @defgroup tr69hostif
23 * @{
24 * @defgroup hostif
25 * @{
26 **/
27 
28 
29 #include "hostIf_main.h"
30 #include "hostIf_msgHandler.h"
31 #include "hostIf_tr69ReqHandler.h"
32 #include "hostIf_dsClient_ReqHandler.h"
33 #include "hostIf_DeviceClient_ReqHandler.h"
34 #include "hostIf_updateHandler.h"
35 #include "hostIf_utils.h"
36 #include "libIBus.h"
37 #include "libIARM.h"
38 #include "sysMgr.h"
39 #ifdef MEDIA_CLIENT
40 #include "integrationSettings.h"
41 #endif
42 #ifdef SNMP_ADAPTER_ENABLED
43 #include "hostIf_SNMPClient_ReqHandler.h"
44 #endif
45 #include "waldb.h"
46 
47 static bool TR69_HostIf_Mgr_Init();
48 static bool TR69_HostIf_Mgr_Connect();
49 static bool TR69_HostIf_Mgr_Get_RegisterCall();
50 static IARM_Result_t tr69hostIfMgr_Stop(void);
51 static IARM_Result_t _Gettr69HostIfMgr(void *arg);
52 static IARM_Result_t _Settr69HostIfMgr(void *arg);
53 static IARM_Result_t _SetAttributestr69HostIfMgr(void *arg);
54 static IARM_Result_t _GetAttributestr69HostIfMgr(void *arg);
55 static IARM_Result_t _RegisterForEventstr69HostIfMgr(void *arg);
56 static void _hostIf_EventHandler(const char *, IARM_EventId_t, void *, size_t);
57 //----------------------------------------------------------------------
58 // hostIf_IARM_IF_Start: This shall be use to initialize and register
59 // the hostIf application to IARM bus.
60 //----------------------------------------------------------------------
61 bool hostIf_IARM_IF_Start()
62 {
63  bool ret = false;
64  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
65 
66  if ( TR69_HostIf_Mgr_Init() &&
67  TR69_HostIf_Mgr_Connect() &&
68  TR69_HostIf_Mgr_Get_RegisterCall() )
69  {
70  ret = true;
71  /* Initialize Managers */
72  msgHandler *pMsgHandler;
73  pMsgHandler = DSClientReqHandler::getInstance();
74  pMsgHandler->init();
75  pMsgHandler = DeviceClientReqHandler::getInstance();
76  pMsgHandler->init();
77 
78 #ifdef SNMP_ADAPTER_ENABLED
79  pMsgHandler = SNMPClientReqHandler::getInstance();
80  pMsgHandler->init();
81 #endif
82  }
83 
84  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
85 
86  return ret;
87 }
88 
89 //----------------------------------------------------------------------
90 //Initialization: This shall be initialized tr69 application to IARM bus.
91 //----------------------------------------------------------------------
92 static bool TR69_HostIf_Mgr_Init()
93 {
94  IARM_Result_t err = IARM_RESULT_SUCCESS;
95  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
96 RDK_LOG(RDK_LOG_DEBUG,LOG_TR69HOSTIF,"#######################################################");
97  err = IARM_Bus_Init(IARM_BUS_TR69HOSTIFMGR_NAME);
98 
99  if(IARM_RESULT_SUCCESS != err)
100  {
101  RDK_LOG(RDK_LOG_ERROR,LOG_TR69HOSTIF,"[%s()] Failed to 'IARM_Bus_Init(%s)', return with Error "\
102  "code: (%d).\n", __FUNCTION__,IARM_BUS_TR69HOSTIFMGR_NAME, err);
103  return false;
104  }
105  RDK_LOG(RDK_LOG_DEBUG,LOG_TR69HOSTIF,"[%s()] Success 'IARM_Bus_Init(%s)'.\n", __FUNCTION__, IARM_BUS_TR69HOSTIFMGR_NAME);
106 
107  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
108  return true;
109 }
110 //----------------------------------------------------------------------
111 // Connect to IARM Bus:
112 //----------------------------------------------------------------------
113 static bool TR69_HostIf_Mgr_Connect()
114 {
115  IARM_Result_t err = IARM_RESULT_SUCCESS;
116 
117  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
118 
119  err = IARM_Bus_Connect();
120 
121  if(IARM_RESULT_SUCCESS != err)
122  {
123  RDK_LOG(RDK_LOG_ERROR,LOG_TR69HOSTIF,"[%s] Failed to IARM_Bus_Connect(), return with Error code: %d\n", __FUNCTION__, err);
124  IARM_Bus_Term();
125  return false;
126  }
127  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
128  return true;
129 }
130 
131 static IARM_Result_t _RegisterForEventstr69HostIfMgr(void *arg)
132 {
133  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
134  updateHandler::reset();
135  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
136  return IARM_RESULT_SUCCESS;
137 
138 }
139 
140 
141 //----------------------------------------------------------------------
142 //Register RPC call: This shall be RPC call registered to IARM bus.
143 //----------------------------------------------------------------------
144 static bool TR69_HostIf_Mgr_Get_RegisterCall()
145 {
146  bool ret = true;
147  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
148 
149  /* Get RPC: to get the value*/
150  if( (IARM_Bus_RegisterCall(IARM_BUS_TR69HOSTIFMGR_API_GetParams, _Gettr69HostIfMgr) != IARM_RESULT_SUCCESS) ||
151  (IARM_Bus_RegisterCall(IARM_BUS_TR69HOSTIFMGR_API_SetParams, _Settr69HostIfMgr) != IARM_RESULT_SUCCESS) ||
152  (IARM_Bus_RegisterCall(IARM_BUS_TR69HOSTIFMGR_API_SetAttributes, _SetAttributestr69HostIfMgr) != IARM_RESULT_SUCCESS) ||
153  (IARM_Bus_RegisterCall(IARM_BUS_TR69HOSTIFMGR_API_GetAttributes, _GetAttributestr69HostIfMgr) != IARM_RESULT_SUCCESS) ||
154  (IARM_Bus_RegisterCall(IARM_BUS_TR69HOSTIFMGR_API_RegisterForEvents, _RegisterForEventstr69HostIfMgr) != IARM_RESULT_SUCCESS))
155  {
156  ret = false;
157  }
158 
159  /* Notification RPC:*/
160  IARM_Bus_RegisterEvent(IARM_BUS_TR69HOSTIFMGR_EVENT_MAX);
161 
162 #ifdef MEDIA_CLIENT
163  /* Register Event Handler for IARM_TR69_CLIENT for ACS Connection status */
164  IARM_Bus_RegisterEventHandler(IARM_TR69_CLIENT, IARM_BUS_TR69Agent_ACS_CONN_EVENT, _hostIf_EventHandler);
165 #endif
166  /* Register Sys manager Event Handler for IARM_TR69_CLIENT for ACS Connection status */
167  IARM_Bus_RegisterEventHandler(IARM_BUS_SYSMGR_NAME, IARM_BUS_SYSMGR_SYSSTATE_GATEWAY_CONNECTION, _hostIf_EventHandler);
168 
169  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
170  return ret;
171 }
172 
173 void hostIf_GetAttributesReqHandler(void *arg)
174 {
175  int ret;
176  HOSTIF_MsgData_t *stMsgData = (HOSTIF_MsgData_t *) arg;
177  g_printf("[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
178  if(stMsgData)
179  {
180  ret = hostIf_SetAttributesMsgHandler(stMsgData);
181  g_printf("[hostIf_GetAttributesReqHandler : hostIf_MsgHandler()] Return value : %d\n", ret);
182  /*
183 
184  if(ret == OK)
185  {
186  hostIf_Print_msgData(stMsgData);
187  // hostIf_Free_stMsgData(stMsgData);
188  }
189  */
190  }
191  g_printf("[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
192 }
193 
194 
195 static IARM_Result_t _GetAttributestr69HostIfMgr(void *arg)
196 {
197  g_printf("[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
198 
199 
200  HOSTIF_MsgData_t *param = (HOSTIF_MsgData_t *) arg;
201  if(param)
202  {
203  // g_printf("[%s:%s] paramName :%s \n", __FUNCTION__, __FILE__, (char *)param->paramName);
204  hostIf_GetAttributesReqHandler(arg);
205  }
206 
207 
208  g_printf("[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
209  return IARM_RESULT_SUCCESS;
210 }
211 
212 void hostIf_SetAttributesReqHandler(void *arg)
213 {
214  int ret;
215  HOSTIF_MsgData_t *stMsgData = (HOSTIF_MsgData_t *) arg;
216  g_printf("[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
217  if(stMsgData)
218  {
219  ret = hostIf_SetAttributesMsgHandler(stMsgData);
220  g_printf("[*****hostIf_SetAttributesReqHandler : hostIf_MsgHandler()] Return value : %d for Parameter %s\n", ret,stMsgData->paramName);
221  /*
222 
223  if(ret == OK)
224  {
225  hostIf_Print_msgData(stMsgData);
226  // hostIf_Free_stMsgData(stMsgData);
227  }
228  */
229  }
230  g_printf("[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
231 }
232 
233 
234 static IARM_Result_t _SetAttributestr69HostIfMgr(void *arg)
235 {
236  g_printf("[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
237 
238 
239  HOSTIF_MsgData_t *param = (HOSTIF_MsgData_t *) arg;
240  if(param)
241  {
242  // g_printf("[%s:%s] paramName :%s \n", __FUNCTION__, __FILE__, (char *)param->paramName);
243  hostIf_SetAttributesReqHandler(arg);
244  }
245 
246 
247  g_printf("[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
248  return IARM_RESULT_SUCCESS;
249 }
250 
251 
252 //----------------------------------------------------------------------
253 //Initialization: This shall be initialized tr69 application to IARM bus.
254 //----------------------------------------------------------------------
255 void hostIf_IARM_IF_Stop()
256 {
257  /* Uninitialized Device setting client*/
258  msgHandler *pMsgHandler = DSClientReqHandler::getInstance();
259  pMsgHandler->unInit();
260  tr69hostIfMgr_Stop();
261 }
262 //----------------------------------------------------------------------
263 //Initialization: This shall be initialized tr69 application to IARM bus.
264 //----------------------------------------------------------------------
265 static IARM_Result_t tr69hostIfMgr_Stop(void)
266 {
267  IARM_Result_t err = IARM_RESULT_SUCCESS;
268  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering...\n", __FUNCTION__, __FILE__);
269  err = IARM_Bus_Disconnect();
270  if(IARM_RESULT_SUCCESS != err)
271  {
272  RDK_LOG(RDK_LOG_ERROR,LOG_TR69HOSTIF,"[%s] Failed to IARM_Bus_Disconnect(), return with Error code: %d\n", __FUNCTION__, err);
273  }
274 
275  err = IARM_Bus_Term();
276  if(IARM_RESULT_SUCCESS != err)
277  {
278  RDK_LOG(RDK_LOG_ERROR,LOG_TR69HOSTIF,"[%s] Failed to IARM_Bus_Term(), return with Error code: %d\n", __FUNCTION__, err);
279  }
280  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
281  return err;
282 }
283 
284 void hostIf_SetReqHandler(void *arg)
285 {
286  int ret;
287  HOSTIF_MsgData_t *stMsgData = (HOSTIF_MsgData_t *) arg;
288  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
289  if(stMsgData)
290  {
291  stMsgData->requestor = HOSTIF_SRC_IARM;
292  stMsgData->bsUpdate = HOSTIF_NONE;
293  ret = hostIf_SetMsgHandler(stMsgData);
294  RDK_LOG(RDK_LOG_DEBUG,LOG_TR69HOSTIF,"[hostIf_SetReqHandler : hostIf_MsgHandler()] Return value : %d\n", ret);
295  /*
296 
297  if(ret == OK)
298  {
299  hostIf_Print_msgData(stMsgData);
300  // hostIf_Free_stMsgData(stMsgData);
301  }
302  */
303  }
304  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
305 }
306 
307 
308 //----------------------------------------------------------------------
309 //Initialization: This shall be initialized tr69 application to IARM bus.
310 //----------------------------------------------------------------------
311 static IARM_Result_t _Settr69HostIfMgr(void *arg)
312 {
313  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
314 
315 
316  HOSTIF_MsgData_t *param = (HOSTIF_MsgData_t *) arg;
317  if(param)
318  {
319  RDK_LOG(RDK_LOG_DEBUG,LOG_TR69HOSTIF,"[%s:%s] paramName :%s \n", __FUNCTION__, __FILE__, (char *)param->paramName);
320  hostIf_SetReqHandler(arg);
321  }
322 
323 
324  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
325  return IARM_RESULT_SUCCESS;
326 }
327 
328 
329 //----------------------------------------------------------------------
330 //Initialization: This shall be initialized tr69 application to IARM bus.
331 //----------------------------------------------------------------------
332 void hostIf_GetReqHandler(void *arg)
333 {
334  int ret;
335  HOSTIF_MsgData_t *stMsgData = (HOSTIF_MsgData_t *) arg;
336 
337 // hostIf_Init_Dummy_stMsgData (&stMsgData);
338 
339  if(stMsgData)
340  {
341  DataModelParam dmParam = {0};
342  if(!getParamInfoFromDataModel(getDataModelHandle(), stMsgData->paramName, &dmParam))
343  {
344  RDK_LOG(RDK_LOG_ERROR,LOG_TR69HOSTIF,"%s: Invalid parameter name %s: doesn't exist in data-model\n", __FUNCTION__, stMsgData->paramName);
345  }
346  stMsgData->bsUpdate = getBSUpdateEnum(dmParam.bsUpdate);
347  if(dmParam.objectName)
348  free(dmParam.objectName);
349  if(dmParam.paramName)
350  free(dmParam.paramName);
351  if(dmParam.bsUpdate)
352  free(dmParam.bsUpdate);
353  if(dmParam.access)
354  free(dmParam.access);
355  if(dmParam.dataType)
356  free(dmParam.dataType);
357  if(dmParam.defaultValue)
358  free(dmParam.defaultValue);
359 
360  stMsgData->requestor = HOSTIF_SRC_IARM;
361  ret = hostIf_GetMsgHandler(stMsgData);
362  RDK_LOG(RDK_LOG_DEBUG,LOG_TR69HOSTIF,"[hostIf_GetReqHandler : hostIf_MsgHandler()] Return value : %d\n", ret);
363 
364  if(ret == OK)
365  {
366 // hostIf_Print_msgData(stMsgData);
367  //hostIf_Free_stMsgData(stMsgData);
368  }
369  else
370  RDK_LOG(RDK_LOG_ERROR,LOG_TR69HOSTIF,"[%s()] Failed with returned Value : %d for [%s]\n",
371  __FUNCTION__, ret, stMsgData->paramName);
372  }
373  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
374 }
375 
376 //----------------------------------------------------------------------
377 //Initialization: This shall be initialized tr69 application to IARM bus.
378 //----------------------------------------------------------------------
379 static IARM_Result_t _Gettr69HostIfMgr(void *arg)
380 {
381  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
382 
383 
384  HOSTIF_MsgData_t *param = (HOSTIF_MsgData_t *) arg;
385  if(param)
386  {
387  RDK_LOG(RDK_LOG_DEBUG,LOG_TR69HOSTIF,"[%s:%s] paramName :%s \n", __FUNCTION__, __FILE__, (char *)param->paramName);
388  }
389  hostIf_GetReqHandler(arg);
390  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
391  return IARM_RESULT_SUCCESS;
392 }
393 
394 
395 //----------------------------------------------------------------------
396 //_hostIf_EventHandler: This is to listen the IARM events and handles.
397 //----------------------------------------------------------------------
398 static void _hostIf_EventHandler(const char *owner, IARM_EventId_t eventId, void *data, size_t len)
399 {
400  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Entering..\n", __FUNCTION__, __FILE__);
401  if (0 == strcmp(owner, IARM_TR69_CLIENT))
402  {
403 #ifdef MEDIA_CLIENT
404  IARM_Bus_TR69Agent_EventData_t *tr69AgentData = (IARM_Bus_TR69Agent_EventData_t *)data;
405  RDK_LOG(RDK_LOG_DEBUG,LOG_TR69HOSTIF,"[%s:%s] EventId: %d value : %d \n", __FILE__, __FUNCTION__, (IARM_Bus_tr69Agent_EventId_t)eventId, tr69AgentData->value);
406 
407  switch (eventId)
408  {
409  case IARM_BUS_TR69Agent_ACS_CONN_EVENT:
410  set_ACSStatus((tr69AgentData->value == ACS_CONNECTED) ? true: false);
411  RDK_LOG(RDK_LOG_DEBUG,LOG_TR69HOSTIF,"[%s:%s] get_ACSStatus :%d \n", __FUNCTION__, __FILE__, get_ACSStatus());
412  break;
413  default:
414  break;
415  }
416 #endif
417  }
418  else if (0 == strcmp(owner, IARM_BUS_SYSMGR_NAME))
419  {
420  IARM_Bus_SYSMgr_EventData_t *eventData = (IARM_Bus_SYSMgr_EventData_t*)data;
421  int gatewayConnState = eventData->data.systemStates.state;
422  RDK_LOG(RDK_LOG_DEBUG,LOG_TR69HOSTIF,"[%s:%s:%d] Getting events from %s for Gateway Connection State : %d\n", __FILE__, __FUNCTION__, __LINE__, IARM_BUS_SYSMGR_NAME, gatewayConnState);
423 
424  set_ACSStatus((gatewayConnState) ? true: false);
425 
426  }
427  RDK_LOG(RDK_LOG_TRACE1,LOG_TR69HOSTIF,"[%s:%s] Exiting..\n", __FUNCTION__, __FILE__);
428 }
429 
430 /** @} */
431 /** @} */
__DataModelParam
Definition: waldb.h:39
IARM_Bus_Term
IARM_Result_t IARM_Bus_Term(void)
This API is used to terminate the IARM-Bus library.
hostIf_SNMPClient_ReqHandler.h
The header file provides HostIf SNMP client request handler information APIs.
sysMgr.h
IARM-Bus Sys Manager Public API.
_HostIf_MsgData_t::bsUpdate
HostIf_Source_Type_t bsUpdate
Definition: hostIf_tr69ReqHandler.h:181
IARM_BUS_TR69HOSTIFMGR_API_GetAttributes
#define IARM_BUS_TR69HOSTIFMGR_API_GetAttributes
Definition: hostIf_tr69ReqHandler.h:97
IARM_BUS_SYSMGR_NAME
#define IARM_BUS_SYSMGR_NAME
Definition: sysMgr.h:110
msgHandler::init
virtual bool init()=0
This is a pure virtual function used for initialization. Currently not implemented.
_HostIf_MsgData_t
Definition: hostIf_tr69ReqHandler.h:170
IARM_BUS_TR69HOSTIFMGR_API_RegisterForEvents
#define IARM_BUS_TR69HOSTIFMGR_API_RegisterForEvents
Definition: hostIf_tr69ReqHandler.h:100
IARM_Bus_RegisterEvent
IARM_Result_t IARM_Bus_RegisterEvent(IARM_EventId_t maxEventId)
This API is used to register all the events that are published by the application.
IARM_Bus_RegisterEventHandler
IARM_Result_t IARM_Bus_RegisterEventHandler(const char *ownerName, IARM_EventId_t eventId, IARM_EventHandler_t handler)
This API register to listen to event and provide the callback function for event notification....
Definition: iarmMgrMocks.cpp:43
IARM_Bus_RegisterCall
IARM_Result_t IARM_Bus_RegisterCall(const char *methodName, IARM_BusCall_t handler)
This API is used to register an RPC method that can be invoked by other applications.
hostIf_main.h
hostIf_main API.
hostIf_DeviceClient_ReqHandler.h
The header file provides HostIf Device client request handler information APIs.
IARM_Bus_Disconnect
IARM_Result_t IARM_Bus_Disconnect(void)
This API disconnect Application from IARM Bus so the application will not receive any IARM event or R...
IARM_BUS_TR69HOSTIFMGR_API_SetParams
#define IARM_BUS_TR69HOSTIFMGR_API_SetParams
Definition: hostIf_tr69ReqHandler.h:92
_IARM_BUS_SYSMgr_EventData_t
Definition: sysMgr.h:229
RDK_LOG
#define RDK_LOG
Definition: rdk_debug.h:258
libIBus.h
RDK IARM-Bus API Declarations.
_HostIf_MsgData_t::paramName
char paramName[(4 *1024)]
Definition: hostIf_tr69ReqHandler.h:171
IARM_BUS_TR69HOSTIFMGR_EVENT_MAX
@ IARM_BUS_TR69HOSTIFMGR_EVENT_MAX
Definition: hostIf_tr69ReqHandler.h:190
hostIf_dsClient_ReqHandler.h
The header file provides HostIf ds client request handler information APIs.
IARM_BUS_TR69HOSTIFMGR_NAME
#define IARM_BUS_TR69HOSTIFMGR_NAME
Definition: hostIf_tr69ReqHandler.h:85
IARM_Bus_Connect
IARM_Result_t IARM_Bus_Connect(void)
This API is used to connect application to the IARM bus daemon. After connected, the application can ...
Definition: iarmMgrMocks.cpp:33
msgHandler
Definition: hostIf_msgHandler.h:103
hostIf_msgHandler.h
The header file provides HostIf message handler information APIs.
_HostIf_MsgData_t::requestor
HostIf_Source_Type_t requestor
Definition: hostIf_tr69ReqHandler.h:180
msgHandler::unInit
virtual bool unInit()=0
This is a pure virtual function used for un initialization. Currently not implemented.
IARM_BUS_TR69HOSTIFMGR_API_GetParams
#define IARM_BUS_TR69HOSTIFMGR_API_GetParams
Definition: hostIf_tr69ReqHandler.h:94
IARM_Bus_Init
IARM_Result_t IARM_Bus_Init(const char *name)
This API is used to initialize the IARM-Bus library.
Definition: iarmMgrMocks.cpp:38
IARM_BUS_TR69HOSTIFMGR_API_SetAttributes
#define IARM_BUS_TR69HOSTIFMGR_API_SetAttributes
Definition: hostIf_tr69ReqHandler.h:96