diff options
Diffstat (limited to 'otherservice/rpc_library/library/src/rpc_lib.c')
| -rw-r--r-- | otherservice/rpc_library/library/src/rpc_lib.c | 1264 |
1 files changed, 1264 insertions, 0 deletions
diff --git a/otherservice/rpc_library/library/src/rpc_lib.c b/otherservice/rpc_library/library/src/rpc_lib.c new file mode 100644 index 00000000..b77775fd --- /dev/null +++ b/otherservice/rpc_library/library/src/rpc_lib.c @@ -0,0 +1,1264 @@ +/* + * @copyright Copyright (c) 2016-2019 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; +} + +/** @}*/ |