diff options
Diffstat (limited to 'video_in_hal/otherservice/rpc_library/library/src/rpc_lib.c')
| -rwxr-xr-x | video_in_hal/otherservice/rpc_library/library/src/rpc_lib.c | 1264 |
1 files changed, 0 insertions, 1264 deletions
diff --git a/video_in_hal/otherservice/rpc_library/library/src/rpc_lib.c b/video_in_hal/otherservice/rpc_library/library/src/rpc_lib.c deleted file mode 100755 index 76f0d49..0000000 --- a/video_in_hal/otherservice/rpc_library/library/src/rpc_lib.c +++ /dev/null @@ -1,1264 +0,0 @@ -/* - * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/** - * @file rpc_lib.c - * @brief RPC Library-API Function Implementation - * - */ -/** @mainpage - * This document describes the following API functions, structures, - * type declarations, and macros. - * - RPC library external specification - * - External specifications for RPC tools - * - * For an overview of other RPC libraries and tools and anomaly processing, - * to reference the Word version of the documentation. - * (external specifications and programming guides) */ -/** @defgroup RPClib RPC library external specification */ -/** @defgroup RPCtool RPC tool (rpc_apidef) */ -/** @defgroup RPC_ID_assign RPC_ID Assignment */ -/** @defgroup RPClib_in RPC library internal specifications (incomplete) */ -/** @addtogroup RPClib - * @{ - */ -#include <stdio.h> -#include <stdlib.h> -#include <string.h> -#include <unistd.h> -#include <fcntl.h> -#include <errno.h> -#include <sys/types.h> -#include <sys/time.h> -#include <sys/socket.h> -#include <sys/select.h> -#include <sys/poll.h> -#include <sys/stat.h> -#include <netinet/in.h> -#include <sys/un.h> -#include <sys/inotify.h> - -#include <other_service/rpc.h> -#include "rpc_internal.h" - -#include <native_service/cl_process.h> // for CL_INTFY_FILENAME_FORMAT -#include <native_service/cl_monitor.h> - - -/* Prototype declarations */ -static RPC_Result ProcessAPIcallRequest(RpcIdInfo *idinfo, RPC_ID client, - UINT16 api_num, char *args_string, - unsigned int args_size); -static RPC_Result RpcAllDeleteSrvrPid(RpcIdInfo *idinfo); -static RPC_Result RpcClientWaitCertification(RpcIdInfo *idinfo, pid_t *srvr_pid); -static RPC_Result RpcRegistSrvrPid(RpcIdInfo *idinfo, RPC_ID srvr_rpc_id, pid_t srvr_pid, int wd); - -#define THREAD_INFO_CHECK(th) \ - if ((th) == NULL) { \ - RPC_LOG_STATE("No thread info"); \ - return RPC_ERR_Fatal; \ - } - -#define SUB_THREAD_CHECK() \ - if (g_rpc_thread_alive == 0) { \ - RPC_LOG_STATE("No sub thread -- shutdown"); \ - RpcDestroyThreadInfo(); \ - return RPC_ERR_Fatal; \ - } - -/** - * Waiting for response packet for API call and API result transmission - * Timeout time in msec. - * If the other program is abnormal (process termination), delay occurs in the meanwhile. - * Confirm the operation on the actual machine and set again. - */ -#define RESPONSE_WAIT_MSEC_DEFAULT 2000 -static unsigned int Response_wait_msec = RESPONSE_WAIT_MSEC_DEFAULT; - -char *RPC_DEBUG = NULL; - -#if defined(RPC_USE_UNIX_AUTOBIND) - - static RPC_Result -CreateClientIdinfo(RpcThreadInfo *th, RPC_ID *pID) { - if (RpcCreateIdInfo(th, *pID, NULL, NO_SECURE_CHECK) < 0) { - RPC_LOG_ERR("Can't create id_info"); - return RPC_ERR_Fatal; - } - - *pID = RPC_my_id(RPC_clnt_idinfo(th)); - RPC_LOG_DEBUG("RPC: assigned client ID %d", *pID); - if (RPC_DEBUG) { // LCOV_EXCL_BR_LINE 7: debug - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - printf("RPC[%s]: client start finished.\n", RPC_DEBUG); // LCOV_EXCL_LINE 7: debug - } - return RPC_OK; -} -#else /* !AUTOBIND */ - -#include <sys/file.h> - - static int -FindUniqClientId(void) { -#define RPC_ID_FILE_NAME "/tmp/RPC/id" -#define RPC_MIN_CLIENT_ID 1024 -#define RPC_MAX_CLIENT_ID (1024+32768-1) - - int fd, found; - RPC_ID id, next; - struct stat statbuf; - char fname[32]; - - fd = open(RPC_ID_FILE_NAME, O_RDWR|O_CLOEXEC, 0777); - if (fd < 0) { - id = RPC_MIN_CLIENT_ID; - fd = open(RPC_ID_FILE_NAME, O_RDWR|O_CREAT|O_CLOEXEC, 0777); - if (fd < 0) { - return -1; - } - flock(fd, LOCK_EX); // Possible sleep here - } else { - flock(fd, LOCK_EX); // Possible sleep here - read(fd, &id, sizeof(id)); - } - - found = 0; - while(found == 0) { - rpc_set_socket_name(fname, id); - if (stat(fname, &statbuf) < 0) { - found = 1; - break; - } - id++; - if (id > RPC_MAX_CLIENT_ID) { - id = RPC_MIN_CLIENT_ID; - } - } - - next = id + 1; - if (next > RPC_MAX_CLIENT_ID) { - next = RPC_MIN_CLIENT_ID; - } - - lseek(fd, 0, SEEK_SET); - write(fd, &next, sizeof(next)); - flock(fd, LOCK_UN); - close(fd); - - return id; -} - - static RPC_Result -CreateClientIdinfo(RpcThreadInfo *th, UINT16 port) { - if (RpcCreateIdInfo(th, port, NULL, NO_SECURE_CHECK) < 0) { - RPC_LOG_ERR("Can't create id_info"); - return RPC_ERR_Fatal; - } - // LCOV_EXCL_BR_START 7: debug - if (RPC_DEBUG) { - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - printf("RPC[%s]: client start finished.\n", RPC_DEBUG); - } - // LCOV_EXCL_BR_STOP - return RPC_OK; -} -#endif /* AUTOBIND */ - -/** @fn RPC_START_SERVER(ID) - * @brief RPC_start() macro for the server - * - * Used by RPC-API server programs to activate the RPC library. - * ID specifies a symbol of the form XXX_RPC_ID defined in rpc_id.h. - * Only one server program per thread is allowed. - * When a server program calls an API as a client of another server, - * it only needs to call RPC_START_SERVER, - * not RPC_START_CLIENT. - * - * RPC_end() should be called when the RPC library is no longer needed. - * @param ID [IN]RPC_ID of the program - * @see RPC_start - * @see RPC_end - */ -/** @fn RPC_START_CLIENT(pID) - * @brief RPC_start() macro for clients - * - * Use only the client functions of the RPC library - * (only calling APIs provided by other programs), - * This macro is used for the start process. - * - * - * RPC_end() should be called when the RPC library is no longer needed. - * - * @param pID [OUT]Pointer to the RPC_ID of the program - * @see RPC_start - * @see RPC_end - */ -/** @brief Start processing of the RPC library - * - * - With an open socket, RPC_ID, and API call dispatching functions - * Register in the global variable (managed separately for each thread and RPC_ID) - * - Starting use as a server - * - func specifies a function pointer (defined in stub) that is not a NULL. - * - Specifies a fixed ID defined in rpc_id.h as the ID. - * - If the same thread has already started using the server, an error code is returned. - * - When the server function is started for the first time in a process, - * one subthread is started to process received packets - * in the background. - * - Starting use as a client - * - NULL is specified in the func. - * - In principle, an invalid ID value (RPC_NO_PORT) is specified. - * This function automatically assigns IDs and returns the assignment result to pID. - * - However, if another program has already started using it as a client, - * it shares the socket/RPC_ID instead of creating a new socket. - * - Exceptionally, it is allowed to specify a fixed ID defined in rpc_id.h as the ID. - * This is the only way to use RPC_start() in programs - * where it is difficult to always call RPC_end() at the end of use by program structure/design. - * - In this case, the pID argument is not referenced. - * - The maximum number of threads that use the RPC library in a process is - * specified by RPC_MAX_THREADS_IN_PROCESS. - * - * @param id [IN]RPC_ID of the program (in the case of RPC_NO_PORT, this means automatic assignment) - * @param dispatch_func Dispatching functions (defined in stub files for servers, - * and NULL specified in programs that do not provide APIs) - * @param pID [OUT]RPC_ID of the automatically assigned program - * - * @retval RPC_OK: normal completion - * @retval Otherwise: Abnormal termination (FATAL) - * - * @note Normally, this function is not called directly, but the following macro is used. - * - RPC_START_SERVER(ID) - * For programs that provide RPC server functions. - * This macro is also used when both server and client functions are used. - * - RPC_START_CLIENT(pID) - * For programs that use only the RPC client function. - */ - RPC_Result -RPC_start(RPC_ID id, RPC_dispatch_func_t func, RPC_ID *pID, INT32 secure_check) -{ -#if defined(RPC_USE_SYSLOG) - static int init_syslog = 0; - - if (init_syslog == 0) { - openlog("librpc", LOG_PID, LOG_USER); - setlogmask(LOG_UPTO(LOG_INFO)); - /* setlogmask(LOG_MASK(LOG_DEBUG)); */ - init_syslog = 1; - if (func != NULL) - RPC_LOG_STATE("RPC_START_SERVER(%#x)\n", id); - } -#endif /* RPC_USE_SYSLOG */ - - if (func != NULL && id == RPC_NO_ID) { /* No ID is specified despite as a server */ - RPC_LOG_ERR("Invalid RPC_start server arg"); - return RPC_ERR_Fatal; - } - if (func != NULL && pID != NULL) { /* Requested obtaining pID despite as a server */ // LCOV_EXCL_BR_LINE 200: macro guarantee impossible both not NULL, RPC_START_*** - RPC_LOG_ERR("Invalid RPC_start server arg"); // LCOV_EXCL_START 200: macro guarantee impossible both not NULL, RPC_START_*** - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - return RPC_ERR_Fatal; - } // LCOV_EXCL_STOP - if (func == NULL && id != RPC_NO_ID) { /* Specified ID despite as a client */ - RPC_LOG_ERR("Invalid RPC_start server arg"); - return RPC_ERR_Fatal; - } -#if defined(RPC_USE_UNIX_AUTOBIND) - if (func == NULL && pID == NULL) { - /* pID is NULL despite as a client (not supported for ID-specified clients) */ - RPC_LOG_ERR_W_NAME("RPC_Start(ID, NULL, NULL) is no longer supported, ID is auto-assigned"); - return RPC_ERR_Fatal; - } -#else /* !AUTOBIND */ - if (func == NULL && id == RPC_NO_ID && pID == NULL) { - /* pID is NULL despite as an auto-assigned client */ - RPC_LOG_ERR("Invalid RPC_start arg"); - return RPC_ERR_Fatal; - } -#endif /* !AUTOBIND */ - if ((secure_check != NO_SECURE_CHECK) && (secure_check != NEED_SECURE_CHECK)) { // LCOV_EXCL_BR_LINE 200: macro guarantee only two value, RPC_START_*** - /* Check Arguments for Client Authentication */ - RPC_LOG_ERR("Invalid RPC_start arg"); // LCOV_EXCL_START 200: macro guarantee only two value, RPC_START_*** - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - return RPC_ERR_Fatal; - } // LCOV_EXCL_STOP - - RpcThreadInfo *th = RpcMyThreadInfo(); - if (th == NULL) { - th = RpcCreateThreadInfo(); - if (th == NULL) { // LCOV_EXCL_BR_LINE 5: fail safe for libc malloc - return RPC_ERR_Fatal; - } - } - - /* RPC_start is already done in the same thread */ - if (func != NULL) {/* Server start */ - if (RPC_srvr_idinfo(th) != NULL) {/* Server already started */ - RPC_LOG_ERR("duplicated RPC_START_SERVER"); - return RPC_ERR_Fatal; - } - } else { /* Client start */ - if (RPC_clnt_idinfo(th) != NULL) {/* Client already started */ - if (pID != NULL) { // LCOV_EXCL_BR_LINE 6: double check - *pID = (RPC_clnt_idinfo(th))->port; - RPC_LOG_DEBUG("use existing client ID=%d", *pID); - RPC_inc_clnt_count(RPC_clnt_idinfo(th)); - } - /* - * When pID == NULL (RPC_ID fixed), there is no guarantee - * that RPC_end() will be called as many times as needed, so it does not count up. - */ - return RPC_OK; - } - } - - if (func == NULL) {/* Client start */ -#if defined(RPC_USE_UNIX_AUTOBIND) - /* Automatically assign everything without supporting ID specification */ - RPC_ID id_local = RPC_NO_ID; - RPC_Result ret = CreateClientIdinfo(th, &id_local); - if(RPC_OK != ret) return ret; - - if (pID) { // LCOV_EXCL_BR_LINE 6: double check - *pID = id_local; - } - RPC_clnt_inotify_fd(RPC_clnt_idinfo(th)) = inotify_init1(IN_CLOEXEC); - return ret; -#else /* !AUTOBIND */ - if (id == RPC_NO_ID) { - /* No port number specified -> Automatically assign an ID and port number here */ - /* - * FindUniqClientId() returns ID within the range of RPC_MIN_CLIENT_ID(1024) to RPC_MAX_CLIENT_ID(1024+32768-1) - */ - int ret; - ret = FindUniqClientId(); - if (ret < 0) { - return RPC_ERR_Fatal; - } - /* pID != NULL is already checked */ - *pID = (UINT16)ret; - return CreateClientIdinfo(th, *pID); - } else { - /* - * Client start with specified port number - * Programs that cannot guarantee an RPC_end() call - * at termination specify a fixed RPC_ID from the upper level and use it. - * (To avoid memory shortage caused by building up socket-files in /tmp/RPC) - */ - return CreateClientIdinfo(th, id); - } -#endif /* !AUTOBIND */ - } - - /* Dispatch func specified (servers) -> bind */ - CL_MonitorInit(CL_MONITOR_INIT_USER); /* Using the API for Error Monitoring */ - - if (RpcCreateIdInfo(th, id, func, secure_check) < 0) { - RPC_LOG_ERR("Can't create id_info"); - return RPC_ERR_Fatal; - } - - if (RPC_DEBUG) { // LCOV_EXCL_BR_LINE 7: debug - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - printf("RPC[%s]: server thread invoked\n", RPC_DEBUG); // LCOV_EXCL_LINE 7: debug - } - char *env; - if ((env = getenv("RPC_RESPONSE_WAIT")) != NULL) { - Response_wait_msec = (unsigned int)strtol(env, NULL, 10); - } - - return RPC_OK; -} - - static void -RpcEndSub(RpcThreadInfo *th, RpcIdInfo *idinfo) { - int sockfd; -#if !defined(RPC_USE_UNIX_AUTOBIND) - char path[120]; - - rpc_set_socket_name(path, RPC_my_id(idinfo)); -#endif /* !AUTOBIND */ - sockfd = idinfo->sock; - RpcDestroyIdInfo(th, idinfo); - close(sockfd); -#if !defined(RPC_USE_UNIX_AUTOBIND) - unlink(path); -#endif /* !AUTOBIND */ -} - -/** @brief RPC Library End-of-Use Processing - * - * - Perform termination processing such as closing the opened socket, releasing the memory. - * (Server/Client Common) - * - If there are no programs in the thread that use RPC_ID, - * the subthread started by RPC_start is terminated. - * - Each RPC_ID must be called before the program exits. - * - RPC_end must be called by the thread that performed the RPC_start. - * - Ignored unused or no longer used RPC_ID if specified. - * - * @param ID [IN]RPC_ID of the program - */ - void -RPC_end(RPC_ID id) { - RpcThreadInfo *th = RpcMyThreadInfo(); - if (th == NULL) { - return; - } - RpcIdInfo *idinfo; - idinfo = RPC_srvr_idinfo(th); - if (idinfo != NULL && RPC_my_id(idinfo) == id) {/* srvr */ - RpcEndSub(th, idinfo); - } - - idinfo = RPC_clnt_idinfo(th); - if (idinfo != NULL && RPC_my_id(idinfo) == id) {/* client */ - - RPC_dec_clnt_count(idinfo); - if (RPC_clnt_count(idinfo) == 0) { - /* Deleting management table of the communication destination server PID */ - RpcAllDeleteSrvrPid(idinfo); - close(RPC_clnt_inotify_fd(idinfo)); - - RpcEndSub(th, idinfo); - } - } - if (RPC_srvr_idinfo(th) == NULL && RPC_clnt_idinfo(th) == NULL) { - RPC_LOG_DEBUG("destroy thread info %p", th); - RpcDestroyThreadInfo(); - } -} - -/** @brief RPC library use termination processing (forced cleanup at process termination) - * - * Deletes the socket file created for RPC communication in the process. - * For to release the resources of programs that use the RPC library with RPC_end() in principle, - * but this API is an insurance process to eliminate socket file leaks. - * - * - Since it is assumed that the socket is called immediately before the process terminates, - * closing sockets and releasing memory is not performed automatically when the process terminates. - * - All RPC processing (both server and client) after this API call cannot be used. - * Operation is not guaranteed even if RPC_START is performed again after that. - * - * No action for versions of the RPC library that use Unix autobind. - */ - void -RPC_end_all(void) { -#if !defined(RPC_USE_UNIX_AUTOBIND) - RpcUnlinkSocketFiles(); -#endif -} - -/** - * @fn RPC_Result RPC_set_API_timeout(RPC_ID id, UINT32 sec) - * @brief Setting the timeout period during server API processing - * - * @param sec [IN] Timeout (sec) Set within the range of 1 to 60 sec. - * - * @retval RPC_OK: normal completion - * @retval RPC_ERR_Configuration: Argument out of range - * @retval RPC_ERR_Fatal: Fatal error - */ - RPC_Result -RPC_set_API_timeout(INT32 sec) { - /* param check */ - if ((sec > 60) || (sec < 1)) { - RPC_LOG_ERR( "RPC_set_API_timeout() : Invalid Param." ); - return RPC_ERR_Configuration; - } - - /* thread_info check */ - RpcThreadInfo *th = RpcMyThreadInfo(); - THREAD_INFO_CHECK(th); - - /* thread_info->id_info check */ - if (RPC_srvr_idinfo(th) != NULL ) { // LCOV_EXCL_BR_LINE 200: server start abnormal can't test - RpcIdInfo *idinfo = RPC_srvr_idinfo(th); - - /* thread_info->id_info->apicall_info check */ - if( RPC_apicall_info(idinfo) != NULL ) { // LCOV_EXCL_BR_LINE 200: server start abnormal can't test - RPC_apicall_api_timeout_sec(idinfo) = sec; - } else { // LCOV_EXCL_START 200: server start abnormal can't test - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - RPC_LOG_ERR( "No apicall_info" ); - return RPC_ERR_Fatal; - } - - } else { - RPC_LOG_STATE("No srvr_id info"); - return RPC_ERR_Fatal; - } // LCOV_EXCL_STOP - return RPC_OK; -} - - -/** @brief API call execution function (client side) - * - * (These functions are called from within a client-facing STUB. Users never use these directly.) - */ - RPC_Result -RPC_API_call(RPC_ID server, UINT16 api_num, - const char *args_string, unsigned int args_size, - char **ret_string, unsigned int *ret_size) { - *ret_string = NULL; - - RpcThreadInfo *th = RpcMyThreadInfo(); - - THREAD_INFO_CHECK(th); - - RpcIdInfo *idinfo; - idinfo = RPC_clnt_idinfo(th); - - pid_t srvr_pid; - - if (idinfo == NULL) { // LCOV_EXCL_BR_LINE 8: dead code, idinfo always isn't NULL - /* - * In the past, the remedy of uninitialized clients has been done here. - * However, because it becomes to accumulate garbage in the /tmp/RPC by changing UNIX sockets, - * as an error without remedies. - */ - // LCOV_EXCL_START 8: dead code, idinfo always isn't NULL - RPC_LOG_ERR_W_NAME("warning!!! RPC call without RPC_start(): server=%d, api_num=%d", server, api_num); - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert -#if defined(RPC_USE_UNIX_AUTOBIND) - RPC_ID id = RPC_NO_ID; - RPC_Result ret = CreateClientIdinfo(th, &id); -#else /* !AUTOBIND */ - int id; - id = FindUniqClientId(); - if (id < 0) { - return RPC_ERR_Fatal; - } - RPC_Result ret = CreateClientIdinfo(th, (UINT16)id); -#endif /* !AUTOBIND */ - if (ret != RPC_OK) { - return ret; - } - idinfo = RPC_clnt_idinfo(th); - if (idinfo == NULL) { - return RPC_ERR_Fatal; - } - } // LCOV_EXCL_STOP - - char api_head[RPC_APICALL_FORMAT_ARGS_START + 1]; - sprintf(api_head, RPC_APICALL_FORMAT, api_num); - - rpc_send_buf sendbuf[2]; - sendbuf[0].buf = api_head; - sendbuf[0].bytes = RPC_APICALL_FORMAT_ARGS_START; - if (args_size > 0) { - sendbuf[1].buf = args_string; - sendbuf[1].bytes = args_size; - } - - int seq_num; - -send_api_call: - seq_num = RpcSendUdp2(idinfo, server, - (api_num == RPC_API_NUM_RPC_ALIVE - ? RPC_SEND_TO_SERVER_NO_RETRY - : RPC_SEND_TO_SERVER), - RPC_PACKET_APICALL, - (args_size > 0) ? 2 : 1, sendbuf); - if (seq_num < 0) { - return RPC_ERR_No_Response; - } - - // wait for response - UINT16 response; - RPC_Result result = RpcClientWaitResponse(idinfo, (UINT32)seq_num, Response_wait_msec, - &response); - if (result != RPC_OK) { - return result; - } - - if (response == RPC_RESPONSE_API_BUSY) { /* Server is busy */ - return RPC_ERR_Busy; - } else if (response == RPC_RESPONSE_API_ERR) { /* API call error */ - RPC_LOG_STATE("APIcall error (can't queue)"); - return RPC_ERR_Fatal; - } else if (response == RPC_RESPONSE_API_DEADLOCK) { /* Server is in deadlock */ - RPC_LOG_STATE("server DeadLock."); - return RPC_ERR_Server_DeadLock; - } else if (response == RPC_RESPONSE_API_CERTIFY) { /* Authentication request */ - struct sockaddr_un srvr_sa_un, secure_sa_un; - socklen_t srvr_sa_len, secure_sa_len; - int secure_sock_un; - - /* Create client socket for authentication */ - memset(&secure_sa_un, 0, sizeof(secure_sa_un)); - secure_sa_un.sun_family = AF_UNIX; - secure_sock_un = socket(PF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0); - RpcSetClientSecureName(secure_sa_un.sun_path, RPC_port(idinfo)); - secure_sa_len = (socklen_t)(sizeof(secure_sa_un.sun_family) + SECURE_SOCK_NAME_LEN); - if (bind(secure_sock_un, (struct sockaddr *)&secure_sa_un, secure_sa_len) < 0) { - RPC_LOG_PERROR("STREAM : bind(unix), ID:%#x", RPC_port(idinfo)); - } - idinfo->secure_sock = secure_sock_un; - - /* Destination Server Socket Setting */ - memset(&srvr_sa_un, 0, sizeof(srvr_sa_un)); - srvr_sa_un.sun_family = AF_UNIX; - RpcSetServerSecureName(srvr_sa_un.sun_path, server); - srvr_sa_len = (socklen_t)(sizeof(srvr_sa_un.sun_family) + SECURE_SOCK_NAME_LEN); - - /* Connection */ - int cr = connect(RPC_my_secure_sock(idinfo), (struct sockaddr *)&srvr_sa_un, srvr_sa_len); - if (0 > cr) { - RPC_LOG_STATE("client connect() is failed."); - return RPC_ERR_Fatal; - } - - /* Waiting for server authentication */ - RPC_Result ret_certify = RpcClientWaitCertification(idinfo, &srvr_pid); - close(RPC_my_secure_sock(idinfo)); - if (RPC_OK != ret_certify) {/* Authentication NG */ - RPC_LOG_STATE("denied the connection."); - return ret_certify; - } - - /* inotify monitoring of server processes */ - char intfy_fname[32]; - snprintf(intfy_fname, sizeof(intfy_fname), CL_INTFY_FILENAME_FORMAT, srvr_pid); - int wd = inotify_add_watch(RPC_clnt_inotify_fd(idinfo), intfy_fname, IN_DELETE_SELF); - if (0 > wd) { - RPC_LOG_STATE("intfy_fname is Not Found [%s].", intfy_fname); - } - - /* Register the communication destination server PID in the management table. */ - if (RPC_OK != RpcRegistSrvrPid(idinfo, server, srvr_pid, wd)) { - return RPC_ERR_Fatal; - } - goto send_api_call; /* Sending the API request again */ - - } else if (response == RPC_RESPONSE_NONE) { // LCOV_EXCL_BR_LINE 8: dead code, not implement - // Not implemented to cancel processing - // LCOV_EXCL_START 8: dead code, not implement - RPC_LOG_STATE("No response for API call"); - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - return RPC_ERR_No_Response; - } // LCOV_EXCL_STOP - - // When the server ALIVE is queried, no result is returned, so return here - if (api_num == RPC_API_NUM_RPC_ALIVE) { - return RPC_OK; - } - - // API call is accepted at server - // now wait for the return packet - result = RpcClientWaitResult(idinfo, server); - if (result != RPC_OK) { - RpcDiscardAPIcallReturn(idinfo); - return result; - } - - /****** Function error and return value must be handled separately *******/ - UINT8 *return_str = RPC_apicall_return_str(idinfo); /* pgr0689 */ -#ifdef APICALL_RETURN_TIMEOUT - if (return_str == NULL) { - RPC_LOG_STATE("APIcall return timeout"); - return RPC_ERR_No_Response; - } -#else - rpc_assert(return_str != NULL); // LCOV_EXCL_BR_LINE 6: double check -#endif - - RPC_THREAD_MUTEX_LOCK(idinfo->thread_info); - - *ret_string = rpc_malloc(RPC_apicall_return_str_len(idinfo)); - if (*ret_string != NULL) { // LCOV_EXCL_BR_LINE 5: fail safe for libc malloc - if (ret_size) { - *ret_size = RPC_apicall_return_str_len(idinfo); - } - memcpy(*ret_string, RPC_apicall_return_str(idinfo), - RPC_apicall_return_str_len(idinfo)); - } else { - RPC_LOG_STATE("APIcall: No Memory"); // LCOV_EXCL_START 5: fail safe for libc malloc - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - result = RPC_ERR_Fatal; - } // LCOV_EXCL_STOP - RPC_THREAD_MUTEX_UNLOCK(idinfo->thread_info); - RpcDiscardAPIcallReturn(idinfo); - - return result; -} - -/** @brief Releasing allocated memory while API call is processing - * - * (These functions are called from within a client-facing STUB. Users never use it directly.) - */ - void -RPC_free_return_string(void *ptr) { - if (ptr != NULL) { - rpc_free(ptr); - } -} - -/** @brief Retrieving file descriptors for determining whether RPC-API calls are requested - * - * - This function returns a file descriptor used to determine whether or not there is a request to the server. - * - For the FD returned by this function, Don't use the other way than the FD specified - * in the poll or select parameter. - * - Intended use - * - Obtain FD using this function. - * - Wait for data to arrive by poll or select. - * - Call RPC_process_API_request() when data arrived. - * - This procedure performs handling request of the API call from the client. - * (Server-side API function is executed.) - * - * @param id [IN]RPC_ID of the server program. - * @param fd [OUT]Storage of file descriptor - * - * @retval RPC_OK: normal completion - * @retval Otherwise: Abnormal termination (FATAL) - * @see RPC_process_API_request - */ - RPC_Result -RPC_get_fd(RPC_ID id, int *fd) { - if ((id == RPC_NO_ID) || (fd == NULL)) { - return RPC_ERR_Fatal; - } - rpc_assert(fd != NULL); // LCOV_EXCL_BR_LINE 6: double check - - RpcThreadInfo *th = RpcMyThreadInfo(); - - THREAD_INFO_CHECK(th); - - SUB_THREAD_CHECK(); // LCOV_EXCL_BR_LINE 15: macro define in rpc_lib.c - - RpcIdInfo *idinfo = RPC_srvr_idinfo(th); - - rpc_assert(idinfo != NULL && RPC_my_id(idinfo) == id); // LCOV_EXCL_BR_LINE 6: double check - - *fd = RPC_pipe_sub_main(th)[PIPE_READ]; - - return RPC_OK; -} - -/** API Call Request Handling -*/ - static RPC_Result -ProcessAPIcallRequest(RpcIdInfo *idinfo, RPC_ID client, UINT16 api_num, - char *args_string, unsigned int args_size) { - /* ---------------------------- - * call API dispatch function - * ---------------------------- - */ - - /* API Running Client RPC_ID Setting */ - RPC_apicall_in_process_client(idinfo) = client; - - char *ret_string = NULL; - unsigned int ret_size = 0; - RPC_dispatch_func_t dispatch = RPC_apicall_dispatch_func(idinfo); - rpc_assert(dispatch != NULL); // LCOV_EXCL_BR_LINE 6: double check - RPC_Result api_ret; - api_ret = dispatch(api_num, args_string, args_size, &ret_string, &ret_size); /* pgr0060 */ - - unsigned char retcode[RPC_RETCODE_LEN+1]; - sprintf((char *)retcode, "%08x ", api_ret); - - rpc_send_buf sendbuf[2]; - sendbuf[0].buf = retcode; - sendbuf[0].bytes = sizeof(retcode) - 1; - - int seq_num; - - if (ret_string != NULL) { - sendbuf[1].buf = ret_string; - sendbuf[1].bytes = ret_size; - seq_num = RpcSendUdp2(idinfo, client, RPC_SEND_TO_CLIENT, - RPC_PACKET_APIRETURN, 2, sendbuf); - } else { - seq_num = RpcSendUdp2(idinfo, client, RPC_SEND_TO_CLIENT, - RPC_PACKET_APIRETURN, 1, sendbuf); - } - RPC_marshall_free(1, ret_string); - - if (seq_num < 0) { - RPC_LOG_ERR("send result failed!"); - return RPC_ERR_Fatal; - } - - /* Set API Running Client RPC_ID to None */ - RPC_apicall_in_process_client(idinfo) = RPC_NO_PORT; - - /* Sleep API-processing entries */ - RPC_THREAD_MUTEX_LOCK(idinfo->thread_info); - CL_MonitorSetEntry(CL_MONITOR_TYPE_RPC, RPC_port(idinfo), - CL_MONITOR_STATE_SLEEP, 0, 0); - RPC_THREAD_MUTEX_UNLOCK(idinfo->thread_info); - - return api_ret; -} - -/** @brief Executing RPC-API calls - * - * Process all queued API execution requests from clients. - * The API function of the server program is called from here. - * If there is no API execution request, the system returns normally immediately without waiting. - * - * @param id [IN]RPC_ID of the server program - * @retval RPC_OK: normal completion - * @retval Otherwise: Fatal errors - */ - RPC_Result -RPC_process_API_request(RPC_ID id) { - if (id == RPC_NO_ID) { - return RPC_ERR_Fatal; - } - RpcThreadInfo *th = RpcMyThreadInfo(); - - THREAD_INFO_CHECK(th); - - SUB_THREAD_CHECK(); - - RpcIdInfo *idinfo = RPC_srvr_idinfo(th); - - rpc_assert(idinfo != NULL && id == RPC_my_id(idinfo)); // LCOV_EXCL_BR_LINE 6: double check - - rpc_assert(RPC_apicall_info(idinfo) != NULL /* pgr0689 */ // LCOV_EXCL_BR_LINE 6: double check - && RPC_apicall_dispatch_func(idinfo) != NULL); // LCOV_EXCL_BR_LINE 6: double check - - char c; - read(RPC_pipe_sub_main(th)[PIPE_READ], &c, sizeof(c)); - - /* Process all API calls here */ - UINT16 api_num; - RPC_ID client = RPC_NO_PORT; - RPC_Result result = RPC_OK; - char *args_string; - unsigned int args_size; - do { - api_num = RpcGetAPIRequest(idinfo, &client, - &args_string, &args_size); - - if (api_num > 0) {/* API calls were queued */ - result = ProcessAPIcallRequest(idinfo, client, api_num, - args_string, args_size); - - RpcFreeAPIArgsString(args_string); - - if (result == RPC_ERR_API_Fatal || result == RPC_ERR_Fatal) { - break; - } else { - result = RPC_OK; - } - } - } while(api_num > 0); - - return result; -} - -/** @brief Returns the operational state of the RPC server - * - * Returns whether or not the server with the specified RPC_ID is running. - * - * @param id [IN]RPC_ID of the server program - * @retval RPC_OK: Running - * @retval RPC_ERR_No_Response: Server is not running - */ - RPC_Result -RPC_is_server_ready(RPC_ID id) { -#if defined(RPC_USE_UNIX_AUTOBIND) - char *ret_string = NULL; - unsigned int ret_size; - RPC_Result ret; - - // Invoke Internal-API Calls for Server ALIVE Queries - ret = RPC_API_call(id, RPC_API_NUM_RPC_ALIVE, NULL, 0, - &ret_string, &ret_size); - RPC_free_return_string(ret_string); - - return ret; -#else /* !AUTOBIND */ - struct stat statbuf; - int err; - char sockname[128]; - - /* Check if server socket is created */ - rpc_set_socket_name(sockname, id); - err = stat(sockname, &statbuf); - if (err == 0) { - return RPC_OK; - } else { - return RPC_ERR_No_Response; - } -#endif /* !AUTOBIND */ -} - -/** @brief Registering UIDs and GID Lists - * - * Register a list of UIDs and GIDs that can be accepted by the RPC server. - * A function used by the RPC server after RPC_START_SECURE_SERVER(). - * Return error if called from an RPC client or an RPC server that has not called RPC_START_SECURE_SERVER(). - * - * @param uid_num [IN] Number of registered UIDs (number of elements in UID list array) - * @param *uid_list [IN] Start pointer of registered UID list - * @param gid_num [IN] Number of registered GIDs (number of elements in the array of GID lists) - * @param *gid_list [IN] Start pointer of registered GID list - * @retval RPC_OK: List registration completed - * @retval RPC_ERR_Fatal: Failed to save to list - */ -RPC_Result -RPC_regist_credential(int uid_num, uid_t *uid_list, int gid_num, gid_t *gid_list) { - RpcThreadInfo *th = RpcMyThreadInfo(); - THREAD_INFO_CHECK(th); - - if (NULL == RPC_srvr_idinfo(th)) { - RPC_LOG_ERR("No server thread info"); - return RPC_ERR_Fatal; - } - - RpcIdInfo *idinfo = RPC_srvr_idinfo(th); - if ((NULL == idinfo) || (NULL == RPC_apicall_info(idinfo))) { // LCOV_EXCL_BR_LINE 8: dead code, idinfo always isn't NULL - // LCOV_EXCL_START 8: dead code, idinfo always isn't NULL - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - RPC_LOG_ERR("No RPC_ID info"); - return RPC_ERR_Fatal; - } // LCOV_EXCL_STOP - - /* Neither UID nor GID list is specified. */ - if ((NULL == uid_list) && (NULL == gid_list)) { - RPC_LOG_ERR("RPC_regist_credential() : UID and GID list is NULL."); - return RPC_ERR_Fatal; - } - - /* UID list argument check */ - if ((NULL == uid_list) && ((0 < uid_num ) && (uid_num <= CREDENTIAL_LIST_NUM_MAX))) {/* UID list is invalid */ - RPC_LOG_ERR("RPC_regist_credential() : UID list is illegal."); - return RPC_ERR_Fatal; - } else if ((NULL != uid_list) && ((1 > uid_num) || (uid_num > CREDENTIAL_LIST_NUM_MAX))) {/* Number of UID list elements is invalid */ - RPC_LOG_ERR("RPC_regist_credential() : UID list num is illegal."); - return RPC_ERR_Configuration; - } - - /* GID list argument check */ - if ((NULL == gid_list) && ((0 < gid_num ) && (gid_num <= CREDENTIAL_LIST_NUM_MAX))) {/* GID list is invalid */ - RPC_LOG_ERR("RPC_regist_credential() : GID list is illegal."); - return RPC_ERR_Fatal; - } else if ((NULL != gid_list) && ((1 > gid_num) || (gid_num > CREDENTIAL_LIST_NUM_MAX))) {/* Number of GID list elements is invalid */ - RPC_LOG_ERR("RPC_regist_credential() : GID list num is illegal."); - return RPC_ERR_Configuration; - } - - if (NO_SECURE_CHECK == RPC_secure_check(idinfo)) {/* Return error if registration is not necessary */ - RPC_LOG_ERR("Needless secure check."); - return RPC_ERR_Fatal; - } - - if (REGISTERED == RPC_regist_credential_info(idinfo)) {/* Return error if a list has already been registered */ - RPC_LOG_ERR("credential info has been registered already."); - return RPC_ERR_Fatal; - } - - /* Allocate as many memory areas as there are UID and GID lists */ - RPC_apicall_info(idinfo)->uid_list = rpc_malloc(sizeof(uid_t) * (unsigned int)uid_num); - if (NULL == RPC_apicall_info(idinfo)->uid_list) { // LCOV_EXCL_BR_LINE 5: fail safe for libc malloc - RPC_LOG_ERR("Can't malloc uid_list."); // LCOV_EXCL_START 5: fail safe for libc malloc - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - return RPC_ERR_Fatal; - } // LCOV_EXCL_STOP - RPC_apicall_info(idinfo)->gid_list = rpc_malloc(sizeof(gid_t) * (unsigned int)gid_num); - if (NULL == RPC_apicall_info(idinfo)->gid_list) { // LCOV_EXCL_BR_LINE 5: fail safe for libc malloc - RPC_LOG_ERR("Can't malloc gid_list."); // LCOV_EXCL_START 5: fail safe for libc malloc - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - return RPC_ERR_Fatal; - } // LCOV_EXCL_STOP - - /* Copy UID and GID registration list and number of elements */ - memcpy(RPC_apicall_info(idinfo)->uid_list, uid_list, sizeof(uid_t) * (unsigned int)uid_num); /* UID list */ - memcpy(RPC_apicall_info(idinfo)->gid_list, gid_list, sizeof(gid_t) * (unsigned int)gid_num); /* GID list */ - RPC_uid_num(idinfo) = uid_num; /* Number of elements in the UID list */ - RPC_gid_num(idinfo) = gid_num; /* Number of elements in the GID list */ - - /* Set whether to register authentication information to Yes/No */ - RPC_regist_credential_info(idinfo) = REGISTERED; - - return RPC_OK; -} - -/** @brief Obtain authentication info (UID, GID) of API requesting client - * - * Obtain the UID and GID of the client that requested the API processing being executed. - * Return error if called from an RPC client or to an RPC server that has not called RPC_START_SECURE_SERVER(). - * This function should be called within an API function (in other words, API is being executed) provided to the client. - * if called the other function, error is returned because there is no API being executed. - * - * @param *client_uid [OUT] Requesting client UID of running API - * @param *client_gid [OUT] Requesting client GID of running API - * @retval RPC_OK: Succeeded to obtain of authentication info - * @retval RPC_ERR_Fatal: Failed to obtain of authentication Info - */ -RPC_Result -RPC_get_client_credential(uid_t *client_uid, gid_t *client_gid) { - RpcThreadInfo *th = RpcMyThreadInfo(); - THREAD_INFO_CHECK(th); - - if (NULL == RPC_srvr_idinfo(th)) { - RPC_LOG_ERR("No server thread info"); - return RPC_ERR_Fatal; - } - - RpcIdInfo *idinfo = RPC_srvr_idinfo(th); - if ((NULL == idinfo) || (NULL == RPC_apicall_info(idinfo))) { // LCOV_EXCL_BR_LINE 8: dead code, idinfo always isn't NULL - // LCOV_EXCL_START 8: dead code, idinfo always isn't NULL - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - RPC_LOG_ERR("No RPC_ID info"); - return RPC_ERR_Fatal; - } // LCOV_EXCL_STOP - - if ((NULL == client_uid) || (NULL == client_gid)) {/* Argument check */ - RPC_LOG_ERR("RPC_regist_credential() : Invalid Param."); - return RPC_ERR_Fatal; - } - - if (NO_SECURE_CHECK == RPC_secure_check(idinfo)) {/* Return error if no security */ - RPC_LOG_ERR("Needless secure check."); - return RPC_ERR_Fatal; - } - - if (RPC_NO_PORT == RPC_apicall_in_process_client(idinfo)) {/* Return error if the API is not being executed */ - RPC_LOG_ERR("NOT in process APIcall."); - return RPC_ERR_Fatal; - } - - char buf[7], client_path_name[SOCK_NAME_LEN]; /* Client socket name */ - - /* Converting client_id to the socket name associated with RPC_ID */ - RpcSetClientName(buf, RPC_apicall_in_process_client(idinfo)); - memcpy(client_path_name, buf + 1, 5); - client_path_name[5] = '\0'; - RpcClientSockNameInfo *current = RPC_sock_info_head(idinfo); - - /* Search info of running client from the management table */ - while (NULL != current) { - if (0 == strcmp(current->client_sock_name, client_path_name)) {/* Match Running Client Info */ - *client_uid = current->uid; - *client_gid = current->gid; - return RPC_OK; - } - current = current->next; - } - RPC_LOG_ERR("Nothing client credential info."); - return RPC_ERR_Fatal; /* Not found Client info */ -} - -/** @brief Waiting for server authentication - * - * When a client requests an API to the server, - * wait for the server to check whether it is allowed to communicate. - * - * @param *idinfo [IN] Information associated with the client's RPC_ID - * - * @retval RPC_OK: Authentication OK (communication with the server is permitted) - * @retval RPC_ERR_Reject_connect: Authentication NG (Communication denied) - */ -static RPC_Result -RpcClientWaitCertification(RpcIdInfo *idinfo, pid_t *srvr_pid) { - fd_set fds; - RpcCertifyResult recv_ret; /* Authentication result from the server */ - RPC_Result ret = RPC_ERR_Fatal; - - for(;;) { - FD_ZERO(&fds); - FD_SET(RPC_my_secure_sock(idinfo), &fds); - - int sret = select(RPC_my_secure_sock(idinfo) + 1, &fds, NULL, NULL, NULL); - if (sret < 0 && errno == EINTR) {/* signal interrupt */ // LCOV_EXCL_BR_LINE 5: fail safe for libc select - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - continue; // LCOV_EXCL_LINE 5: fail safe for libc select - } else if (sret > 0 && FD_ISSET(RPC_my_secure_sock(idinfo), &fds)) { - /* Check the response from the server */ - ssize_t rret = recv(RPC_my_secure_sock(idinfo), (char*)&recv_ret, sizeof(RpcCertifyResult), 0); - if (0 < rret) { // LCOV_EXCL_BR_LINE 5: fail safe for libc recv - switch(recv_ret.certify_res) { - case CERTIFY_OK: /* OK */ - ret = RPC_OK; - *srvr_pid = recv_ret.srvr_pid; - break; - - case CERTIFY_NG: /* NG */ - ret = RPC_ERR_Reject_connect; - break; - - default: - ret = RPC_ERR_Fatal; - break; - } - goto exit_loop_ok; - } else if(0 == rret) { // LCOV_EXCL_START 5: fail safe for libc recv - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - RPC_LOG_ERR("server process terminate."); - return RPC_ERR_Fatal; - } else { - RPC_LOG_PERROR("certification_wait recv()"); - return RPC_ERR_Fatal; - } // LCOV_EXCL_STOP - } - } -exit_loop_ok: - return ret; -} - -/** @brief Register the PID of the communication destination server in the management table. - * - * Register a pair of the PID and ID of the server in the management table. - * - * @param *idinfo [IN] Information associated with the client's RPC_ID - * @param srvr_rpc_id [IN] RPC_ID of the communication destination server - * @param srvr_pid [IN] PID of the communication destination server - * - * @retval RPC_OK : Registration completed - * @retval RPC_ERR_Fatal : Registration failed - */ -static RPC_Result -RpcRegistSrvrPid(RpcIdInfo *idinfo, RPC_ID srvr_rpc_id, pid_t srvr_pid, int wd) { - if ((NULL == idinfo) || (srvr_rpc_id == RPC_NO_ID) || (0 > srvr_pid)) { // LCOV_EXCL_START 8: dead code, idinfo always isn't NULL - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - RPC_LOG_ERR("RpcRegistSrvrPid() : Invalid Param."); - return RPC_ERR_Fatal; - } // LCOV_EXCL_STOP - - RpcSrvrPidInfo *srvr_pid_buf, *current; - - srvr_pid_buf = rpc_malloc(sizeof(RpcSrvrPidInfo)); - if( srvr_pid_buf == NULL ){ // LCOV_EXCL_START 5: fail safe for libc malloc - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - return RPC_ERR_Fatal; - } // LCOV_EXCL_STOP - - srvr_pid_buf->srvr_rpc_id = srvr_rpc_id; /* Server RPC_ID */ - srvr_pid_buf->srvr_pid = srvr_pid; /* Server PID */ - srvr_pid_buf->wd = wd; /* wd */ - srvr_pid_buf->next = NULL; /* Next node in the communication destination server PID management table */ - - if (0 == RPC_srvr_pid_head(idinfo)) { - RPC_srvr_pid_head(idinfo) = srvr_pid_buf; - } else { - for (current = RPC_srvr_pid_head(idinfo); current->next != NULL; current = current->next) - ; - current->next = srvr_pid_buf; - } - return RPC_OK; -} - -/** @brief Delete Termination Process PID from Management Table - * - * Check whether the terminated process matches the communicating server process, and delete it from the management table. - * - * @param *idinfo [IN] Information associated with the client's RPC_ID - * @param srvr_rpc_id [IN] Currently communicating server RPC_ID - * @param wd [IN] Wd of the termination process - * - * @retval RPC_OK : Deletion completed - * @retval RPC_ERR_Server_Finish: Deletion completed (server process in communication terminated) - * @retval RPC_ERR_Fatal : Argument error - */ - RPC_Result -RpcDeleteSrvrPid(RpcIdInfo *idinfo, RPC_ID srvr_rpc_id, int wd) { - if ((NULL == idinfo) || (RPC_NO_ID == srvr_rpc_id)) { // LCOV_EXCL_START 8: dead code, idinfo always isn't NULL - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - RPC_LOG_ERR("rpc_check_srvr_pid() : Invalid Param."); - return RPC_ERR_Fatal; - } // LCOV_EXCL_STOP - - RPC_Result ret = RPC_OK; - int cnt = 0; - RpcSrvrPidInfo *current, *previous; - current = RPC_srvr_pid_head(idinfo); - - while (NULL != current) { - if (wd == current->wd) { - - /* Check whether the termination process matches the communicating server process */ - if (srvr_rpc_id == current->srvr_rpc_id) { - ret = RPC_ERR_Server_Finish; - } - - /* Delete info from the Server info table */ - if (0 == cnt) {/* Delete the start of the management table */ - RPC_srvr_pid_head(idinfo) = RPC_srvr_pid_head(idinfo)->next; - rpc_free(current); - current = RPC_srvr_pid_head(idinfo); - cnt = -1; - } else {/* Delete all but the first element */ - // LCOV_EXCL_START 8: dead code - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - previous->next = current->next; - rpc_free(current); - current = previous->next; - // LCOV_EXCL_STOP - } - } else { - previous = current; - current = current->next; - } - cnt ++; - } - return ret; -} - -/** @brief Delete all PID management tables of the communication destination server - * - * Releases the PID management table and deletes all data when the client terminates with RPC_end(). - * - * @param *idinfo [IN] Information associated with the client's RPC_ID - * - * @retval RPC_OK : Deletion completed - * @retval RPC_ERR_Fatal : Argument error - */ -static RPC_Result -RpcAllDeleteSrvrPid(RpcIdInfo *idinfo) { - if (NULL == idinfo) { // LCOV_EXCL_BR_LINE 6: double check in rpc_lib.c --> RPC_end() - RPC_LOG_ERR("RpcAllDeleteSrvrPid() : Invalid Param."); // LCOV_EXCL_START 6: double check in rpc_lib.c --> RPC_end() - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - return RPC_ERR_Fatal; - } // LCOV_EXCL_STOP - - RpcSrvrPidInfo *current = RPC_srvr_pid_head(idinfo); - while (NULL != current) { - - if (0 <= current->wd) { - inotify_rm_watch(RPC_clnt_inotify_fd(idinfo), current->wd); - } - - RpcSrvrPidInfo *previous = current; - current = current->next; - - rpc_free(previous); - } - RPC_srvr_pid_head(idinfo) = NULL; - return RPC_OK; -} - -/** @brief Logging RPC-API calling process - * - * Receive File name, function name and line-number of the client calling API and API-function-name, and logging them. - * - * @param filename [IN]Pointer to caller filename string - * @param funcname [IN]Pointer to caller function-name string - * @param line [IN]Line-number in the source file of the client - * @param apiname [IN]Pointer to call-API-function-name string - * @retval 0: normal completion - * @retval Otherwise: Fatal error - */ - int -RPC_record_dbg_log( const char *filename, const char *funcname, int line, - const char *apiname ) { - printf( "[RPC debug log]%s() called from %s() [%s, line %d]\n", - apiname, funcname, filename, line ); - return 0; -} - -/** @}*/ |