systemservice/task_manager/server/src/tskm_main.cpp

   1 /*
   2  * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "tskm_main.h"
  18 #include <stdio.h>
  19 #include <string.h>
  20 #include <sys/select.h>
  21 #include <sys/time.h>
  22 #include <sys/types.h>
  23 #include <unistd.h>
  24 #include <errno.h>
  25 #include <sys/inotify.h>
  26 #include <getopt.h>
  27 #include <system_service/ss_services.h>
  28 #include <native_service/ns_version_if.h>
  29 #include <native_service/ns_np_service_protocol.h>
  30 #include <system_service/ss_system_if.h>
  31 #include <system_service/ss_version.h>
  32 #include <system_service/ss_templates.h>
  33 #include <native_service/frameworkunified_dispatcher.h>
  34 #include <other_service/rpc.h>
  35 #include <system_service/resm.h>
  36
  37 #include "tskm_data_init_local.h"
  38 #include "tskm_port_pf.h"
  39 #include "tskm_port_subsys.h"
  40 #include "tskm_debug.h"
  41 #include "tskm_util.h"
  42 #include "tskm_srvr.h"
  43 #include "tskm_comm.h"
  44 #include "tskm_watch.h"
  45 #include "system_service/tskm_local_type.h"
  46 #include "system_service/tskm_xml_data.h"
  47 #include "tskm_state.h"
  48
  49 #define TSKM_DATA_KEY "TSKM_KEY"
  50
  51 TSKM_STATIC TSKM_MAIN_CTX_t g_mainCtx;  // Main context
  52
  53 TSKM_STATIC BOOL s_isVupMode = FALSE;
  54
  55 CFrameworkunifiedVersion g_FrameworkunifiedVersion(MAJORNO, MINORNO, REVISION);
  56
  57 // For NsLog
  58 FRAMEWORKUNIFIEDLOGPARAM g_FrameworkunifiedLogParams = {
  59 FRAMEWORKUNIFIEDLOGOPTIONS, {
  60 ZONE_TEXT_10, ZONE_TEXT_11, ZONE_TEXT_12,
  61 ZONE_TEXT_13, ZONE_TEXT_14, ZONE_TEXT_15,
  62 ZONE_TEXT_16, ZONE_TEXT_17, ZONE_TEXT_18,
  63 ZONE_TEXT_19, ZONE_TEXT_20, ZONE_TEXT_21,
  64 ZONE_TEXT_22, ZONE_TEXT_23, ZONE_TEXT_24,
  65 ZONE_TEXT_25, ZONE_TEXT_26, ZONE_TEXT_27,
  66 ZONE_TEXT_28, ZONE_TEXT_29, ZONE_TEXT_30,
  67 ZONE_TEXT_31 }, FRAMEWORKUNIFIEDLOGZONES };
  68
  69 EFrameworkunifiedStatus OnFinishLoadFile(HANDLE hApp) {  // LCOV_EXCL_START 6: Because the condition cannot be set
  70   AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  71   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  72
  73   int ret;
  74   TSKM_MAIN_CTX_t* p_main = &g_mainCtx;
  75   TSKM_EVENT_INFO_t ev;
  76
  77   ret = tskm_pf_nvFileRead(hApp, &p_main->nvInfo);
  78   if (ret != 0) {
  79     TSKM_ASSERT(0);
  80   }
  81
  82   // issure INI_INITCOMP_NVM_ACCESS
  83   bzero(&ev, sizeof(ev));
  84   ev.event = TSKM_EV_PRI_REP_WAKEUP_COMP;
  85   ev.errCode = TSKM_E_OK;
  86   ev.prm.repWakeupComp.compId = INI_INITCOMP_NVM_ACCESS;
  87   tskm_handleEvent(p_main, &ev);
  88
  89   return l_eStatus;
  90 }
  91 // LCOV_EXCL_STOP
  92
  93 EFrameworkunifiedStatus onDataInitRequest(HANDLE hApp) {
  94   TSKM_ERR_t l_tskmRet = TSKM_E_OK;
  95   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  96   TSKM_MAIN_CTX_t* p_main = tskm_getMainCtx();
  97
  98   TSKM_PRINTF(TSKM_LOG_API, "%s()", __FUNCTION__)
  99
 100   if (p_main->bootInfo.startupReason == epswfINVALID) {
 101     // Before issuing FrameworkunifiedOnStart = Requests before TaskManager became Availabile are not accepted
 102     TSKM_ASSERT(0);
 103     l_tskmRet = TSKM_E_STATE;
 104   } else {
 105     T_SS_SM_START_DataStructType bootInfo(epswfIGN_ACC, TRUE,
 106                                           e_SS_SM_DATA_RESET_MODE_USER,
 107                                           epsssUNLOCK, epsstWARMSTART,
 108                                           e_SS_SM_DRAM_BACKUP_OK,
 109                                           e_SS_SM_RESET_STATUS_NONE, 0);
 110
 111     T_SS_SM_START_ExtDataStructType extBootInfo;
 112
 113     memcpy(&extBootInfo, &p_main->extBootInfo, sizeof(extBootInfo));
 114
 115     // After updating the program,
 116     // FALSE is notified here because it is notified when data initialization I/F is called at startup
 117     extBootInfo.isProgUpdated = FALSE;
 118
 119     tskm_dataInitAll(&bootInfo, &extBootInfo);
 120   }
 121
 122   PCSTR l_senderName = FrameworkunifiedGetMsgSrc(hApp);
 123   if (NULL != l_senderName) {
 124     HANDLE hSession = FrameworkunifiedMcOpenSender(hApp, l_senderName);
 125     if (hSession == NULL) {
 126       TSKM_ASSERT(0);
 127     } else {
 128       TSKM_ASSERT(
 129           eFrameworkunifiedStatusOK
 130               == FrameworkunifiedSendMsg(hSession, TSKM_DATAINIT_RESP, sizeof(l_tskmRet),
 131                             &l_tskmRet));
 132       TSKM_ASSERT(eFrameworkunifiedStatusOK == FrameworkunifiedMcClose(hSession));
 133     }
 134   }
 135
 136   return l_eStatus;
 137 }
 138
 139 EFrameworkunifiedStatus onTransStepRequest(HANDLE hApp) {  // LCOV_EXCL_START 6:Because the condition cannot be set
 140   AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 141   TSKM_MAIN_CTX_t* p_main = &g_mainCtx;
 142   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 143
 144   TSKM_EVENT_INFO_t ev;
 145   bzero(&ev, sizeof(ev));
 146
 147   ev.event = TSKM_EV_LCL_REQ_TRANS_STEP;
 148   ev.errCode = TSKM_E_OK;
 149   tskm_handleEvent(p_main, &ev);
 150
 151   return l_eStatus;
 152 }
 153 // LCOV_EXCL_STOP
 154
 155 EFrameworkunifiedStatus OnResmAvailability(HANDLE hApp) {  // LCOV_EXCL_START 6: Because the condition cannot be set
 156   AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 157   TSKM_MAIN_CTX_t* p_main = &g_mainCtx;
 158
 159   if (0 != strcmp(NTFY_ResourceMgr_Availability, FrameworkunifiedGetLastNotification(hApp))) {
 160     TSKM_ASSERT(0);
 161   } else if (FrameworkunifiedIsServiceAvailable(hApp)) {
 162     // Availability = TRUE
 163
 164     p_main->resmFd = tskm_sub_resmInit();
 165     if (-1 == p_main->resmFd) {
 166       TSKM_ASSERT(0);
 167     }
 168   }
 169   return eFrameworkunifiedStatusOK;
 170 }
 171 // LCOV_EXCL_STOP
 172
 173 //************ NS Framework Callback : must implemet ******************
 174 EFrameworkunifiedStatus FrameworkunifiedOnInitialization(HANDLE hApp) {
 175   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 176   TSKM_PRINTF(TSKM_LOG_STATE, "+");
 177
 178   l_eStatus = FrameworkunifiedRegisterServiceAvailabilityNotification(hApp, NTFY_SS_TaskManager_Availability);
 179   if (eFrameworkunifiedStatusOK != l_eStatus) {
 180     TSKM_ASSERT(0);
 181   }
 182
 183   l_eStatus = FrameworkunifiedPublishServiceAvailability(hApp, FALSE);
 184   if (eFrameworkunifiedStatusOK != l_eStatus) {
 185     TSKM_ASSERT(0);
 186   }
 187
 188   l_eStatus = FrameworkunifiedAttachCallbackToDispatcher(hApp, FRAMEWORKUNIFIED_NS_NPSERVICE,
 189                                             NPS_GET_PERS_FILE_ACK,
 190                                             OnFinishLoadFile);
 191   if (eFrameworkunifiedStatusOK != l_eStatus) {
 192     TSKM_ASSERT(0);
 193   }
 194
 195   l_eStatus = FrameworkunifiedAttachCallbackToDispatcher(hApp, FRAMEWORKUNIFIED_ANY_SOURCE,
 196                                             TSKM_DATAINIT_REQ,
 197                                             onDataInitRequest);
 198   if (eFrameworkunifiedStatusOK != l_eStatus) {
 199     TSKM_ASSERT(0);
 200   }
 201
 202   l_eStatus = FrameworkunifiedAttachCallbackToDispatcher(hApp, FrameworkunifiedGetAppName(hApp),
 203                                             TSKM_TRANS_STEP_REQ,
 204                                             onTransStepRequest);
 205   if (eFrameworkunifiedStatusOK != l_eStatus) {
 206     TSKM_ASSERT(0);
 207   }
 208
 209   l_eStatus = FrameworkunifiedSubscribeNotificationWithCallback(hApp, NTFY_ResourceMgr_Availability, OnResmAvailability);
 210   if (eFrameworkunifiedStatusOK != l_eStatus) {
 211     TSKM_ASSERT(0);
 212   }
 213
 214   TSKM_PRINTF(TSKM_LOG_STATE, "-");
 215
 216   return l_eStatus;
 217 }
 218
 219 EFrameworkunifiedStatus FrameworkunifiedOnStart(HANDLE hApp) {
 220   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 221   TSKM_PRINTF(TSKM_LOG_STATE, "+");
 222   l_eStatus = OnStart(hApp);
 223   TSKM_PRINTF(TSKM_LOG_STATE, "-");
 224   return l_eStatus;
 225 }
 226
 227 EFrameworkunifiedStatus FrameworkunifiedOnPreStart(HANDLE hApp) {
 228   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 229   TSKM_PRINTF(TSKM_LOG_STATE, "+");
 230   l_eStatus = OnStart(hApp);
 231   TSKM_PRINTF(TSKM_LOG_STATE, "-");
 232   return l_eStatus;
 233 }
 234
 235 EFrameworkunifiedStatus FrameworkunifiedOnBackgroundStart(HANDLE hApp) {
 236   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 237   TSKM_PRINTF(TSKM_LOG_STATE, "+");
 238   l_eStatus = OnStart(hApp);
 239   TSKM_PRINTF(TSKM_LOG_STATE, "-");
 240   return l_eStatus;
 241 }
 242
 243 EFrameworkunifiedStatus FrameworkunifiedOnStop(HANDLE hApp) {
 244   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 245   TSKM_MAIN_CTX_t* p_main = &g_mainCtx;
 246   // Returns Fail to send asynchronous STOP reply to SM
 247   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
 248
 249   TSKM_EVENT_INFO_t ev;
 250   bzero(&ev, sizeof(ev));
 251
 252   ev.event = TSKM_EV_LCL_REQ_STOP;
 253   ev.errCode = TSKM_E_OK;
 254   tskm_handleEvent(p_main, &ev);
 255
 256   p_main->isOnStopDone = TSKM_TRUE;
 257
 258   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 259   return l_eStatus;
 260 }
 261
 262 EFrameworkunifiedStatus FrameworkunifiedOnPreStop(HANDLE hApp) {
 263   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 264   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 265   return eFrameworkunifiedStatusOK;
 266 }
 267
 268 EFrameworkunifiedStatus FrameworkunifiedOnBackgroundStop(HANDLE hApp) {
 269   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 270   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 271   return eFrameworkunifiedStatusOK;
 272 }
 273
 274 EFrameworkunifiedStatus FrameworkunifiedOnDestroy(HANDLE hApp) {
 275   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 276   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 277   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 278   return l_eStatus;
 279 }
 280
 281 EFrameworkunifiedStatus FrameworkunifiedOnDebugDump(HANDLE hApp) {
 282   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 283   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 284   TSKM_MAIN_CTX_t* p_main = &g_mainCtx;
 285   TSKM_ERR_t l_tskmRet;
 286
 287   // Call DebugDump of all running SVCs
 288   l_tskmRet = tskm_svcsCallDebugDump(&p_main->svcs);
 289   if (TSKM_E_OK != l_tskmRet) {
 290     TSKM_ASSERT(0);
 291   }
 292
 293   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 294   return l_eStatus;
 295 }
 296
 297 EFrameworkunifiedStatus FrameworkunifiedCreateStateMachine(HANDLE hApp) {  // LCOV_EXCL_START 6: Because the condition cannot be set
 298   AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 299   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 300   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 301   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 302   return l_eStatus;
 303 }
 304 // LCOV_EXCL_STOP
 305
 306 /*********************************************************
 307  *        System start process
 308  *********************************************************/
 309 EFrameworkunifiedStatus OnStart(const HANDLE hApp) {
 310   TSKM_PRINTF(TSKM_LOG_STATE, "+");
 311   TSKM_MAIN_CTX_t* const p_main = &g_mainCtx;
 312   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 313
 314   if (p_main->isOnStartDone == TSKM_FALSE) {
 315     T_SS_SM_START_DataStructType startupInfo;
 316     TSKM_EVENT_INFO_t ev;
 317     l_eStatus = ReadMsg<T_SS_SM_START_DataStructType>(hApp, startupInfo);
 318     if (l_eStatus != eFrameworkunifiedStatusOK) {
 319       TSKM_ASSERT(0);
 320     } else {
 321       memcpy(&p_main->bootInfo, &startupInfo, sizeof(T_SS_SM_START_DataStructType));
 322     }
 323
 324     if (0 != tskm_sub_getExtBootInfo(&p_main->extBootInfo)) {
 325       TSKM_ASSERT(0);
 326     }
 327
 328     tskm_dataInitAll(&p_main->bootInfo, &p_main->extBootInfo);
 329
 330     tskm_svcsSetBootInfo(&p_main->svcs, &p_main->bootInfo, &p_main->extBootInfo);
 331     p_main->isOnStartDone = TSKM_TRUE;
 332
 333     l_eStatus = FrameworkunifiedPublishServiceAvailability(hApp, TRUE);
 334     if (l_eStatus != eFrameworkunifiedStatusOK) {
 335       TSKM_ASSERT(0);
 336     } else {
 337       TSKM_PRINTF(TSKM_LOG_STATE, "Availability TRUE");
 338     }
 339
 340     // Issure INI_INITCOMP_ON_START
 341     bzero(&ev, sizeof(ev));
 342     ev.event = TSKM_EV_PRI_REP_WAKEUP_COMP;
 343     ev.errCode = TSKM_E_OK;
 344     ev.prm.repWakeupComp.compId = INI_INITCOMP_ON_START;
 345     tskm_handleEvent(p_main, &ev);
 346   }
 347
 348   TSKM_PRINTF(TSKM_LOG_STATE, "-");
 349   return l_eStatus;
 350 }
 351
 352 /*********************************************************
 353  *        Argument analysis process
 354  *********************************************************/
 355 TSKM_STATIC EFrameworkunifiedStatus argParser(SI_32 argument, PCHAR argumentValue) {  // LCOV_EXCL_START 6: for process initialization processing
 356   AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 357   if ('v' == argument) {
 358     s_isVupMode = TRUE;
 359   }
 360
 361   return eFrameworkunifiedStatusOK;
 362 }
 363 // LCOV_EXCL_STOP
 364 /*********************************************************
 365  *        Creating process for TSKM internal context
 366  *********************************************************/
 367 TSKM_STATIC void ctxCreate(TSKM_MAIN_CTX_t* p_main, int argc, char* argv[]) {
 368   int ret;
 369   EFrameworkunifiedStatus taskmanagerRet;
 370   TSKM_ERR_t tskmRet;
 371   FrameworkunifiedDefaultCallbackHandler cbFuncs;
 372   FRAMEWORKUNIFIED_MAKE_DEFAULT_CALLBACK(cbFuncs);
 373   CustomCommandLineOptions cmdLineOpt = { "v", NULL, argParser };
 374
 375   p_main->state = TSKM_ST_ACCOFF;
 376   p_main->isOnStartDone = TSKM_FALSE;
 377
 378   // Create dispatcher
 379   taskmanagerRet = FrameworkunifiedCreateDispatcherWithoutLoop(SS_TASK_MANAGER, p_main->hApp, argc,
 380                                           argv, &cbFuncs, TRUE, &cmdLineOpt);
 381   if (eFrameworkunifiedStatusOK != taskmanagerRet) {  // LCOV_EXCL_BR_LINE 6: For process initialization processing
 382     // LCOV_EXCL_START 6: For process initialization processing
 383     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 384     TSKM_ASSERT_PRINT(0, "%d", taskmanagerRet);
 385     goto ERROR;
 386     // LCOV_EXCL_STOP
 387   }
 388
 389   TSKM_PRINTF(TSKM_LOG_STATE, "s_isVupMode :%s", s_isVupMode ? "TRUE" : "FALSE");
 390
 391   taskmanagerRet = FrameworkunifiedGetDispatcherFD(p_main->hApp, &p_main->nsFd);
 392   if (taskmanagerRet != eFrameworkunifiedStatusOK) {  // LCOV_EXCL_BR_LINE 6: For process initialization processing
 393     // LCOV_EXCL_START 6: For process initialization processing
 394     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 395     TSKM_ASSERT_PRINT(0, "%d", taskmanagerRet);
 396     exit(EXIT_FAILURE);
 397     // LCOV_EXCL_STOP
 398   }
 399
 400   p_main->sigFd = tskm_pf_sysInit();  // Platform initialization
 401   if (p_main->sigFd == -1) {  // LCOV_EXCL_BR_LINE 6: For process initialization processing
 402     // LCOV_EXCL_LINE 6: For process initialization processing
 403     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 404     TSKM_ASSERT(0);
 405     goto ERROR;
 406     // LCOV_EXCL_STOP
 407   }
 408
 409   p_main->iFd = inotify_init1(IN_CLOEXEC);
 410   if (p_main->sigFd == -1) {  // LCOV_EXCL_BR_LINE 6: For process initialization processing
 411     // LCOV_EXCL_LINE 6: For process initialization processing
 412     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 413     TSKM_ASSERT_ERRNO(0);
 414     goto ERROR;
 415     // LCOV_EXCL_STOP
 416   }
 417
 418   // Obtain RESM FDs after waiting for Availability
 419   p_main->resmFd = -1;
 420
 421   tskmRet = tskm_srvSockCreate(TSKM_SOCKET_NAME, &p_main->sock);
 422   TSKM_ERR_CHK(tskmRet, TSKM_E_OK, ERROR);  // LCOV_EXCL_BR_LINE 6: For process initialization processing
 423
 424   ret = tskm_pf_nvFileInit(p_main->hApp);
 425   if (ret != 0) {  // LCOV_EXCL_BR_LINE 6: For process initialization processing
 426     // LCOV_EXCL_START 6: For process initialization processing
 427     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 428     TSKM_ASSERT(0);
 429     goto ERROR;
 430     // LCOV_EXCL_STOP
 431   }
 432
 433   ret = tskm_initServiceList(&p_main->svcs, p_main->iFd);   // Service to be started
 434   if (0 != ret) {  // LCOV_EXCL_BR_LINE 6: For process initialization processing
 435     // LCOV_EXCL_START 6: For For process initialization process
 436     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 437     TSKM_ASSERT(0);
 438     goto ERROR;
 439     // LCOV_EXCL_STOP
 440   }
 441
 442   tskm_initWakeupCtx(&p_main->wakeup, s_isVupMode);  // Gradual startup info
 443   tskm_initDownCtx(&p_main->down, s_isVupMode);      // Gradual termination info
 444   return;
 445
 446   // LCOV_EXCL_START 6: For process initialization processing
 447   ERROR:
 448   AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 449   tskm_pf_exit(EXIT_FAILURE);
 450   return;
 451   // LCOV_EXCL_STOP
 452 }
 453
 454 /*********************************************************
 455  *        Get main context
 456  *********************************************************/
 457 TSKM_MAIN_CTX_t*
 458 tskm_getMainCtx(void) {
 459   return &g_mainCtx;
 460 }
 461
 462 /*********************************************************
 463  *        Process initialization process (MAIN function sub)
 464  *********************************************************/
 465 int Init_Process(int* rpcFd, int* sockFd, int* maxFd, fd_set* fds, TSKM_MAIN_CTX_t* p_main) {
 466   int ret;
 467   uint32_t ii;
 468
 469   TSKM_SRV_CONNENT_LIST_t* p_connList = &p_main->sock.connList;
 470
 471   FD_ZERO(fds);
 472
 473   FD_SET(*rpcFd, fds);
 474   *maxFd = TSKM_MAX(*rpcFd, *maxFd);  // LCOV_EXCL_BR_LINE 6:  For process initialization processing
 475
 476   FD_SET(*sockFd, fds);
 477   *maxFd = TSKM_MAX(*sockFd, *maxFd);  // LCOV_EXCL_BR_LINE 6:  For process initialization processing
 478
 479   FD_SET(p_main->nsFd, fds);
 480   *maxFd = TSKM_MAX(p_main->nsFd, *maxFd);  // LCOV_EXCL_BR_LINE 6:  For process initialization processing
 481
 482   FD_SET(p_main->sigFd, fds);
 483   *maxFd = TSKM_MAX(p_main->sigFd, *maxFd);  // LCOV_EXCL_BR_LINE 6:  For process initialization processing
 484
 485   if (-1 != p_main->resmFd) {  // LCOV_EXCL_BR_LINE 6:  For process initialization processing
 486     // LCOV_EXCL_START 6:  For process initialization processing
 487     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 488     FD_SET(p_main->resmFd, fds);
 489     *maxFd = TSKM_MAX(p_main->resmFd, *maxFd);
 490     // LCOV_EXCL_STOP
 491   }
 492
 493   for (ii = 0; ii < p_connList->num; ii++) {  // LCOV_EXCL_BR_LINE 6:  For process initialization processing
 494     // LCOV_EXCL_START 6:  For process initialization processing
 495     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 496     TSKM_SRV_CONNENT_t* p_conn = &p_connList->conn[ii];
 497     FD_SET(p_conn->connFd, fds);
 498     *maxFd = TSKM_MAX(p_conn->connFd, *maxFd);
 499     // LCOV_EXCL_STOP
 500   }
 501
 502   TSKM_PRINTF(TSKM_LOG_FUNC, "SELECT IN");
 503   ret = select(*maxFd + 1, fds, NULL, NULL, NULL);
 504   if (ret < 1) {
 505     if (errno != EINTR) {
 506       TSKM_ASSERT(0);
 507     }
 508     return ret;
 509   }
 510   TSKM_PRINTF(TSKM_LOG_FUNC, "SELECT OUT");
 511   return 0;
 512 }
 513
 514 /*********************************************************
 515  *        Receiving Messages from CONNECT Clients (MAIN Functions Sub)
 516  *********************************************************/
 517 void Recv_Msg_FromConnectClient(fd_set* fds, TSKM_MAIN_CTX_t* p_main) {
 518   uint32_t ii;
 519   TSKM_SRV_CONNENT_LIST_t* p_connList = &p_main->sock.connList;
 520
 521   // Messages from CONNECT clients
 522   for (ii = 0; ii < p_connList->num; ii++) {
 523     TSKM_SRV_CONNENT_t* p_conn = &p_connList->conn[ii];
 524     if (FD_ISSET(p_conn->connFd, fds)) {
 525       TSKM_PRINTF(TSKM_LOG_FUNC, "connFd IN");
 526       TSKM_EVENT_INFO_t ev;
 527       int ret;
 528       ret = tskm_sockRcv(p_conn->connFd, &ev);
 529
 530       if (ret < 0) {
 531         TSKM_ASSERT(0);
 532       } else {
 533         TSKM_SVC_CTX_t* p_svc;
 534
 535         if (ret == 0) {
 536           // Closed Connection
 537           TSKM_PRINTF(TSKM_LOG_STATE, "DISSCON pid:%d", p_conn->pid);
 538           ev.event = TSKM_EV_PRI_REP_DISCONNECT;
 539           ev.errCode = TSKM_E_OK;
 540           ev.fromPid = p_conn->pid;
 541           tskm_srvSockDisconnect(&p_main->sock, p_conn);
 542           p_conn = NULL;  // If the connection is lost, it cannot be referenced.
 543         }
 544
 545         p_svc = tskm_svcsGetSvcByPid(&p_main->svcs, ev.fromPid);
 546         if (p_svc) {  // Events from service
 547           TSKM_ERR_t tskmRet;
 548           tskmRet = tskm_svcEventHandle(p_svc, &ev);  // Service handler
 549           if (tskmRet != TSKM_E_OK) {
 550             TSKM_ASSERT(0);
 551           }
 552         }
 553         if (ev.event != TSKM_EV_NOP) {
 554           tskm_handleEvent(p_main, &ev);             // Main handler
 555         }
 556       }
 557       TSKM_PRINTF(TSKM_LOG_FUNC, "connFd OUT");
 558     }
 559   }
 560 }
 561
 562 /*********************************************************
 563  *        CONNECT Requests (MAIN Functions Sub)
 564  *********************************************************/
 565 void Recv_Req_Connect(fd_set* fds, TSKM_MAIN_CTX_t* p_main, int sockFd) {
 566   // CONNECT requests
 567   if (FD_ISSET(sockFd, fds)) {
 568     TSKM_PRINTF(TSKM_LOG_FUNC, "sockFd IN");
 569
 570     TSKM_SRV_CONNENT_t* conn;
 571     conn = tskm_srvSockConnect(&p_main->sock);
 572     if (conn == NULL) {
 573       TSKM_ASSERT(0);
 574     } else {
 575       TSKM_SVC_CTX_t* p_svc;
 576       TSKM_PRINTF(TSKM_LOG_STATE, "CONNECT pid:%d", conn->pid);
 577
 578       p_svc = tskm_svcsGetSvcByPid(&p_main->svcs, conn->pid);
 579       if (p_svc) {
 580         TSKM_ERR_t tskmRet;
 581         TSKM_EVENT_INFO_t ev;
 582
 583         ev.event = TSKM_EV_PRI_REP_CONNECT;
 584         ev.errCode = TSKM_E_OK;
 585         ev.fromPid = conn->pid;
 586         ev.prm.repConnect.connFd = conn->connFd;
 587
 588         tskmRet = tskm_svcEventHandle(p_svc, &ev);  // Service handler
 589         if (tskmRet != TSKM_E_OK) {
 590           TSKM_ASSERT(0);
 591         } else if (ev.event != TSKM_EV_NOP) {
 592           tskm_handleEvent(p_main, &ev);            // Main hander
 593         }
 594       }
 595     }
 596     TSKM_PRINTF(TSKM_LOG_FUNC, "sockFd OUT");
 597   }
 598 }
 599
 600 /*********************************************************
 601  *        MAIN Function
 602  *********************************************************/
 603 int main(int argc, char* argv[]) {
 604   RPC_ID rpcId = TSKM_RPC_ID;
 605   int rpcFd = 0;
 606   int maxFd = 0;
 607   int ret;
 608   fd_set fds;
 609   TSKM_MAIN_CTX_t* p_main = &g_mainCtx;
 610
 611   // Logging setting
 612   FRAMEWORKUNIFIED_SET_ZONES();
 613
 614   ctxCreate(p_main, argc, argv);  // Initialize context
 615
 616   tskm_sub_init();    // Initialize sub systems
 617
 618   RPC_START_SECURE_SERVER(rpcId);
 619   RPC_get_fd(rpcId, &rpcFd);
 620
 621   uid_t uid[2];
 622   gid_t gid[2];
 623
 624   uid[0] = 0;
 625   gid[0] = 0;
 626   uid[1] = getuid();
 627   gid[1] = getgid();
 628
 629   if (RPC_OK != RPC_regist_credential(2, uid, 2, gid)) {  // LCOV_EXCL_BR_LINE 6: For process initialization processing
 630     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 631     TSKM_ASSERT(0);  // LCOV_EXCL_LINE 6: For process initialization processing
 632   }
 633
 634   // Start periodic timer thread
 635   ret = tskm_watch_startTimer();
 636   if (ret != 0) {  // LCOV_EXCL_BR_LINE 6: For process initialization processing
 637     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 638     TSKM_ASSERT(0);  // LCOV_EXCL_LINE 6: For process initialization processing
 639   }
 640
 641   tskm_stateTransit(p_main, TSKM_ST_ACCOFF, TSKM_ST_ACCON);
 642
 643   p_main->isExec = TSKM_TRUE;
 644   while (p_main->isExec) {  // LCOV_EXCL_BR_LINE 6: For process initialization processing
 645     int sockFd = p_main->sock.sockFd;
 646
 647     // Initialization processing
 648     if (Init_Process(&rpcFd, &sockFd, &maxFd, &fds, p_main) != 0) {  // LCOV_EXCL_BR_LINE 6: For process initialization processing
 649       AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 650       continue;  // LCOV_EXCL_LINE 6: For process initialization processing
 651     }
 652
 653     // RPC API
 654     if (FD_ISSET(rpcFd, &fds)) {
 655       RPC_process_API_request(rpcId);
 656     }
 657
 658     // Process termination signal
 659     if (FD_ISSET(p_main->sigFd, &fds)) {
 660       int count = 0;
 661
 662       do {
 663         TSKM_EVENT_INFO_t ev;
 664         ev.event = TSKM_EV_SVC_REP_TERM;
 665
 666         count++;
 667
 668         ret = tskm_pf_cleanupProc(p_main->sigFd, &ev.fromPid, &ev.errCode);
 669         if (ret == -1) {
 670           TSKM_ASSERT(0);
 671           break;
 672         }
 673
 674         TSKM_SVC_CTX_t* p_svc;
 675
 676         p_svc = tskm_svcsGetSvcByPid(&p_main->svcs, ev.fromPid);
 677         if (p_svc) {
 678           TSKM_ERR_t tskmRet;
 679
 680           tskmRet = tskm_svcEventHandle(p_svc, &ev);  // Service handler
 681           if (tskmRet != TSKM_E_OK) {
 682             TSKM_ASSERT(0);
 683           }
 684           if (ev.event != TSKM_EV_NOP) {
 685             tskm_handleEvent(p_main, &ev);           // Main handler
 686           }
 687         }
 688       } while (ret == 1 && count < 50);
 689     }
 690
 691     if (FD_ISSET(p_main->nsFd, &fds)) {
 692       FrameworkunifiedDispatchProcessWithoutLoop(p_main->hApp);
 693     }
 694
 695     // EV from RESM
 696     if (-1 != p_main->resmFd) {
 697       if (FD_ISSET(p_main->resmFd, &fds)) {
 698         TSKM_EVENT_INFO_t ev;
 699         int ret;
 700         ret = tskm_sub_resmRcv(&ev);
 701
 702         if (-1 == ret) {
 703           TSKM_ASSERT(0);
 704         } else {
 705           tskm_handleEvent(p_main, &ev);
 706         }
 707       }
 708     }
 709
 710     // Messages from connected clients
 711     Recv_Msg_FromConnectClient(&fds, p_main);
 712
 713     // CONNECT request
 714     Recv_Req_Connect(&fds, p_main, sockFd);
 715   }
 716
 717   tskm_srvSockDestory(&p_main->sock);
 718
 719   RPC_end(rpcId);
 720
 721   FrameworkunifiedDestroyDispatcherWithoutLoop(p_main->hApp);
 722   TSKM_PRINTF(TSKM_LOG_STATE, "tskm end");
 723
 724   sleep(TSKM_CFG_WAIT_SHUTDOWN);
 725   return 0;
 726 }  // LCOV_EXCL_BR_LINE 10: Final line
 727