From 8e57c8bb986da92aae6da2b8ef2bfce86629966b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=A7=9C=E5=A4=A9=E7=90=AA?= Date: Wed, 24 May 2023 11:22:42 +0000 Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E7=83=AD=E8=BF=81=E7=A7=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 姜天琪 --- .../container-mig/gpworker_tzcp_dbus.c | 23273 ++++++++++++++++ 1 file changed, 23273 insertions(+) create mode 100644 cc-resource-pooling/container-mig/gpworker_tzcp_dbus.c diff --git a/cc-resource-pooling/container-mig/gpworker_tzcp_dbus.c b/cc-resource-pooling/container-mig/gpworker_tzcp_dbus.c new file mode 100644 index 0000000..0a52182 --- /dev/null +++ b/cc-resource-pooling/container-mig/gpworker_tzcp_dbus.c @@ -0,0 +1,23273 @@ +/* + * Using low-level D-Bus C API code. + * Written by + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "tzcp_dbus.h" + +#ifdef GP_PROXY_WORKER + +#include "threadpool.h" + +#ifdef GP_WORKER + +#include "tee_client_api.h" +#include "tee_client_list.h" + +#endif +#endif + +/** + * Listens for signals on the bus + */ +void +receive_signal(void) +{ + DBusMessage *msg; + DBusMessageIter args; + DBusConnection *conn; + DBusError err; + int ret; + char *sigvalue; + + printf("Listening for signals\n"); + + // initialise the errors + dbus_error_init(&err); + + // connect to the bus and check for errors + conn = dbus_bus_get(DBUS_BUS_SESSION, &err); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Connection Error (%s)\n", err.message); + dbus_error_free(&err); + } + if (NULL == conn) + { + exit(1); + } + + // request our name on the bus and check for errors + ret = dbus_bus_request_name(conn, "test.signal.sink", DBUS_NAME_FLAG_REPLACE_EXISTING, &err); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Name Error (%s)\n", err.message); + dbus_error_free(&err); + } + if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) + { + exit(1); + } + + // add a rule for which messages we want to see + dbus_bus_add_match(conn, "type='signal',interface='test.signal.Type'", &err); + // see signals from the given interface + dbus_connection_flush(conn); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Match Error (%s)\n", err.message); + exit(1); + } + // printf("Match rule sent\n"); + + // loop listening for signals being emmitted + while (true) + { + // non blocking read of the next available message + dbus_connection_read_write(conn, 0); + msg = dbus_connection_pop_message(conn); + + // loop again if we haven't read a message + if (NULL == msg) + { + usleep(10000); + continue; + } + + // check if the message is a signal from the correct interface and with the correct name + if (dbus_message_is_signal(msg, "test.signal.Type", "Test")) + { + + // read the parameters + if (!dbus_message_iter_init(msg, &args)) + fprintf(stderr, "Message Has No Parameters\n"); + else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) + fprintf(stderr, "Argument is not string!\n"); + else + dbus_message_iter_get_basic(&args, &sigvalue); + + printf("Got Signal with value %s\n", sigvalue); + } + + // free the message + dbus_message_unref(msg); + } +} + + +/** + * Connect to the DBUS bus and send a broadcast signal + */ +void +send_signal( + char *sigvalue +) +{ + DBusMessage *msg; + DBusMessageIter args; + DBusConnection *conn; + DBusError err; + int ret; + dbus_uint32_t sigserial = 0; + + printf("Sending signal with value %s\n", sigvalue); + + // initialise the error value + dbus_error_init(&err); + + // connect to the DBUS system bus, and check for errors + conn = dbus_bus_get(DBUS_BUS_SESSION, &err); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Connection Error (%s)\n", err.message); + dbus_error_free(&err); + } + if (NULL == conn) + { + exit(1); + } + + // register our name on the bus, and check for errors + ret = dbus_bus_request_name(conn, "test.signal.source", DBUS_NAME_FLAG_REPLACE_EXISTING, &err); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Name Error (%s)\n", err.message); + dbus_error_free(&err); + } + if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) + { + exit(1); + } + + // create a signal & check for errors + msg = dbus_message_new_signal("/test/signal/Object", // object name of the signal + "test.signal.Type", // interface name of the signal + "Test"); // name of the signal + if (NULL == msg) + { + fprintf(stderr, "Message Null\n"); + exit(1); + } + + // append arguments onto signal + dbus_message_iter_init_append(msg, &args); + if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &sigvalue)) + { + fprintf(stderr, "Out Of Memory!\n"); + exit(1); + } + + // send the message and flush the connection + if (!dbus_connection_send(conn, msg, &sigserial)) + { + fprintf(stderr, "Out Of Memory!\n"); + exit(1); + } + dbus_connection_flush(conn); + + printf("Signal Sent\n"); + + // free the message + dbus_message_unref(msg); +} + +int errno = -1; +int tcl_flag = 0; +uint32_t lt_session_id[128] = {0}; +int32_t lt_fd[128] = {0}; + +// 将tcl_t写入文件 +int store_context(tcl_t *tcl,TEEC_Context *context,tcn_t *tcnIns,int id,tsl_t *tsl) { + char filename[20]; + sprintf(filename, "tcl_%d.bin", id); + FILE *fp = fopen(filename, "wb"); + if (fp == NULL) { + printf("Error opening file %s.\n", filename); + return -1; + } + int ret = 0; + ret = fwrite(&context->fd, sizeof(int32_t), 1, fp); + if (ret != 1) { + printf("Failed to write tcl_t count to file: %s\n", strerror(errno)); + return -1; + } + printf(" context->fd = 0x %8.8x \n", context->fd); + + /* int32_t context_tapath_size = strlen((const char *)context->ta_path); + ret = fwrite(&context_tapath_size, sizeof(int32_t), 1, fp); + if (ret != 1) { + printf("Failed to write tcl_t count to file: %s\n", strerror(errno)); + return -1; + } + printf(" context->ta_path_size = %d \n", context_tapath_size); + + ret = fwrite(context->ta_path, context_tapath_size, 1, fp); + if (ret != 1) { + printf("Failed to write tcl_t count to file: %s\n", strerror(errno)); + return -1; + } + printf(" context->ta_path = %s \n", context->ta_path); + + printf(" session_list_prev = 0x %16.16lx \n", context->session_list.prev); + printf(" shrd_mem_list_next = 0x %16.16lx \n", context->shrd_mem_list.next); + printf(" shrd_mem_list_prev = 0x %16.16lx \n", context->shrd_mem_list.prev); + printf(" share_buffer_buffer = 0x %16.16lx \n", context->share_buffer.buffer); + printf(" share_buffer_buffer_barrier = 0x %16.16lx \n", context->share_buffer.buffer_barrier.__align); + */ + + ret = fwrite(&context->session_list, sizeof(struct ListNode), 1, fp); + if (ret != 1) { + printf("Failed to write tcl_t count to file: %s\n", strerror(errno)); + return -1; + } + + ret = fwrite(&context->shrd_mem_list, sizeof(struct ListNode), 1, fp); + if (ret != 1) { + printf("Failed to write tcl_t count to file: %s\n", strerror(errno)); + return -1; + } + + ret = fwrite(&context->share_buffer.buffer, sizeof(dbus_uint64_t), 1, fp); + if (ret != 1) { + printf("Failed to write tcl_t count to file: %s\n", strerror(errno)); + return -1; + } + + ret = fwrite(&context->share_buffer.buffer_barrier.__align, sizeof(dbus_int64_t), 1, fp); + if (ret != 1) { + printf("Failed to write tcl_t count to file: %s\n", strerror(errno)); + return -1; + } + + if(tsl->count == 0){ + printf("tcn clean sessionid = 0x %8.8x \n",id); + tcn_t *lttcnTemp; + lttcnTemp = tcnIns->prev; + if (lttcnTemp != NULL) + { + lttcnTemp->next = tcnIns->next; + } + lttcnTemp = tcnIns->next; + if (lttcnTemp != NULL) + { + lttcnTemp->prev = tcnIns->prev; + } + if (tcl->last == tcnIns) + { + tcl->last = tcnIns->prev; + } + if (tcl->first == tcnIns) + { + tcl->first = tcnIns->next; + } + } + +/* for(int i = 0; i < 128; i++) + { + if(lt_fd[i] == 0) + lt_fd[i] = context->fd; + } + tcl->count = tcl->count - 1;*/ + + fclose(fp); + //printf("tzc %d\n",__LINE__); + tcl_flag = 0; + return 0; +} +// 读取tcl_t +int load_tcl(tcl_t *tcl,tcn_t *tcnIns,int id) { + printf("load tcl start\n"); + char filename[20]; + sprintf(filename, "tcl_%d.bin", id); + FILE *fp = fopen(filename, "rb"); + if (fp == NULL) { + printf("Error opening file %s.\n", filename); + return -1; + } + int ret = 0; + + ret = fread(&tcnIns->self->fd, sizeof(int32_t), 1, fp); + if (ret != 1) { + printf("Failed to write tcl_t count to file: %s\n", strerror(errno)); + return -1; + } + printf(" context->fd = 0x %8.8x \n", tcnIns->self->fd); + +/* int32_t context_tapath_size; + ret = fread(&context_tapath_size, sizeof(int32_t), 1, fp); + printf(" context->ta_path_size = 0x %8.8x \n", context_tapath_size); + + ret = fread(&tcnIns->self->ta_path, context_tapath_size, 1, fp); + if (ret != 1) { + printf("Failed to write tcl_t count to file: %s\n", strerror(errno)); + return -1; + }*/ + + ret = fread(&tcnIns->self->session_list, sizeof(struct ListNode), 1, fp); + if (ret != 1) { + printf("Failed to write tcl_t count to file: %s\n", strerror(errno)); + return -1; + } + + ret = fread(&tcnIns->self->shrd_mem_list, sizeof(struct ListNode), 1, fp); + if (ret != 1) { + printf("Failed to write tcl_t count to file: %s\n", strerror(errno)); + return -1; + } + + ret = fread(&tcnIns->self->share_buffer.buffer, sizeof(dbus_uint64_t), 1, fp); + if (ret != 1) { + printf("Failed to write tcl_t count to file: %s\n", strerror(errno)); + return -1; + } + + ret = fread(&tcnIns->self->share_buffer.buffer_barrier.__align, sizeof(dbus_int64_t), 1, fp); + if (ret != 1) { + printf("Failed to write tcl_t count to file: %s\n", strerror(errno)); + return -1; + } + + /*printf(" context->ta_path = %s \n", tcnIns->self->ta_path); + printf(" session_list_prev = 0x %16.16lx \n", tcnIns->self->session_list.prev); + printf(" shrd_mem_list_next = 0x %16.16lx \n", tcnIns->self->shrd_mem_list.next); + printf(" shrd_mem_list_prev = 0x %16.16lx \n", tcnIns->self->shrd_mem_list.prev); + printf(" share_buffer_buffer = 0x %16.16lx \n", tcnIns->self->share_buffer.buffer); + printf(" share_buffer_buffer_barrier = 0x %16.16lx \n", tcnIns->self->share_buffer.buffer_barrier.__align);*/ + + if (tcl->first == NULL) + { + tcnIns->next = NULL; + tcnIns->prev = NULL; + tcl->first = tcnIns; + tcl->last = tcnIns; + tcl->count = 1; + } else + { + tcnIns->prev = tcl->last; + tcnIns->next = NULL; + tcl->last->next = tcnIns; + tcl->last = tcnIns; + tcl->count = tcl->count + 1; + } + + struct timeval tvcreate; + gettimeofday(&tvcreate, NULL); + tcnIns->createtime = tvcreate; + fclose(fp); + tcl_flag = 1; + if (remove(filename) != 0){ + printf("session %d remove_tcl error\n",id); + } + + return 0; +} + +// 将tsn写入文件 +int store_tsl(tsl_t *tsl,tsn_t *tsnIns) { + tsn_t *tsnTemp; + tsnTemp = tsnIns->prev; + if (tsnTemp != NULL) + { + tsnTemp->next = tsnIns->next; + } + tsnTemp = tsnIns->next; + if (tsnTemp != NULL) + { + tsnTemp->prev = tsnIns->prev; + } + if (tsl->last == tsnIns) + { + tsl->last = tsnIns->prev; + } + if (tsl->first == tsnIns) + { + tsl->first = tsnIns->next; + } + tsl->count = tsl->count - 1; + if(tsl->count == 0){ + tsl->first = NULL; + tsl->last = NULL; + } + //free(sessionIns); +/* for(int i = 0; i < 128; i++) + { + if(lt_session_id[i] == 0) + lt_session_id[i] = tsnIns->self->session_id; + }*/ + + return 0; +} +// 读取tsl_t +int load_tsl(tsl_t *tsl,tsn_t *tsnIns,tcn_t *tcnIns,TEEC_Session *sessionIns,int id) { + tsnIns->self = sessionIns; + tsnIns->self->session_id = id; + tsnIns->self->context = tcnIns->self; + struct timeval tvcreate; + gettimeofday(&tvcreate, NULL); + tsnIns->createtime = tvcreate; + if (tsl->first == NULL) + { + tsnIns->next = NULL; + tsnIns->prev = NULL; + tsl->first = tsnIns; + tsl->last = tsnIns; + tsl->count = 1; + } else + { + tsnIns->prev = tsl->last; + tsnIns->next = NULL; + tsl->last->next = tsnIns; + tsl->last = tsnIns; + tsl->count = tsl->count + 1; + } + tsnIns = tsl->first; + while(tsnIns != NULL){ + printf("load tsnIns->self->session_id = 0x %8.8x \n",tsnIns->self->session_id); + printf("tsnIns->self = %p \n",tsnIns->self); + tsnIns = tsnIns->next; + } + //tsl->count = tsl->count + 1; + + printf("load_tsl successed 0x %8.8x\n",id); + return 0; +} + + +#ifdef GP_PROXY_WORKER +/** + * Server that exposes a method call and waits for it to be called + */ +void +receive_methodcall( + threadpool_t *pool, + pthread_mutex_t *mutex_tcl, + pthread_mutex_t *mutex_tsl, + tcl_t *tcl, + tsl_t *tsl, + char *workername +) +{ + DBusMessage *msg; + DBusConnection *conn; + DBusError err; + int ret; + dbus_bool_t bResult; + + threadpool_init(pool, +#ifdef GP_PROXY + MAX_NUM_THREAD + 2 +#endif +#ifdef GP_WORKER + MAX_NUM_THREAD, tcl, tsl +#endif + ); + +#ifdef GP_WORKER + pthread_mutex_init(mutex_tcl, NULL); + pthread_mutex_init(mutex_tsl, NULL); +#endif + +#ifdef GP_PROXY + pthread_mutex_init(mutex_workerrec, NULL); + pthread_cond_init(cond_notbusy, NULL); + for (int iworker = 0; iworker < MAX_NUM_WORKER; iworker++) + { + workerrec[iworker].busy = 0; + workerrec[iworker].context_fd = 0; + // workerrec[iworker].context_addr = 0; + workerrec[iworker].context_addr = 0xffffffff; + workerrec[iworker].sessionid_count = 0; + workerrec[iworker].first = NULL; + workerrec[iworker].last = NULL; + } + + DBusMsgConn* thdfargs_stp = (DBusMsgConn*)malloc(sizeof(DBusMsgConn)); + thdfargs_stp->mutex_workerrec = mutex_workerrec; + thdfargs_stp->workerrec = workerrec; + threadpool_add_task( + pool, + session_timeout_process, + thdfargs_stp + ); + + DBusMsgConn* thdfargs_ctp = (DBusMsgConn*)malloc(sizeof(DBusMsgConn)); + thdfargs_ctp->mutex_workerrec = mutex_workerrec; + thdfargs_ctp->workerrec = workerrec; + thdfargs_ctp->cond_notbusy = cond_notbusy; + threadpool_add_task( + pool, + context_timeout_process, + thdfargs_ctp + ); +#endif + + printf("%s is listening for method calls ... \n", workername); + + // initialise the error + dbus_error_init(&err); + + dbus_threads_init_default(); + + // connect to the bus and check for errors + conn = dbus_bus_get(DBUS_BUS_SESSION, &err); + // conn = dbus_bus_get_private(DBUS_BUS_SESSION, &err); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Connection Error (%s)\n", err.message); + dbus_error_free(&err); + } + if (NULL == conn) + { + fprintf(stderr, "Connection Null\n"); + exit(1); + } + + char dbusname[1024]; + memset((char *) dbusname, 0, 1024); + sprintf(dbusname, "%s.method.server", workername); + int64_t workernum = 0; + for (int iind = 0; iind < strlen(workername) - 6; iind++) + { + workernum = workernum + + (workername[strlen(workername) - 1 - iind] - '0') * pow(10, iind); +#if 0 + printf( + "workername[%d] = %c. \n", + strlen(workername) - 1 - iind, + workername[strlen(workername) - 1 - iind] + ); +#endif + } + // printf("The worker num is 0x %16.16lx. \n", workernum); + // request our name on the bus and check for errors + ret = + dbus_bus_request_name( + conn, + // "test.method.server", + dbusname, + DBUS_NAME_FLAG_REPLACE_EXISTING, + &err); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Name Error (%s)\n", err.message); + dbus_error_free(&err); + } + if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) + { + fprintf(stderr, "Not Primary Owner (%d)\n", ret); + exit(1); + } + + // loop, testing for new messages + memset((char *) dbusname, 0, 1024); + sprintf(dbusname, "%s.method.Type", workername); + while (true) + { + // non blocking read of the next available message + dbus_connection_read_write(conn, 0); + msg = dbus_connection_pop_message(conn); + + // loop again if we haven't got a message + if (NULL == msg) + { + usleep(10000); + continue; + } + + // check this is a method call for the right interface & method + bResult = dbus_message_is_method_call( + msg, + // "test.method.Type", + dbusname, + "TEEC_InitializeContext" + ); + if (bResult == TRUE) + { + DBusMsgConn *thdfargs = (DBusMsgConn *) malloc(sizeof(DBusMsgConn)); + thdfargs->msg = msg; + thdfargs->conn = conn; +#ifdef GP_PROXY + thdfargs->mutex_workerrec = mutex_workerrec; + thdfargs->cond_notbusy = cond_notbusy; + thdfargs->workerrec = workerrec; +#endif +#ifdef GP_WORKER + thdfargs->workernum = workernum; + thdfargs->mutex_tcl = mutex_tcl; + thdfargs->mutex_tsl = mutex_tsl; + thdfargs->tcl = tcl; + thdfargs->tsl = tsl; +#endif + threadpool_add_task( + pool, + reply_to_method_call_teec_inicont, + thdfargs + ); + } + + // check this is a method call for the right interface & method + bResult = dbus_message_is_method_call( + msg, + // "test.method.Type", + dbusname, + "TEEC_FinalizeContext" + ); + if (bResult == TRUE) + { + DBusMsgConn *thdfargs = (DBusMsgConn *) malloc(sizeof(DBusMsgConn)); + thdfargs->msg = msg; + thdfargs->conn = conn; +#ifdef GP_PROXY + thdfargs->mutex_workerrec = mutex_workerrec; + thdfargs->cond_notbusy = cond_notbusy; + thdfargs->workerrec = workerrec; +#endif +#ifdef GP_WORKER + thdfargs->workernum = workernum; + thdfargs->mutex_tcl = mutex_tcl; + thdfargs->mutex_tsl = mutex_tsl; + thdfargs->tcl = tcl; + thdfargs->tsl = tsl; +#endif + threadpool_add_task( + pool, + reply_to_method_call_teec_fincont, + thdfargs + ); + } + + // check this is a method call for the right interface & method + bResult = dbus_message_is_method_call( + msg, + // "test.method.Type", + dbusname, + "TEEC_OpenSession" + ); + if (bResult == TRUE) + { + DBusMsgConn *thdfargs = (DBusMsgConn *) malloc(sizeof(DBusMsgConn)); + thdfargs->msg = msg; + thdfargs->conn = conn; +#ifdef GP_PROXY + thdfargs->mutex_workerrec = mutex_workerrec; + thdfargs->cond_notbusy = cond_notbusy; + thdfargs->workerrec = workerrec; +#endif +#ifdef GP_WORKER + thdfargs->workernum = workernum; + thdfargs->mutex_tcl = mutex_tcl; + thdfargs->mutex_tsl = mutex_tsl; + thdfargs->tcl = tcl; + thdfargs->tsl = tsl; +#endif + threadpool_add_task( + pool, + reply_to_method_call_teec_opensession, + thdfargs + ); + } + + // check this is a method call for the right interface & method + bResult = dbus_message_is_method_call( + msg, + // "test.method.Type", + dbusname, + "TEEC_CloseSession" + ); + if (bResult == TRUE) + { + DBusMsgConn *thdfargs = (DBusMsgConn *) malloc(sizeof(DBusMsgConn)); + thdfargs->msg = msg; + thdfargs->conn = conn; +#ifdef GP_PROXY + thdfargs->mutex_workerrec = mutex_workerrec; + thdfargs->cond_notbusy = cond_notbusy; + thdfargs->workerrec = workerrec; +#endif +#ifdef GP_WORKER + thdfargs->workernum = workernum; + thdfargs->mutex_tcl = mutex_tcl; + thdfargs->mutex_tsl = mutex_tsl; + thdfargs->tcl = tcl; + thdfargs->tsl = tsl; +#endif + threadpool_add_task( + pool, + reply_to_method_call_teec_closesession, + thdfargs + ); + } + + bResult = dbus_message_is_method_call( + msg, + // "test.method.Type", + dbusname, + "TEEC_InvokeCommand" + ); + if (bResult == TRUE) + { + DBusMsgConn *thdfargs = (DBusMsgConn *) malloc(sizeof(DBusMsgConn)); + thdfargs->msg = msg; + thdfargs->conn = conn; +#ifdef GP_PROXY + thdfargs->mutex_workerrec = mutex_workerrec; + thdfargs->cond_notbusy = cond_notbusy; + thdfargs->workerrec = workerrec; +#endif +#ifdef GP_WORKER + thdfargs->workernum = workernum; + thdfargs->mutex_tcl = mutex_tcl; + thdfargs->mutex_tsl = mutex_tsl; + thdfargs->tcl = tcl; + thdfargs->tsl = tsl; +#endif + threadpool_add_task( + pool, + reply_to_method_call_teec_invokecommand, + thdfargs + ); + } + + // check this is a method call for the right interface & method + bResult = dbus_message_is_method_call( + msg, + // "test.method.Type", + dbusname, + "Destroy" + ); + if (bResult == TRUE) + { + reply_to_method_call_destroy_threadpool( + msg, + conn, + pool +#ifdef GP_WORKER + , + mutex_tcl, + mutex_tsl +#endif + +#ifdef GP_PROXY + , + mutex_workerrec, + cond_notbusy +#endif + ); + } + + // free the message + // dbus_message_unref(msg); + + } // end of the while true +} // end of the function +#endif + + + +/** + * Call a method on a remote object + */ +int32_t +method_call_teec_inicont( + const char *workername, + + const uint8_t *name, size_t name_size, + int32_t in_context_fd, + const uint8_t *in_context_tapath, size_t in_context_tapath_size, + uint64_t in_context_sessionlist_next, + uint64_t in_context_sessionlist_prev, + uint64_t in_context_shrdmemlist_next, + uint64_t in_context_shrdmemlist_prev, + uint64_t in_context_sharebuffer_buffer, + int64_t in_context_sharebuffer_bufferbarrier, + + uint32_t *teecresult, + int32_t *context_fd, + uint8_t *context_tapath, size_t context_tapath_insize, + uint64_t *context_sessionlist_next, + uint64_t *context_sessionlist_prev, + uint64_t *context_shrdmemlist_next, + uint64_t *context_shrdmemlist_prev, + uint64_t *context_sharebuffer_buffer, + int64_t *context_sharebuffer_bufferbarrier, + uint64_t *context_addr, + uint32_t *context_tapath_outsize +) +{ + DBusConnection *conn = NULL; + DBusMessage *msg; + DBusMessageIter args; + DBusError err; + DBusPendingCall *pending; + dbus_bool_t bResult; + DBusMessageIter structIter; + int ret; + int iType; + unsigned char *context_tapath_temp = NULL; + dbus_int32_t di32Temp; + dbus_uint32_t dui32Temp; + dbus_int64_t di64Temp; + dbus_uint64_t dui64Temp; + + // initialiset the errors + dbus_error_init(&err); + + dbus_threads_init_default(); + + char dbusname[1024]; + if (conn == NULL) + { + // connect to the system bus and check for errors + // conn = dbus_bus_get(DBUS_BUS_SESSION, &err); + conn = dbus_bus_get_private(DBUS_BUS_SESSION, &err); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Connection Error (%s)\n", err.message); + dbus_error_free(&err); + } + if (NULL == conn) + { + return -1; + } + + memset((uint8_t *) dbusname, 0, 1024); + struct timeval tv; + gettimeofday(&tv, NULL); + uint64_t u64time = (long unsigned int) (tv.tv_sec * 1000000 + tv.tv_usec); + srand(u64time); + sprintf(dbusname, + "%s.method.caller%16.16lx%16.16lx", + workername, + u64time, + (long unsigned int) rand() + ); + // request our name on the bus + ret = + dbus_bus_request_name( + conn, + dbusname, + DBUS_NAME_FLAG_REPLACE_EXISTING, + &err + ); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Name Error (%s)\n", err.message); + dbus_error_free(&err); + dbus_connection_flush(conn); + } + if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) + { + dbus_connection_flush(conn); + return -1; + } + } + + // create a new method call and check for errors + char objname[1024]; + char interfacename[1024]; + memset((uint8_t *) dbusname, 0, 1024); + sprintf(dbusname, "%s.method.server", workername); + memset((uint8_t *) objname, 0, 1024); + sprintf(objname, "/%s/method/Object", workername); + memset((uint8_t *) interfacename, 0, 1024); + sprintf(interfacename, "%s.method.Type", workername); + msg = + dbus_message_new_method_call( + // "test.method.server", // target for the method call + dbusname, + // "/test/method/Object", // object to call on + objname, + // "test.method.Type", // interface to call on + interfacename, + "TEEC_InitializeContext" // method name + ); + if (NULL == msg) + { + fprintf(stderr, "Message Null\n"); + dbus_connection_flush(conn); + return -1; + } + + // append arguments + dbus_message_iter_init_append(msg, &args); + dbus_message_iter_open_container( + &args, + DBUS_TYPE_STRUCT, + NULL, + &structIter + ); + + di32Temp = name_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + if (name_size > 0 && name != NULL) + { + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_STRING, + &name + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + } + + di32Temp = in_context_fd; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + if (in_context_tapath_size > 0 && + in_context_tapath != NULL && + strlen((const char *) in_context_tapath) > 0 + ) + { + if (dbus_validate_utf8((const char *) in_context_tapath, &err) == true) + { + di32Temp = strlen((const char *) in_context_tapath); + } else + { + di32Temp = 0; + } + } else + { + di32Temp = 0; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + // if (in_context_tapath_size > 0 && in_context_tapath != NULL) + if (di32Temp > 0) + { + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_STRING, + &in_context_tapath + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + } + + dui64Temp = in_context_sessionlist_next; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_context_sessionlist_prev; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_context_shrdmemlist_next; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_context_shrdmemlist_prev; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_context_sharebuffer_buffer; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di64Temp = in_context_sharebuffer_bufferbarrier; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT64, + &di64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_close_container( + &args, + &structIter + ); + + // send message and get a handle for a reply + if (!dbus_connection_send_with_reply(conn, msg, &pending, -1)) + { // -1 is default timeout + fprintf(stderr, "Out Of Memory!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + if (NULL == pending) + { + fprintf(stderr, "Pending Call Null\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_connection_flush(conn); + dbus_message_unref(msg); + + printf("\n"); + printf("Method Call Teec Init Contex Sent. \n"); + + // block until we recieve a reply + dbus_pending_call_block(pending); + + // get the reply message + msg = dbus_pending_call_steal_reply(pending); + if (NULL == msg) + { + fprintf(stderr, "Reply Null\n"); + return -1; + } + // free the pending message handle + dbus_pending_call_unref(pending); + + // read the parameters + bResult = + dbus_message_iter_init( + msg, + &args + ); + if (!bResult) + { + fprintf(stderr, "Message has no arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_recurse( + &args, + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *teecresult = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di32Temp + ); + *context_fd = di32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *context_tapath_outsize = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + if (*context_tapath_outsize > 0) + { + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_STRING + ) + { + fprintf(stderr, "Argument is not STRING.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &context_tapath_temp); + + bResult = + dbus_message_iter_next( + &structIter + ); + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_sessionlist_next = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_sessionlist_prev = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_shrdmemlist_next = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_shrdmemlist_prev = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_sharebuffer_buffer = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT64 + ) + { + fprintf(stderr, "Argument is not INT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di64Temp + ); + *context_sharebuffer_bufferbarrier = di64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_addr = dui64Temp; + + printf("Got Reply of Method Call Teec Init Contex: \n"); + printf(" teecresult = 0x %8.8x \n", *teecresult); + printf(" fd = 0x %8.8x \n", (unsigned int) *context_fd); + printf(" ta_path = %s \n", context_tapath_temp); + printf(" ta_path_size = %d \n", (int) *context_tapath_outsize); +#if 0 + printf(" TEEC_Context session_list.next = 0x %16.16lx \n", + *context_sessionlist_next + ); + printf(" TEEC_Context session_list.prev = 0x %16.16lx \n", + *context_sessionlist_prev + ); + printf(" TEEC_Context shrd_mem_list.next = 0x %16.16lx \n", + *context_shrdmemlist_next + ); + printf(" TEEC_Context shrd_mem_list.prev = 0x %16.16lx \n", + *context_shrdmemlist_prev + ); + printf(" TEEC_Context share_buffer.buffer = 0x %16.16lx \n", + *context_sharebuffer_buffer + ); + printf(" TEEC_Context share_buffer.buffer_barrier = 0x %16.16lx \n", + (long unsigned int)*context_sharebuffer_bufferbarrier + ); +#endif + printf(" context addr = 0x %16.16lx \n", + (long unsigned int) *context_addr + ); + + if ( + context_tapath_insize > *context_tapath_outsize && + *context_tapath_outsize > 0 && + context_tapath != NULL && + context_tapath_temp != NULL + ) + { + memcpy(context_tapath, context_tapath_temp, *context_tapath_outsize); + *(context_tapath + *context_tapath_outsize) = 0; + } else + { + // dbus_message_unref(msg); + // return -1; + *(context_tapath + 0) = 0; + } + + // free msg + dbus_message_unref(msg); + + dbus_connection_close(conn); + dbus_connection_unref(conn); + + return 0; +} + + +/** + * Call a method on a remote object + */ +int32_t +method_call_teec_fincont( + const char *workername, + + int32_t in_context_fd, + const uint8_t *in_context_tapath, size_t in_context_tapath_size, + uint64_t in_context_sessionlist_next, + uint64_t in_context_sessionlist_prev, + uint64_t in_context_shrdmemlist_next, + uint64_t in_context_shrdmemlist_prev, + uint64_t in_context_sharebuffer_buffer, + int64_t in_context_sharebuffer_bufferbarrier, + uint64_t in_context_addr, + + int32_t *context_fd, + uint8_t *context_tapath, size_t context_tapath_insize, + uint64_t *context_sessionlist_next, + uint64_t *context_sessionlist_prev, + uint64_t *context_shrdmemlist_next, + uint64_t *context_shrdmemlist_prev, + uint64_t *context_sharebuffer_buffer, + int64_t *context_sharebuffer_bufferbarrier, + uint32_t *context_tapath_outsize +) +{ + DBusConnection *conn = NULL; + DBusMessage *msg; + DBusMessageIter args; + DBusError err; + DBusPendingCall *pending; + dbus_bool_t bResult; + DBusMessageIter structIter; + int ret; + int iType; + unsigned char *context_tapath_temp = NULL; + dbus_int32_t di32Temp; + dbus_uint32_t dui32Temp; + dbus_int64_t di64Temp; + dbus_uint64_t dui64Temp; + + // initialiset the errors + dbus_error_init(&err); + + char dbusname[1024]; + if (conn == NULL) + { + // connect to the system bus and check for errors + conn = dbus_bus_get_private(DBUS_BUS_SESSION, &err); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Connection Error (%s)\n", err.message); + dbus_error_free(&err); + } + if (NULL == conn) + { + return -1; + } + + memset((uint8_t *) dbusname, 0, 1024); + struct timeval tv; + gettimeofday(&tv, NULL); + uint64_t u64time = (long unsigned int) (tv.tv_sec * 1000000 + tv.tv_usec); + srand(u64time); + sprintf(dbusname, + "%s.method.caller%16.16lx%16.16lx", + workername, + u64time, + (long unsigned int) rand() + ); + // request our name on the bus + ret = + dbus_bus_request_name( + conn, + dbusname, + DBUS_NAME_FLAG_REPLACE_EXISTING, + &err + ); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Name Error (%s)\n", err.message); + dbus_error_free(&err); + dbus_connection_flush(conn); + } + if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) + { + dbus_connection_flush(conn); + return -1; + } + } + + // create a new method call and check for errors + char objname[1024]; + char interfacename[1024]; + memset((uint8_t *) dbusname, 0, 1024); + sprintf(dbusname, "%s.method.server", workername); + memset((uint8_t *) objname, 0, 1024); + sprintf(objname, "/%s/method/Object", workername); + memset((uint8_t *) interfacename, 0, 1024); + sprintf(interfacename, "%s.method.Type", workername); + msg = + dbus_message_new_method_call( + // "test.method.server", // target for the method call + dbusname, + // "/test/method/Object", // object to call on + objname, + // "test.method.Type", // interface to call on + interfacename, + "TEEC_FinalizeContext" + ); + if (NULL == msg) + { + fprintf(stderr, "Message Null\n"); + dbus_connection_flush(conn); + return -1; + } + + // append arguments + dbus_message_iter_init_append(msg, &args); + dbus_message_iter_open_container( + &args, + DBUS_TYPE_STRUCT, + NULL, + &structIter + ); + + di32Temp = in_context_fd; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + if (in_context_tapath_size > 0 && + in_context_tapath != NULL && + strlen((const char *) in_context_tapath) > 0 + ) + { + if (dbus_validate_utf8((const char *) in_context_tapath, &err) == true) + { + di32Temp = strlen((const char *) in_context_tapath); + } else + { + di32Temp = 0; + } + } else + { + di32Temp = 0; + } + + // fprintf(stderr, "in_context_tapath_size = %ld \n", in_context_tapath_size); + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + // if (in_context_tapath_size > 0 && in_context_tapath != NULL) + if (di32Temp > 0) + { + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_STRING, + &in_context_tapath + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + } + + dui64Temp = in_context_sessionlist_next; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_context_sessionlist_prev; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_context_shrdmemlist_next; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_context_shrdmemlist_prev; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_context_sharebuffer_buffer; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di64Temp = in_context_sharebuffer_bufferbarrier; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT64, + &di64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_context_addr; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_close_container( + &args, + &structIter + ); + + // send message and get a handle for a reply + if (!dbus_connection_send_with_reply(conn, msg, &pending, -1)) + { // -1 is default timeout + fprintf(stderr, "Out Of Memory!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + if (NULL == pending) + { + fprintf(stderr, "Pending Call Null\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_connection_flush(conn); + dbus_message_unref(msg); + + printf("\n"); + printf("Method Call Teec Fin Contex Sent. \n"); + + // block until we recieve a reply + dbus_pending_call_block(pending); + + // get the reply message + msg = dbus_pending_call_steal_reply(pending); + if (NULL == msg) + { + fprintf(stderr, "Reply Null\n"); + return -1; + } + // free the pending message handle + dbus_pending_call_unref(pending); + + // read the parameters + bResult = + dbus_message_iter_init( + msg, + &args + ); + if (!bResult) + { + fprintf(stderr, "Message has no arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_recurse( + &args, + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di32Temp + ); + *context_fd = di32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *context_tapath_outsize = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + if (*context_tapath_outsize > 0) + { + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_STRING + ) + { + fprintf(stderr, "Argument is not STRING.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &context_tapath_temp); + + bResult = + dbus_message_iter_next( + &structIter + ); + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_sessionlist_next = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_sessionlist_prev = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_shrdmemlist_next = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_shrdmemlist_prev = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_sharebuffer_buffer = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT64 + ) + { + fprintf(stderr, "Argument is not INT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di64Temp + ); + *context_sharebuffer_bufferbarrier = di64Temp; + + printf("Got Reply of Method Call Teec Fin Contex: \n"); + printf(" fd = 0x %8.8x \n", (unsigned int) *context_fd); + printf(" ta_path = %s \n", context_tapath_temp); + printf(" ta_path_size = %d \n", (int) *context_tapath_outsize); +#if 0 + printf(" TEEC_Context session_list.next = 0x %16.16lx \n", + *context_sessionlist_next + ); + printf(" TEEC_Context session_list.prev = 0x %16.16lx \n", + *context_sessionlist_prev + ); + printf(" TEEC_Context shrd_mem_list.next = 0x %16.16lx \n", + *context_shrdmemlist_next + ); + printf(" TEEC_Context shrd_mem_list.prev = 0x %16.16lx \n", + *context_shrdmemlist_prev + ); + printf(" TEEC_Context share_buffer.buffer = 0x %16.16lx \n", + *context_sharebuffer_buffer + ); + printf(" TEEC_Context share_buffer.buffer_barrier = 0x %16.16lx \n", + (long unsigned int)*context_sharebuffer_bufferbarrier + ); +#endif + + if ( + context_tapath_insize > *context_tapath_outsize && + *context_tapath_outsize > 0 && + context_tapath != NULL && + context_tapath_temp != NULL + ) + { + memcpy(context_tapath, context_tapath_temp, *context_tapath_outsize); + *(context_tapath + *context_tapath_outsize) = 0; + } else + { + // dbus_message_unref(msg); + // return -1; + *(context_tapath + 0) = 0; + } + + // free msg + dbus_message_unref(msg); + + dbus_connection_close(conn); + dbus_connection_unref(conn); + + return 0; +} + + +/** + * Call a method on a remote object + */ +int32_t +method_call_teec_opensession( + const char *workername, + + int32_t in_context_fd, + const uint8_t *in_context_tapath, + size_t in_context_tapath_size, + uint64_t in_context_sessionlist_next, + uint64_t in_context_sessionlist_prev, + uint64_t in_context_shrdmemlist_next, + uint64_t in_context_shrdmemlist_prev, + uint64_t in_context_sharebuffer_buffer, + int64_t in_context_sharebuffer_bufferbarrier, + + uint32_t in_destination_timelow, + uint32_t in_destination_timemid, + uint32_t in_destination_timehiandver, + uint32_t *in_destination_clockseqandnode, + int32_t in_destination_clockseqandnode_size, + + uint32_t in_connectionmethod, + uint64_t in_connectiondata, + + uint32_t in_operation_started, + uint32_t in_operation_paramtypes, + + uint64_t in_operation_param1_tmpref_buffer, + uint32_t in_operation_param1_tmpref_size, + uint64_t in_operation_param1_memref_parent, + uint32_t in_operation_param1_memref_size, + uint32_t in_operation_param1_memref_offset, + uint32_t in_operation_param1_value_a, + uint32_t in_operation_param1_value_b, + int32_t in_operation_param1_ionref_ionsharefd, + uint32_t in_operation_param1_ionref_ionsize, + + uint64_t in_operation_param2_tmpref_buffer, + uint32_t in_operation_param2_tmpref_size, + uint64_t in_operation_param2_memref_parent, + uint32_t in_operation_param2_memref_size, + uint32_t in_operation_param2_memref_offset, + uint32_t in_operation_param2_value_a, + uint32_t in_operation_param2_value_b, + int32_t in_operation_param2_ionref_ionsharefd, + uint32_t in_operation_param2_ionref_ionsize, + + uint64_t in_operation_param3_tmpref_buffer, + uint32_t in_operation_param3_tmpref_size, + uint64_t in_operation_param3_memref_parent, + uint32_t in_operation_param3_memref_size, + uint32_t in_operation_param3_memref_offset, + uint32_t in_operation_param3_value_a, + uint32_t in_operation_param3_value_b, + int32_t in_operation_param3_ionref_ionsharefd, + uint32_t in_operation_param3_ionref_ionsize, + + uint64_t in_operation_param4_tmpref_buffer, + uint32_t in_operation_param4_tmpref_size, + uint64_t in_operation_param4_memref_parent, + uint32_t in_operation_param4_memref_size, + uint32_t in_operation_param4_memref_offset, + uint32_t in_operation_param4_value_a, + uint32_t in_operation_param4_value_b, + int32_t in_operation_param4_ionref_ionsharefd, + uint32_t in_operation_param4_ionref_ionsize, + + uint64_t in_operation_session, + int32_t in_operation_cancelflag, + + uint32_t in_returnorigin, + + uint64_t in_context_addr, + + + uint32_t *teecresult, + + int32_t *context_fd, + uint8_t *context_tapath, + size_t context_tapath_size, + uint32_t *context_tapath_outsize, + uint64_t *context_sessionlist_next, + uint64_t *context_sessionlist_prev, + uint64_t *context_shrdmemlist_next, + uint64_t *context_shrdmemlist_prev, + uint64_t *context_sharebuffer_buffer, + int64_t *context_sharebuffer_bufferbarrier, + + uint32_t *session_seesionid, + uint32_t *session_serviceid_timelow, + uint32_t *session_serviceid_timemid, + uint32_t *session_serviceid_timehiandver, + uint32_t *session_serviceid_clockseqandnode, + int32_t session_serviceid_clockseqandnode_size, + uint32_t *session_serviceid_clockseqandnode_outsize, + uint32_t *session_opscnt, + uint64_t *session_head_next, + uint64_t *session_head_prev, + uint64_t *session_context, + + uint32_t *operation_started, + uint32_t *operation_paramtypes, + + uint64_t *operation_param1_tmpref_buffer, + uint32_t *operation_param1_tmpref_size, + uint64_t *operation_param1_memref_parent, + uint32_t *operation_param1_memref_size, + uint32_t *operation_param1_memref_offset, + uint32_t *operation_param1_value_a, + uint32_t *operation_param1_value_b, + int32_t *operation_param1_ionref_ionsharefd, + uint32_t *operation_param1_ionref_ionsize, + + uint64_t *operation_param2_tmpref_buffer, + uint32_t *operation_param2_tmpref_size, + uint64_t *operation_param2_memref_parent, + uint32_t *operation_param2_memref_size, + uint32_t *operation_param2_memref_offset, + uint32_t *operation_param2_value_a, + uint32_t *operation_param2_value_b, + int32_t *operation_param2_ionref_ionsharefd, + uint32_t *operation_param2_ionref_ionsize, + + uint64_t *operation_param3_tmpref_buffer, + uint32_t *operation_param3_tmpref_size, + uint64_t *operation_param3_memref_parent, + uint32_t *operation_param3_memref_size, + uint32_t *operation_param3_memref_offset, + uint32_t *operation_param3_value_a, + uint32_t *operation_param3_value_b, + int32_t *operation_param3_ionref_ionsharefd, + uint32_t *operation_param3_ionref_ionsize, + + uint64_t *operation_param4_tmpref_buffer, + uint32_t *operation_param4_tmpref_size, + uint64_t *operation_param4_memref_parent, + uint32_t *operation_param4_memref_size, + uint32_t *operation_param4_memref_offset, + uint32_t *operation_param4_value_a, + uint32_t *operation_param4_value_b, + int32_t *operation_param4_ionref_ionsharefd, + uint32_t *operation_param4_ionref_ionsize, + + uint64_t *operation_session, + int32_t *operation_cancelflag, + + uint32_t *returnorigin +) +{ + DBusConnection *conn = NULL; + DBusMessage *msg; + DBusMessageIter args; + DBusError err; + DBusPendingCall *pending; + dbus_bool_t bResult; + DBusMessageIter structIter; + DBusMessageIter ArrayIter; + int ret; + int iType; + unsigned char *context_tapath_temp = NULL; + dbus_uint32_t *session_serviceid_clockseqandnode_temp = NULL; + int session_serviceid_clockseqandnode_realsize; + dbus_int32_t di32Temp; + dbus_uint32_t dui32Temp; + dbus_int64_t di64Temp; + dbus_uint64_t dui64Temp; + char buf[2]; + buf[0] = DBUS_TYPE_UINT32; + buf[1] = '\0'; + + // initialiset the errors + dbus_error_init(&err); + + char dbusname[1024]; + if (conn == NULL) + { + // connect to the system bus and check for errors + conn = dbus_bus_get_private(DBUS_BUS_SESSION, &err); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Connection Error (%s)\n", err.message); + dbus_error_free(&err); + } + if (NULL == conn) + { + return -1; + } + + memset((uint8_t *) dbusname, 0, 1024); + struct timeval tv; + gettimeofday(&tv, NULL); + uint64_t u64time = (long unsigned int) (tv.tv_sec * 1000000 + tv.tv_usec); + srand(u64time); + sprintf(dbusname, + "%s.method.caller%16.16lx%16.16lx", + workername, + u64time, + (long unsigned int) rand() + ); + + // request our name on the bus + ret = + dbus_bus_request_name( + conn, + dbusname, + DBUS_NAME_FLAG_REPLACE_EXISTING, + &err + ); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Name Error (%s)\n", err.message); + dbus_error_free(&err); + dbus_connection_flush(conn); + } + if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) + { + dbus_connection_flush(conn); + return -1; + } + } + + // create a new method call and check for errors + char objname[1024]; + char interfacename[1024]; + memset((uint8_t *) dbusname, 0, 1024); + sprintf(dbusname, "%s.method.server", workername); + memset((uint8_t *) objname, 0, 1024); + sprintf(objname, "/%s/method/Object", workername); + memset((uint8_t *) interfacename, 0, 1024); + sprintf(interfacename, "%s.method.Type", workername); + msg = + dbus_message_new_method_call( + // "test.method.server", // target for the method call + dbusname, + // "/test/method/Object", // object to call on + objname, + // "test.method.Type", // interface to call on + interfacename, + "TEEC_OpenSession" + ); + if (NULL == msg) + { + fprintf(stderr, "Message Null\n"); + dbus_connection_flush(conn); + return -1; + } + + // append arguments + dbus_message_iter_init_append(msg, &args); + dbus_message_iter_open_container( + &args, + DBUS_TYPE_STRUCT, + NULL, + &structIter + ); + + di32Temp = in_context_fd; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + if (in_context_tapath_size > 0 && + in_context_tapath != NULL && + strlen((const char *) in_context_tapath) > 0 + ) + { + if (dbus_validate_utf8((const char *) in_context_tapath, &err) == true) + { + di32Temp = strlen((const char *) in_context_tapath); + } else + { + di32Temp = 0; + } + } else + { + di32Temp = 0; + } + + // fprintf(stderr, "in_context_tapath_size = %ld \n", in_context_tapath_size); + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + // if (in_context_tapath_size > 0 && in_context_tapath != NULL) + if (di32Temp > 0) + { + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_STRING, + &in_context_tapath + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + } + + dui64Temp = in_context_sessionlist_next; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_context_sessionlist_prev; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_context_shrdmemlist_next; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_context_shrdmemlist_prev; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_context_sharebuffer_buffer; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di64Temp = in_context_sharebuffer_bufferbarrier; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT64, + &di64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_destination_timelow; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_destination_timemid; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_destination_timehiandver; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di32Temp = in_destination_clockseqandnode_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + if (in_destination_clockseqandnode_size > 0 && + in_destination_clockseqandnode != NULL) + { + dbus_message_iter_open_container( + &structIter, + DBUS_TYPE_ARRAY, + buf, + &ArrayIter + ); + + bResult = + dbus_message_iter_append_fixed_array( + &ArrayIter, + DBUS_TYPE_UINT32, + &in_destination_clockseqandnode, + in_destination_clockseqandnode_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + } + + dui32Temp = in_connectionmethod; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_connectiondata; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + + dui32Temp = in_operation_started; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_paramtypes; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param1_tmpref_buffer; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param1_tmpref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param1_memref_parent; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param1_memref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param1_memref_offset; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param1_value_a; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param1_value_b; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di32Temp = in_operation_param1_ionref_ionsharefd; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param1_ionref_ionsize; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param2_tmpref_buffer; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param2_tmpref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param2_memref_parent; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param2_memref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param2_memref_offset; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param2_value_a; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param2_value_b; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di32Temp = in_operation_param2_ionref_ionsharefd; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param2_ionref_ionsize; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param3_tmpref_buffer; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param3_tmpref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param3_memref_parent; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param3_memref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param3_memref_offset; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param3_value_a; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param3_value_b; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di32Temp = in_operation_param3_ionref_ionsharefd; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param3_ionref_ionsize; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param4_tmpref_buffer; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param4_tmpref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param4_memref_parent; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param4_memref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param4_memref_offset; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param4_value_a; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param4_value_b; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di32Temp = in_operation_param4_ionref_ionsharefd; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param4_ionref_ionsize; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_session; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di32Temp = in_operation_cancelflag; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_returnorigin; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_context_addr; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_close_container( + &args, + &structIter + ); + + /////////////////////////////////////////////////////////////////// + + // send message and get a handle for a reply + if (!dbus_connection_send_with_reply(conn, msg, &pending, -1)) + { // -1 is default timeout + fprintf(stderr, "Out Of Memory!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + if (NULL == pending) + { + fprintf(stderr, "Pending Call Null\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_connection_flush(conn); + dbus_message_unref(msg); + + printf("\n"); + printf("Method Call Teec Open Session Sent. \n"); + + // block until we recieve a reply + dbus_pending_call_block(pending); + + // get the reply message + msg = dbus_pending_call_steal_reply(pending); + if (NULL == msg) + { + fprintf(stderr, "Reply Null\n"); + return -1; + } + + // free the pending message handle + dbus_pending_call_unref(pending); + + // read the parameters + bResult = + dbus_message_iter_init( + msg, + &args + ); + if (!bResult) + { + fprintf(stderr, "Message has no arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_recurse( + &args, + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *teecresult = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di32Temp + ); + *context_fd = di32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *context_tapath_outsize = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + if (*context_tapath_outsize > 0) + { + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_STRING + ) + { + fprintf(stderr, "Argument is not STRING.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &context_tapath_temp); + + bResult = + dbus_message_iter_next( + &structIter + ); + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_sessionlist_next = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_sessionlist_prev = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_shrdmemlist_next = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_shrdmemlist_prev = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *context_sharebuffer_buffer = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT64 + ) + { + fprintf(stderr, "Argument is not INT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di64Temp + ); + *context_sharebuffer_bufferbarrier = di64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_seesionid = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_serviceid_timelow = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_serviceid_timemid = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_serviceid_timehiandver = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_serviceid_clockseqandnode_outsize = dui32Temp; + + if (*session_serviceid_clockseqandnode_outsize > 0) + { + bResult = + dbus_message_iter_next( + &structIter + ); + + dbus_message_iter_recurse( + &structIter, + &ArrayIter); + + iType = + dbus_message_iter_get_arg_type( + &ArrayIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_fixed_array( + &ArrayIter, + &session_serviceid_clockseqandnode_temp, + &session_serviceid_clockseqandnode_realsize + ); + } + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_opscnt = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *session_head_next = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *session_head_prev = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *session_context = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_started = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_paramtypes = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param1_tmpref_buffer = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param1_tmpref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param1_memref_parent = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param1_memref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param1_memref_offset = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param1_value_a = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param1_value_b = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di32Temp + ); + *operation_param1_ionref_ionsharefd = di32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param1_ionref_ionsize = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param2_tmpref_buffer = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param2_tmpref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param2_memref_parent = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param2_memref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param2_memref_offset = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param2_value_a = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param2_value_b = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di32Temp + ); + *operation_param2_ionref_ionsharefd = di32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param2_ionref_ionsize = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param3_tmpref_buffer = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param3_tmpref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param3_memref_parent = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param3_memref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param3_memref_offset = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param3_value_a = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param3_value_b = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di32Temp + ); + *operation_param3_ionref_ionsharefd = di32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param3_ionref_ionsize = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param4_tmpref_buffer = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param4_tmpref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param4_memref_parent = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param4_memref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param4_memref_offset = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param4_value_a = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param4_value_b = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di32Temp + ); + *operation_param4_ionref_ionsharefd = di32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param4_ionref_ionsize = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_session = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di32Temp + ); + *operation_cancelflag = di32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *returnorigin = dui32Temp; + + printf("Got Reply of Method Call Teec Open Session: \n"); + printf(" teecresult = 0x %8.8x \n", *teecresult); + printf(" fd = 0x %8.8x \n", (unsigned int) *context_fd); + printf(" ta_path = %s \n", context_tapath_temp); + printf(" ta_path_size = %d \n", (int) *context_tapath_outsize); + printf(" session_seesionid = 0x %8.8x \n", + *session_seesionid + ); +#if 0 + printf(" TEEC_Context session_list.next = 0x %16.16lx \n", + *context_sessionlist_next + ); + printf(" TEEC_Context session_list.prev = 0x %16.16lx \n", + *context_sessionlist_prev + ); + printf(" TEEC_Context shrd_mem_list.next = 0x %16.16lx \n", + *context_shrdmemlist_next + ); + printf(" TEEC_Context shrd_mem_list.prev = 0x %16.16lx \n", + *context_shrdmemlist_prev + ); + printf(" TEEC_Context share_buffer.buffer = 0x %16.16lx \n", + *context_sharebuffer_buffer + ); + printf(" TEEC_Context share_buffer.buffer_barrier = 0x %16.16lx \n", + (long unsigned int)*context_sharebuffer_bufferbarrier + ); + + printf(" TEEC_Session session_serviceid_timelow = 0x %8.8x \n", + *session_serviceid_timelow + ); + printf(" TEEC_Session session_serviceid_timehiandver = 0x %8.8x \n", + *session_serviceid_timehiandver + ); + + printf(" TEEC_Session session_serviceid_clockseqandnode = \n"); + if (*session_serviceid_clockseqandnode_outsize > 0 && + session_serviceid_clockseqandnode_temp != NULL) + { + printf(" "); + for (int i = 0; i < session_serviceid_clockseqandnode_realsize; i++) { + printf(" %2.2x", + session_serviceid_clockseqandnode_temp[i] + ); + } + printf("\n"); + } + printf(" TEEC_Session clockseqandnode_outsize = 0x %8.8x \n", + *session_serviceid_clockseqandnode_outsize + ); + + printf(" TEEC_Session session_opscnt = 0x %8.8x \n", + *session_opscnt + ); + printf(" TEEC_Session session_head_next = 0x %16.16lx \n", + *session_head_next + ); + printf(" TEEC_Session session_head_prev = 0x %16.16lx \n", + *session_head_prev + ); + printf(" TEEC_Session session_context = 0x %16.16lx \n", + *session_context + ); + printf(" TEEC_Session operation_started = 0x %8.8x \n", + *operation_started + ); + printf(" TEEC_Session operation_paramtypes = 0x %8.8x \n", + *operation_paramtypes + ); + + printf(" TEEC_Session operation_param1_tmpref_buffer = 0x %16.16lx \n", + *operation_param1_tmpref_buffer + ); + printf(" TEEC_Session operation_param1_tmpref_size = 0x %8.8x \n", + *operation_param1_tmpref_size + ); + printf(" TEEC_Session operation_param1_memref_parent = 0x %16.16lx \n", + *operation_param1_memref_parent + ); + printf(" TEEC_Session operation_param1_memref_size = 0x %8.8x \n", + *operation_param1_memref_size + ); + printf(" TEEC_Session operation_param1_memref_offse = 0x %8.8x \n", + *operation_param1_memref_offset + ); + printf(" TEEC_Session operation_param1_value_a = 0x %8.8x \n", + *operation_param1_value_a + ); + printf(" TEEC_Session operation_param1_value_b = 0x %8.8x \n", + *operation_param1_value_b + ); + printf(" TEEC_Session operation_param1_ionref_ionsharefd = 0x %8.8x \n", + (unsigned int)*operation_param1_ionref_ionsharefd + ); + printf(" TEEC_Session operation_param1_ionref_ionsize = 0x %8.8x \n", + *operation_param1_ionref_ionsize + ); + + printf(" TEEC_Session operation_param2_tmpref_buffer = 0x %16.16lx \n", + *operation_param2_tmpref_buffer + ); + printf(" TEEC_Session operation_param2_tmpref_size = 0x %8.8x \n", + *operation_param2_tmpref_size + ); + printf(" TEEC_Session operation_param2_memref_parent = 0x %16.16lx \n", + *operation_param2_memref_parent + ); + printf(" TEEC_Session operation_param2_memref_size = 0x %8.8x \n", + *operation_param2_memref_size + ); + printf(" TEEC_Session operation_param2_memref_offset = 0x %8.8x \n", + *operation_param2_memref_offset + ); + printf(" TEEC_Session operation_param2_value_a = 0x %8.8x \n", + *operation_param2_value_a + ); + printf(" TEEC_Session operation_param2_value_b = 0x %8.8x \n", + *operation_param2_value_b + ); + printf(" TEEC_Session operation_param2_ionref_ionsharefd = 0x %8.8x \n", + (unsigned int)*operation_param2_ionref_ionsharefd + ); + printf(" TEEC_Session operation_param2_ionref_ionsize = 0x %8.8x \n", + *operation_param2_ionref_ionsize + ); + + printf(" TEEC_Session operation_param3_tmpref_buffer = 0x %16.16lx \n", + *operation_param3_tmpref_buffer + ); + printf(" TEEC_Session operation_param3_tmpref_size = 0x %8.8x \n", + *operation_param3_tmpref_size + ); + printf(" TEEC_Session operation_param3_memref_parent = 0x %16.16lx \n", + *operation_param3_memref_parent + ); + printf(" TEEC_Session operation_param3_memref_size = 0x %8.8x \n", + *operation_param3_memref_size + ); + printf(" TEEC_Session operation_param3_memref_offset = 0x %8.8x \n", + *operation_param3_memref_offset + ); + printf(" TEEC_Session operation_param3_value_a = 0x %8.8x \n", + *operation_param3_value_a + ); + printf(" TEEC_Session operation_param3_value_b = 0x %8.8x \n", + *operation_param3_value_b + ); + printf(" TEEC_Session operation_param3_ionref_ionsharefd = 0x %8.8x \n", + (unsigned int)*operation_param3_ionref_ionsharefd + ); + printf(" TEEC_Session operation_param3_ionref_ionsize = 0x %8.8x \n", + *operation_param3_ionref_ionsize + ); + + printf(" TEEC_Session operation_param4_tmpref_buffer = 0x %16.16lx \n", + *operation_param4_tmpref_buffer + ); + printf(" TEEC_Session operation_param4_tmpref_size = 0x %8.8x \n", + *operation_param4_tmpref_size + ); + printf(" TEEC_Session operation_param4_memref_parent = 0x %16.16lx \n", + *operation_param4_memref_parent + ); + printf(" TEEC_Session operation_param4_memref_size = 0x %8.8x \n", + *operation_param4_memref_size + ); + printf(" TEEC_Session operation_param4_memref_offset = 0x %8.8x \n", + *operation_param4_memref_offset + ); + printf(" TEEC_Session operation_param4_value_a = 0x %8.8x \n", + *operation_param4_value_a + ); + printf(" TEEC_Session operation_param4_value_b = 0x %8.8x \n", + *operation_param4_value_b + ); + printf(" TEEC_Session operation_param4_ionref_ionsharefd = 0x %8.8x \n", + (unsigned int)*operation_param4_ionref_ionsharefd + ); + printf(" TEEC_Session operation_param4_ionref_ionsize = 0x %8.8x \n", + *operation_param4_ionref_ionsize + ); + + printf(" TEEC_Session operation_session = 0x %16.16lx \n", + *operation_session + ); + printf(" TEEC_Session operation_cancelflag = 0x %8.8x \n", + (unsigned int)*operation_cancelflag + ); + printf(" TEEC_Session returnorigin = 0x %8.8x \n", + *returnorigin + ); +#endif + + if (context_tapath_size > *context_tapath_outsize) + { + memcpy(context_tapath, context_tapath_temp, *context_tapath_outsize); + *(context_tapath + *context_tapath_outsize) = 0; + } else + { + dbus_message_unref(msg); + return -1; + } + + if (session_serviceid_clockseqandnode_size >= session_serviceid_clockseqandnode_realsize && + session_serviceid_clockseqandnode_temp != NULL && + session_serviceid_clockseqandnode_realsize > 0 + ) + { + for (int i = 0; i < session_serviceid_clockseqandnode_realsize; i++) + { + session_serviceid_clockseqandnode[i] = + session_serviceid_clockseqandnode_temp[i]; + + } + *session_serviceid_clockseqandnode_outsize = session_serviceid_clockseqandnode_realsize; + } else + { + // dbus_message_unref(msg); + // return -1; + *session_serviceid_clockseqandnode_outsize = 0; + } + + // free msg + dbus_message_unref(msg); + + dbus_connection_close(conn); + dbus_connection_unref(conn); + + return 0; +} + + +int32_t +method_call_teec_closesession( + const char *workername, + + uint32_t in_session_seesionid, + uint32_t in_session_serviceid_timelow, + uint32_t in_session_serviceid_timemid, + uint32_t in_session_serviceid_timehiandver, + uint32_t *in_session_serviceid_clockseqandnode, + int32_t in_session_serviceid_clockseqandnode_size, + uint32_t in_session_opscnt, + uint64_t in_session_head_next, + uint64_t in_session_head_prev, + uint64_t in_session_context, + + uint32_t *session_seesionid, + uint32_t *session_serviceid_timelow, + uint32_t *session_serviceid_timemid, + uint32_t *session_serviceid_timehiandver, + uint32_t *session_serviceid_clockseqandnode, + int32_t session_serviceid_clockseqandnode_size, + uint32_t *session_serviceid_clockseqandnode_outsize, + uint32_t *session_opscnt, + uint64_t *session_head_next, + uint64_t *session_head_prev, + uint64_t *session_context +) +{ + DBusConnection *conn = NULL; + DBusMessage *msg; + DBusMessageIter args; + DBusError err; + DBusPendingCall *pending; + dbus_bool_t bResult; + DBusMessageIter structIter; + DBusMessageIter ArrayIter; + int ret; + int iType; + dbus_uint32_t *session_serviceid_clockseqandnode_temp = NULL; + int session_serviceid_clockseqandnode_realsize; + dbus_int32_t di32Temp; + dbus_uint32_t dui32Temp; + dbus_uint64_t dui64Temp; + char buf[2]; + buf[0] = DBUS_TYPE_UINT32; + buf[1] = '\0'; + + // initialiset the errors + dbus_error_init(&err); + + char dbusname[1024]; + if (conn == NULL) + { + // connect to the system bus and check for errors + conn = dbus_bus_get_private(DBUS_BUS_SESSION, &err); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Connection Error (%s)\n", err.message); + dbus_error_free(&err); + } + if (NULL == conn) + { + return -1; + } + + memset((uint8_t *) dbusname, 0, 1024); + struct timeval tv; + gettimeofday(&tv, NULL); + uint64_t u64time = (long unsigned int) (tv.tv_sec * 1000000 + tv.tv_usec); + srand(u64time); + sprintf(dbusname, + "%s.method.caller%16.16lx%16.16lx", + workername, + u64time, + (long unsigned int) rand() + ); + // request our name on the bus + ret = + dbus_bus_request_name( + conn, + dbusname, + DBUS_NAME_FLAG_REPLACE_EXISTING, + &err + ); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Name Error (%s)\n", err.message); + dbus_error_free(&err); + dbus_connection_flush(conn); + } + if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) + { + dbus_connection_flush(conn); + return -1; + } + } + + // create a new method call and check for errors + char objname[1024]; + char interfacename[1024]; + memset((uint8_t *) dbusname, 0, 1024); + sprintf(dbusname, "%s.method.server", workername); + memset((uint8_t *) objname, 0, 1024); + sprintf(objname, "/%s/method/Object", workername); + memset((uint8_t *) interfacename, 0, 1024); + sprintf(interfacename, "%s.method.Type", workername); + msg = + dbus_message_new_method_call( + // "test.method.server", // target for the method call + dbusname, + // "/test/method/Object", // object to call on + objname, + // "test.method.Type", // interface to call on + interfacename, + "TEEC_CloseSession" + ); + if (NULL == msg) + { + fprintf(stderr, "Message Null\n"); + dbus_connection_flush(conn); + return -1; + } + + // append arguments + dbus_message_iter_init_append(msg, &args); + dbus_message_iter_open_container( + &args, + DBUS_TYPE_STRUCT, + NULL, + &structIter + ); + + dui32Temp = in_session_seesionid; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_session_serviceid_timelow; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_session_serviceid_timemid; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_session_serviceid_timehiandver; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di32Temp = in_session_serviceid_clockseqandnode_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + if (in_session_serviceid_clockseqandnode_size > 0 && + in_session_serviceid_clockseqandnode != NULL) + { + dbus_message_iter_open_container( + &structIter, + DBUS_TYPE_ARRAY, + buf, + &ArrayIter + ); + + bResult = + dbus_message_iter_append_fixed_array( + &ArrayIter, + DBUS_TYPE_UINT32, + &in_session_serviceid_clockseqandnode, + in_session_serviceid_clockseqandnode_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + } + + dui32Temp = in_session_opscnt; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + + dui64Temp = in_session_head_next; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_session_head_prev; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_session_context; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_close_container( + &args, + &structIter + ); + + // send message and get a handle for a reply + if (!dbus_connection_send_with_reply(conn, msg, &pending, -1)) + { // -1 is default timeout + fprintf(stderr, "Out Of Memory!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + if (NULL == pending) + { + fprintf(stderr, "Pending Call Null\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_connection_flush(conn); + dbus_message_unref(msg); + + printf("\n"); + printf("Method Call Teec Close Session Sent. \n"); + + // block until we recieve a reply + dbus_pending_call_block(pending); + + // get the reply message + msg = dbus_pending_call_steal_reply(pending); + if (NULL == msg) + { + fprintf(stderr, "Reply Null\n"); + return -1; + } + + // free the pending message handle + dbus_pending_call_unref(pending); + + // read the parameters + bResult = + dbus_message_iter_init( + msg, + &args + ); + if (!bResult) + { + fprintf(stderr, "Message has no arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_recurse( + &args, + &structIter + ); + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_seesionid = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_serviceid_timelow = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_serviceid_timemid = dui32Temp; + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_serviceid_timehiandver = dui32Temp; + + + bResult = + dbus_message_iter_next( + &structIter + ); + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_serviceid_clockseqandnode_outsize = dui32Temp; + + if (*session_serviceid_clockseqandnode_outsize > 0) + { + bResult = + dbus_message_iter_next( + &structIter + ); + + dbus_message_iter_recurse( + &structIter, + &ArrayIter); + + iType = + dbus_message_iter_get_arg_type( + &ArrayIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_fixed_array( + &ArrayIter, + &session_serviceid_clockseqandnode_temp, + &session_serviceid_clockseqandnode_realsize + ); + } + + bResult = + dbus_message_iter_next( + &structIter + ); + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_opscnt = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *session_head_next = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *session_head_prev = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *session_context = dui64Temp; + + + printf("Got Reply of Method Call Teec Close Session: \n"); + printf(" session_seesionid = 0x %8.8x \n", + *session_seesionid + ); +#if 0 + printf(" TEEC_Session session_serviceid_timelow = 0x %8.8x \n", + *session_serviceid_timelow + ); + printf(" TEEC_Session session_serviceid_timemid = 0x %8.8x \n", + *session_serviceid_timemid + ); + printf(" TEEC_Session session_serviceid_timehiandver = 0x %8.8x \n", + *session_serviceid_timehiandver + ); + printf(" TEEC_Session session_serviceid_clockseqandnode = \n"); + printf(" "); + for (int i = 0; i < session_serviceid_clockseqandnode_realsize; i++) { + printf(" %2.2x", + session_serviceid_clockseqandnode_temp[i] + ); + } + printf("\n"); + printf(" TEEC_Session clockseqandnode_outsize = 0x %8.8x \n", + *session_serviceid_clockseqandnode_outsize + ); + printf(" TEEC_Session session_opscnt = 0x %8.8x \n", + *session_opscnt + ); + printf(" TEEC_Session session_head_next = 0x %16.16lx \n", + *session_head_next + ); + printf(" TEEC_Session session_head_prev = 0x %16.16lx \n", + *session_head_prev + ); +#endif + printf(" session_context = 0x %16.16lx \n", + *session_context + ); + + if (session_serviceid_clockseqandnode_size >= session_serviceid_clockseqandnode_realsize && + session_serviceid_clockseqandnode_temp != NULL && + session_serviceid_clockseqandnode_realsize > 0 + ) + { + memcpy( + session_serviceid_clockseqandnode, + session_serviceid_clockseqandnode_temp, + session_serviceid_clockseqandnode_realsize * sizeof(uint32_t) + ); + *session_serviceid_clockseqandnode_outsize = session_serviceid_clockseqandnode_realsize; + } else + { + // dbus_message_unref(msg); + // return -1; + *session_serviceid_clockseqandnode_outsize = 0; + } + + // free msg + dbus_message_unref(msg); + + dbus_connection_close(conn); + dbus_connection_unref(conn); + + return 0; +} + + +int32_t +method_call_teec_invokecommand( + const char *workername, + + uint32_t in_session_sessionid, + uint32_t in_session_serviceid_timelow, + uint32_t in_session_serviceid_timemid, + uint32_t in_session_serviceid_timehiandver, + uint32_t *in_session_serviceid_clockseqandnode, + uint32_t in_session_serviceid_clockseqandnode_size, + uint32_t in_session_opscnt, + uint64_t in_session_head_next, + uint64_t in_session_head_prev, + uint64_t in_session_context, + + uint32_t commandid, + + uint32_t in_operation_started, + uint32_t in_operation_paramtypes, + + uint64_t in_operation_param1_tmpref_buffer, + uint32_t in_operation_param1_tmpref_size, + uint64_t in_operation_param1_memref_parent, + uint32_t in_operation_param1_memref_parent_flag, + uint32_t in_operation_param1_memref_size, + uint32_t in_operation_param1_memref_offset, + uint32_t in_operation_param1_value_a, + uint32_t in_operation_param1_value_b, + int32_t in_operation_param1_ionref_ionsharefd, + uint32_t in_operation_param1_ionref_ionsize, + + uint64_t in_operation_param2_tmpref_buffer, + uint32_t in_operation_param2_tmpref_size, + uint64_t in_operation_param2_memref_parent, + uint32_t in_operation_param2_memref_parent_flag, + uint32_t in_operation_param2_memref_size, + uint32_t in_operation_param2_memref_offset, + uint32_t in_operation_param2_value_a, + uint32_t in_operation_param2_value_b, + int32_t in_operation_param2_ionref_ionsharefd, + uint32_t in_operation_param2_ionref_ionsize, + + uint64_t in_operation_param3_tmpref_buffer, + uint32_t in_operation_param3_tmpref_size, + uint64_t in_operation_param3_memref_parent, + uint32_t in_operation_param3_memref_parent_flag, + uint32_t in_operation_param3_memref_size, + uint32_t in_operation_param3_memref_offset, + uint32_t in_operation_param3_value_a, + uint32_t in_operation_param3_value_b, + int32_t in_operation_param3_ionref_ionsharefd, + uint32_t in_operation_param3_ionref_ionsize, + + uint64_t in_operation_param4_tmpref_buffer, + uint32_t in_operation_param4_tmpref_size, + uint64_t in_operation_param4_memref_parent, + uint32_t in_operation_param4_memref_parent_flag, + uint32_t in_operation_param4_memref_size, + uint32_t in_operation_param4_memref_offset, + uint32_t in_operation_param4_value_a, + uint32_t in_operation_param4_value_b, + int32_t in_operation_param4_ionref_ionsharefd, + uint32_t in_operation_param4_ionref_ionsize, + + uint64_t in_operation_session, + int32_t in_operation_cancelflag, + + uint32_t in_returnorigin, + + uint32_t *in_buffer1, + uint32_t in_buffer1_size, + uint32_t *in_buffer2, + uint32_t in_buffer2_size, + uint32_t *in_buffer3, + uint32_t in_buffer3_size, + uint32_t *in_buffer4, + uint32_t in_buffer4_size, + + int32_t lt_flag, + + uint32_t *teecresult, + + uint32_t *session_sessionid, + uint32_t *session_serviceid_timelow, + uint32_t *session_serviceid_timemid, + uint32_t *session_serviceid_timehiandver, + uint32_t *session_serviceid_clockseqandnode, + int32_t session_serviceid_clockseqandnode_size, + uint32_t *session_serviceid_clockseqandnode_outsize, + uint32_t *session_opscnt, + uint64_t *session_head_next, + uint64_t *session_head_prev, + uint64_t *session_context, + + uint32_t *operation_started, + uint32_t *operation_paramtypes, + + uint64_t *operation_param1_tmpref_buffer, + uint32_t *operation_param1_tmpref_size, + uint64_t *operation_param1_memref_parent, + uint32_t *operation_param1_memref_parent_flag, + uint32_t *operation_param1_memref_size, + uint32_t *operation_param1_memref_offset, + uint32_t *operation_param1_value_a, + uint32_t *operation_param1_value_b, + int32_t *operation_param1_ionref_ionsharefd, + uint32_t *operation_param1_ionref_ionsize, + + uint64_t *operation_param2_tmpref_buffer, + uint32_t *operation_param2_tmpref_size, + uint64_t *operation_param2_memref_parent, + uint32_t *operation_param2_memref_parent_flag, + uint32_t *operation_param2_memref_size, + uint32_t *operation_param2_memref_offset, + uint32_t *operation_param2_value_a, + uint32_t *operation_param2_value_b, + int32_t *operation_param2_ionref_ionsharefd, + uint32_t *operation_param2_ionref_ionsize, + + uint64_t *operation_param3_tmpref_buffer, + uint32_t *operation_param3_tmpref_size, + uint64_t *operation_param3_memref_parent, + uint32_t *operation_param3_memref_parent_flag, + uint32_t *operation_param3_memref_size, + uint32_t *operation_param3_memref_offset, + uint32_t *operation_param3_value_a, + uint32_t *operation_param3_value_b, + int32_t *operation_param3_ionref_ionsharefd, + uint32_t *operation_param3_ionref_ionsize, + + uint64_t *operation_param4_tmpref_buffer, + uint32_t *operation_param4_tmpref_size, + uint64_t *operation_param4_memref_parent, + uint32_t *operation_param4_memref_parent_flag, + uint32_t *operation_param4_memref_size, + uint32_t *operation_param4_memref_offset, + uint32_t *operation_param4_value_a, + uint32_t *operation_param4_value_b, + int32_t *operation_param4_ionref_ionsharefd, + uint32_t *operation_param4_ionref_ionsize, + + uint64_t *operation_session, + int32_t *operation_cancelflag, + + uint32_t *returnorigin, + + uint32_t *buffer1, + uint32_t buffer1_size, + uint32_t *buffer1_outsize, + uint32_t *buffer2, + uint32_t buffer2_size, + uint32_t *buffer2_outsize, + uint32_t *buffer3, + uint32_t buffer3_size, + uint32_t *buffer3_outsize, + uint32_t *buffer4, + uint32_t buffer4_size, + uint32_t *buffer4_outsize +) +{ + DBusConnection *conn = NULL; + DBusMessage *msg; + DBusMessageIter args; + DBusError err; + DBusPendingCall *pending; + dbus_bool_t bResult; + DBusMessageIter structIter; + DBusMessageIter ArrayIter; + int ret; + int iType; + dbus_uint32_t *session_serviceid_clockseqandnode_temp = NULL; + int session_serviceid_clockseqandnode_realsize; + dbus_int32_t di32Temp; + dbus_uint32_t dui32Temp; + dbus_uint64_t dui64Temp; + char buf[2]; + buf[0] = DBUS_TYPE_UINT32; + buf[1] = '\0'; + + dbus_uint32_t *buffer1_temp = NULL; + int buffer1_realsize; + dbus_uint32_t *buffer2_temp = NULL; + int buffer2_realsize; + dbus_uint32_t *buffer3_temp = NULL; + int buffer3_realsize; + dbus_uint32_t *buffer4_temp = NULL; + int buffer4_realsize; + + + // initialiset the errors + dbus_error_init(&err); + + char dbusname[1024]; + if (conn == NULL) + { + // connect to the system bus and check for errors + conn = dbus_bus_get_private(DBUS_BUS_SESSION, &err); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Connection Error (%s)\n", err.message); + dbus_error_free(&err); + } + if (NULL == conn) + { + return -1; + } + + memset((uint8_t *) dbusname, 0, 1024); + struct timeval tv; + gettimeofday(&tv, NULL); + uint64_t u64time = (long unsigned int) (tv.tv_sec * 1000000 + tv.tv_usec); + srand(u64time); + sprintf(dbusname, + "%s.method.caller%16.16lx%16.16lx", + workername, + u64time, + (long unsigned int) rand() + ); + // request our name on the bus + ret = + dbus_bus_request_name( + conn, + dbusname, + DBUS_NAME_FLAG_REPLACE_EXISTING, + &err + ); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Name Error (%s)\n", err.message); + dbus_error_free(&err); + dbus_connection_flush(conn); + } + if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) + { + dbus_connection_flush(conn); + return -1; + } + } + + // create a new method call and check for errors + char objname[1024]; + char interfacename[1024]; + memset((uint8_t *) dbusname, 0, 1024); + sprintf(dbusname, "%s.method.server", workername); + memset((uint8_t *) objname, 0, 1024); + sprintf(objname, "/%s/method/Object", workername); + memset((uint8_t *) interfacename, 0, 1024); + sprintf(interfacename, "%s.method.Type", workername); + msg = + dbus_message_new_method_call( + // "test.method.server", // target for the method call + dbusname, + // "/test/method/Object", // object to call on + objname, + // "test.method.Type", // interface to call on + interfacename, + "TEEC_InvokeCommand" + ); + if (NULL == msg) + { + fprintf(stderr, "Message Null\n"); + dbus_connection_flush(conn); + return -1; + } + + + // append arguments + dbus_message_iter_init_append(msg, &args); + dbus_message_iter_open_container( + &args, + DBUS_TYPE_STRUCT, + NULL, + &structIter + ); + + + dui32Temp = in_session_sessionid; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_session_serviceid_timelow; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_session_serviceid_timemid; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_session_serviceid_timehiandver; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_session_serviceid_clockseqandnode_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + if (in_session_serviceid_clockseqandnode_size > 0 && + in_session_serviceid_clockseqandnode != NULL) + { + dbus_message_iter_open_container( + &structIter, + DBUS_TYPE_ARRAY, + buf, + &ArrayIter + ); + + bResult = + dbus_message_iter_append_fixed_array( + &ArrayIter, + DBUS_TYPE_UINT32, + &in_session_serviceid_clockseqandnode, + in_session_serviceid_clockseqandnode_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + } + + dui32Temp = in_session_opscnt; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_session_head_next; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_session_head_prev; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_session_context; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + + dui32Temp = commandid; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + + dui32Temp = in_operation_started; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_paramtypes; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param1_tmpref_buffer; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param1_tmpref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param1_memref_parent; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param1_memref_parent_flag; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param1_memref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param1_memref_offset; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param1_value_a; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param1_value_b; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di32Temp = in_operation_param1_ionref_ionsharefd; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param1_ionref_ionsize; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param2_tmpref_buffer; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param2_tmpref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param2_memref_parent; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param2_memref_parent_flag; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param2_memref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param2_memref_offset; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param2_value_a; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param2_value_b; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di32Temp = in_operation_param2_ionref_ionsharefd; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param2_ionref_ionsize; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param3_tmpref_buffer; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param3_tmpref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param3_memref_parent; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param3_memref_parent_flag; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param3_memref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param3_memref_offset; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param3_value_a; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param3_value_b; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di32Temp = in_operation_param3_ionref_ionsharefd; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param3_ionref_ionsize; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param4_tmpref_buffer; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param4_tmpref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_param4_memref_parent; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param4_memref_parent_flag; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param4_memref_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param4_memref_offset; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param4_value_a; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param4_value_b; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di32Temp = in_operation_param4_ionref_ionsharefd; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_operation_param4_ionref_ionsize; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui64Temp = in_operation_session; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &dui64Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + di32Temp = in_operation_cancelflag; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_returnorigin; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dui32Temp = in_buffer1_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + if (in_buffer1_size > 0 && + in_buffer1 != NULL) + { + dbus_message_iter_open_container( + &structIter, + DBUS_TYPE_ARRAY, + buf, + &ArrayIter + ); + + bResult = + dbus_message_iter_append_fixed_array( + &ArrayIter, + DBUS_TYPE_UINT32, + &in_buffer1, + in_buffer1_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + } + + dui32Temp = in_buffer2_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + if (in_buffer2_size > 0 && + in_buffer2 != NULL) + { + dbus_message_iter_open_container( + &structIter, + DBUS_TYPE_ARRAY, + buf, + &ArrayIter + ); + + bResult = + dbus_message_iter_append_fixed_array( + &ArrayIter, + DBUS_TYPE_UINT32, + &in_buffer2, + in_buffer2_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + } + + dui32Temp = in_buffer3_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + if (in_buffer3_size > 0 && + in_buffer3 != NULL) + { + dbus_message_iter_open_container( + &structIter, + DBUS_TYPE_ARRAY, + buf, + &ArrayIter + ); + + bResult = + dbus_message_iter_append_fixed_array( + &ArrayIter, + DBUS_TYPE_UINT32, + &in_buffer3, + in_buffer3_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + } + + dui32Temp = in_buffer4_size; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &dui32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + if (in_buffer4_size > 0 && + in_buffer4 != NULL) + { + dbus_message_iter_open_container( + &structIter, + DBUS_TYPE_ARRAY, + buf, + &ArrayIter + ); + + bResult = + dbus_message_iter_append_fixed_array( + &ArrayIter, + DBUS_TYPE_UINT32, + &in_buffer4, + in_buffer4_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + } + + di32Temp = lt_flag; + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &di32Temp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + printf("Method Call Teec Invoke Command lt_flag %d Sent. \n",lt_flag); + + dbus_message_iter_close_container( + &args, + &structIter + ); + + // send message and get a handle for a reply + if (!dbus_connection_send_with_reply(conn, msg, &pending, -1)) + { // -1 is default timeout + fprintf(stderr, "Out Of Memory!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + if (NULL == pending) + { + fprintf(stderr, "Pending Call Null\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return -1; + } + + dbus_connection_flush(conn); + dbus_message_unref(msg); + + printf("\n"); + printf("Method Call Teec Invoke Command Sent. \n"); + + ///////////////////////////////////////////////////////////////////////////////////// + + // block until we recieve a reply + dbus_pending_call_block(pending); + + // get the reply message + msg = dbus_pending_call_steal_reply(pending); + if (NULL == msg) + { + fprintf(stderr, "Reply Null\n"); + return -1; + } + + // free the pending message handle + dbus_pending_call_unref(pending); + + // read the parameters + bResult = + dbus_message_iter_init( + msg, + &args + ); + if (!bResult) + { + fprintf(stderr, "Message has no arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + dbus_message_iter_recurse( + &args, + &structIter + ); + + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *teecresult = dui32Temp; + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_sessionid = dui32Temp; + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_serviceid_timelow = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_serviceid_timemid = dui32Temp; + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_message_unref(msg); + return -1; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_serviceid_timehiandver = dui32Temp; + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_serviceid_clockseqandnode_outsize = dui32Temp; + bResult = + dbus_message_iter_next( + &structIter + ); + + if (*session_serviceid_clockseqandnode_outsize > 0) + { + + dbus_message_iter_recurse( + &structIter, + &ArrayIter + ); + + iType = + dbus_message_iter_get_arg_type( + &ArrayIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_fixed_array( + &ArrayIter, + &session_serviceid_clockseqandnode_temp, + &session_serviceid_clockseqandnode_realsize + ); + bResult = + dbus_message_iter_next( + &structIter + ); + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *session_opscnt = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *session_head_next = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *session_head_prev = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *session_context = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_started = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_paramtypes = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param1_tmpref_buffer = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param1_tmpref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param1_memref_parent = dui64Temp; + + bResult = dbus_message_iter_next(&structIter); + iType = dbus_message_iter_get_arg_type(&structIter); + if (iType != DBUS_TYPE_UINT32) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param1_memref_parent_flag = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param1_memref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param1_memref_offset = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param1_value_a = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param1_value_b = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di32Temp + ); + *operation_param1_ionref_ionsharefd = di32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param1_ionref_ionsize = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param2_tmpref_buffer = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param2_tmpref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param2_memref_parent = dui64Temp; + + bResult = dbus_message_iter_next(&structIter); + iType = dbus_message_iter_get_arg_type(&structIter); + if (iType != DBUS_TYPE_UINT32) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param2_memref_parent_flag = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param2_memref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param2_memref_offset = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param2_value_a = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param2_value_b = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di32Temp + ); + *operation_param2_ionref_ionsharefd = di32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param2_ionref_ionsize = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param3_tmpref_buffer = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param3_tmpref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param3_memref_parent = dui64Temp; + + bResult = dbus_message_iter_next(&structIter); + iType = dbus_message_iter_get_arg_type(&structIter); + if (iType != DBUS_TYPE_UINT32) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param3_memref_parent_flag = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param3_memref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param3_memref_offset = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param3_value_a = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param3_value_b = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di32Temp + ); + *operation_param3_ionref_ionsharefd = di32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param3_ionref_ionsize = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param4_tmpref_buffer = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param4_tmpref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_param4_memref_parent = dui64Temp; + + bResult = dbus_message_iter_next(&structIter); + iType = dbus_message_iter_get_arg_type(&structIter); + if (iType != DBUS_TYPE_UINT32) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param4_memref_parent_flag = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param4_memref_size = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param4_memref_offset = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param4_value_a = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param4_value_b = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di32Temp + ); + *operation_param4_ionref_ionsharefd = di32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *operation_param4_ionref_ionsize = dui32Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui64Temp + ); + *operation_session = dui64Temp; + + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &di32Temp + ); + *operation_cancelflag = di32Temp; + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *returnorigin = dui32Temp; + bResult = + dbus_message_iter_next( + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *buffer1_outsize = dui32Temp; + bResult = + dbus_message_iter_next( + &structIter + ); + + if (*buffer1_outsize > 0) + { + dbus_message_iter_recurse( + &structIter, + &ArrayIter + ); + + iType = + dbus_message_iter_get_arg_type( + &ArrayIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_fixed_array( + &ArrayIter, + &buffer1_temp, + &buffer1_realsize + ); + bResult = + dbus_message_iter_next( + &structIter + ); + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *buffer2_outsize = dui32Temp; + bResult = + dbus_message_iter_next( + &structIter + ); + + if (*buffer2_outsize > 0) + { + dbus_message_iter_recurse( + &structIter, + &ArrayIter + ); + + iType = + dbus_message_iter_get_arg_type( + &ArrayIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_fixed_array( + &ArrayIter, + &buffer2_temp, + &buffer2_realsize + ); + bResult = + dbus_message_iter_next( + &structIter + ); + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *buffer3_outsize = dui32Temp; + bResult = + dbus_message_iter_next( + &structIter + ); + + if (*buffer3_outsize > 0) + { + dbus_message_iter_recurse( + &structIter, + &ArrayIter + ); + + iType = + dbus_message_iter_get_arg_type( + &ArrayIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_fixed_array( + &ArrayIter, + &buffer3_temp, + &buffer3_realsize + ); + bResult = + dbus_message_iter_next( + &structIter + ); + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_basic( + &structIter, + &dui32Temp + ); + *buffer4_outsize = dui32Temp; + + if (*buffer4_outsize > 0) + { + bResult = + dbus_message_iter_next( + &structIter + ); + + dbus_message_iter_recurse( + &structIter, + &ArrayIter + ); + + iType = + dbus_message_iter_get_arg_type( + &ArrayIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_message_unref(msg); + return -1; + } + dbus_message_iter_get_fixed_array( + &ArrayIter, + &buffer4_temp, + &buffer4_realsize + ); + } + + + printf("Got Reply of Method Call Teec Invoke Command: \n"); + printf(" teecresult = 0x %8.8x \n", + *teecresult); + printf(" session_seesionid = 0x %8.8x \n", + *session_sessionid + ); +#if 0 + printf(" TEEC_Session session_serviceid_timelow = 0x %8.8x \n", + *session_serviceid_timelow + ); + printf(" TEEC_Session session_serviceid_timemid = 0x %8.8x \n", + *session_serviceid_timemid + ); + printf(" TEEC_Session session_serviceid_timehiandver = 0x %8.8x \n", + *session_serviceid_timehiandver + ); + printf(" TEEC_Session session_serviceid_clockseqandnode = \n"); + if ( *session_serviceid_clockseqandnode_outsize > 0 && + session_serviceid_clockseqandnode_temp != NULL + ) + { + for (int i = 0; i < session_serviceid_clockseqandnode_realsize; i++) { + printf(" %2.2x", + session_serviceid_clockseqandnode_temp[i] + ); + } + printf("\n"); + } + printf(" TEEC_Session clockseqandnode_outsize = 0x %8.8x \n", + *session_serviceid_clockseqandnode_outsize + ); + printf(" TEEC_Session session_opscnt = 0x %8.8x \n", + *session_opscnt + ); + printf(" TEEC_Session session_head_next = 0x %16.16lx \n", + *session_head_next + ); + printf(" TEEC_Session session_head_prev = 0x %16.16lx \n", + *session_head_prev + ); + printf(" TEEC_Session session_context = 0x %16.16lx \n", + *session_context + ); + printf(" TEEC_Session session_context = 0x %16.16lx \n", + *session_context + ); + printf(" TEEC_Session operation_started = 0x %8.8x \n", + *operation_started + ); + printf(" TEEC_Session operation_paramtypes = 0x %8.8x \n", + *operation_paramtypes + ); + printf(" TEEC_Session operation_param1_tmpref_buffer = 0x %16.16lx \n", + *operation_param1_tmpref_buffer + ); + printf(" TEEC_Session operation_param1_tmpref_size = 0x %8.8x \n", + *operation_param1_tmpref_size + ); + printf(" TEEC_Session operation_param1_memref_parent = 0x %16.16lx \n", + *operation_param1_memref_parent + ); + printf(" TEEC_Session operation_param1_memref_size = 0x %8.8x \n", + *operation_param1_memref_size + ); + printf(" TEEC_Session operation_param1_memref_offse = 0x %8.8x \n", + *operation_param1_memref_offset + ); + printf(" TEEC_Session operation_param1_value_a = 0x %8.8x \n", + *operation_param1_value_a + ); + printf(" TEEC_Session operation_param1_value_b = 0x %8.8x \n", + *operation_param1_value_b + ); + printf(" TEEC_Session operation_param1_ionref_ionsharefd = 0x %8.8x \n", + (unsigned int)*operation_param1_ionref_ionsharefd + ); + printf(" TEEC_Session operation_param1_ionref_ionsize = 0x %8.8x \n", + *operation_param1_ionref_ionsize + ); + + printf(" TEEC_Session operation_param2_tmpref_buffer = 0x %16.16lx \n", + *operation_param2_tmpref_buffer + ); + printf(" TEEC_Session operation_param2_tmpref_size = 0x %8.8x \n", + *operation_param2_tmpref_size + ); + printf(" TEEC_Session operation_param2_memref_parent = 0x %16.16lx \n", + *operation_param2_memref_parent + ); + printf(" TEEC_Session operation_param2_memref_size = 0x %8.8x \n", + *operation_param2_memref_size + ); + printf(" TEEC_Session operation_param2_memref_offset = 0x %8.8x \n", + *operation_param2_memref_offset + ); + printf(" TEEC_Session operation_param2_value_a = 0x %8.8x \n", + *operation_param2_value_a + ); + printf(" TEEC_Session operation_param2_value_b = 0x %8.8x \n", + *operation_param2_value_b + ); + printf(" TEEC_Session operation_param2_ionref_ionsharefd = 0x %8.8x \n", + (unsigned int)*operation_param2_ionref_ionsharefd + ); + printf(" TEEC_Session operation_param2_ionref_ionsize = 0x %8.8x \n", + *operation_param2_ionref_ionsize + ); + + printf(" TEEC_Session operation_param3_tmpref_buffer = 0x %16.16lx \n", + *operation_param3_tmpref_buffer + ); + printf(" TEEC_Session operation_param3_tmpref_size = 0x %8.8x \n", + *operation_param3_tmpref_size + ); + printf(" TEEC_Session operation_param3_memref_parent = 0x %16.16lx \n", + *operation_param3_memref_parent + ); + printf(" TEEC_Session operation_param3_memref_size = 0x %8.8x \n", + *operation_param3_memref_size + ); + printf(" TEEC_Session operation_param3_memref_offset = 0x %8.8x \n", + *operation_param3_memref_offset + ); + printf(" TEEC_Session operation_param3_value_a = 0x %8.8x \n", + *operation_param3_value_a + ); + printf(" TEEC_Session operation_param3_value_b = 0x %8.8x \n", + *operation_param3_value_b + ); + printf(" TEEC_Session operation_param3_ionref_ionsharefd = 0x %8.8x \n", + (unsigned int)*operation_param3_ionref_ionsharefd + ); + printf(" TEEC_Session operation_param3_ionref_ionsize = 0x %8.8x \n", + *operation_param3_ionref_ionsize + ); + + printf(" TEEC_Session operation_param4_tmpref_buffer = 0x %16.16lx \n", + *operation_param4_tmpref_buffer + ); + printf(" TEEC_Session operation_param4_tmpref_size = 0x %8.8x \n", + *operation_param4_tmpref_size + ); + printf(" TEEC_Session operation_param4_memref_parent = 0x %16.16lx \n", + *operation_param4_memref_parent + ); + printf(" TEEC_Session operation_param4_memref_size = 0x %8.8x \n", + *operation_param4_memref_size + ); + printf(" TEEC_Session operation_param4_memref_offset = 0x %8.8x \n", + *operation_param4_memref_offset + ); + printf(" TEEC_Session operation_param4_value_a = 0x %8.8x \n", + *operation_param4_value_a + ); + printf(" TEEC_Session operation_param4_value_b = 0x %8.8x \n", + *operation_param4_value_b + ); + printf(" TEEC_Session operation_param4_ionref_ionsharefd = 0x %8.8x \n", + (unsigned int)*operation_param4_ionref_ionsharefd + ); + printf(" TEEC_Session operation_param4_ionref_ionsize = 0x %8.8x \n", + *operation_param4_ionref_ionsize + ); + + printf(" TEEC_Session operation_session = 0x %16.16lx \n", + *operation_session + ); + printf(" TEEC_Session operation_cancelflag = 0x %8.8x \n", + (unsigned int)*operation_cancelflag + ); + printf(" returnorigin = 0x %8.8x \n", + *returnorigin + ); + + printf(" buffer1 = \n"); + if (buffer1_temp != NULL) + { + for (int i = 0; i < buffer1_realsize; i++) { + printf(" %2.2x", + buffer1_temp[i] + ); + } + printf("\n"); + } + printf(" buffer1_outsize = 0x %8.8x \n", + *buffer1_outsize + ); + + printf(" buffer2 = \n"); + if (buffer2_temp != NULL) + { + for (int i = 0; i < buffer2_realsize; i++) { + printf(" %2.2x", + buffer2_temp[i] + ); + } + printf("\n"); + } + printf(" buffer2_outsize = 0x %8.8x \n", + *buffer2_outsize + ); + + printf(" buffer3 = \n"); + if (buffer3_temp != NULL) + { + for (int i = 0; i < buffer3_realsize; i++) { + printf(" %2.2x", + buffer3_temp[i] + ); + } + printf("\n"); + } + printf(" buffer3_outsize = 0x %8.8x \n", + *buffer3_outsize + ); + + if (buffer4_temp != NULL) + { + printf(" buffer4 = \n"); + for (int i = 0; i < buffer4_realsize; i++) { + printf(" %2.2x", + buffer4_temp[i] + ); + } + printf("\n"); + } + printf(" buffer4_outsize = 0x %8.8x \n", + *buffer4_outsize + ); +#endif + + if (session_serviceid_clockseqandnode_size >= session_serviceid_clockseqandnode_realsize && + session_serviceid_clockseqandnode != NULL && + session_serviceid_clockseqandnode_temp != NULL && + session_serviceid_clockseqandnode_realsize > 0 + ) + { + memcpy( + session_serviceid_clockseqandnode, + session_serviceid_clockseqandnode_temp, + session_serviceid_clockseqandnode_realsize * sizeof(uint32_t) + ); + *session_serviceid_clockseqandnode_outsize = session_serviceid_clockseqandnode_realsize; + } else + { + // dbus_message_unref(msg); + // return -1; + *session_serviceid_clockseqandnode_outsize = 0; + } + + if (buffer1_size >= (uint32_t) buffer1_realsize && + buffer1 != NULL && + buffer1_temp != NULL && + buffer1_realsize > 0 + ) + { + memcpy( + buffer1, + buffer1_temp, + buffer1_realsize * sizeof(uint32_t) + ); + *buffer1_outsize = buffer1_realsize; + } else + { + // dbus_message_unref(msg); + // return -1; + *buffer1_outsize = 0; + } + + if (buffer2_size >= (uint32_t) buffer2_realsize && + buffer2 != NULL && + buffer2_temp != NULL && + buffer2_realsize > 0 + ) + { + memcpy( + buffer2, + buffer2_temp, + buffer2_realsize * sizeof(uint32_t) + ); + *buffer2_outsize = buffer2_realsize; + } else + { + // dbus_message_unref(msg); + // return -1; + *buffer2_outsize = 0; + } + + if (buffer3_size >= (uint32_t) buffer3_realsize && + buffer3 != NULL && + buffer3_temp != NULL && + buffer3_realsize > 0 + ) + { + memcpy( + buffer3, + buffer3_temp, + buffer3_realsize * sizeof(uint32_t) + ); + *buffer3_outsize = buffer3_realsize; + } else + { + // dbus_message_unref(msg); + // return -1; + *buffer3_outsize = 0; + } + + if (buffer4_size >= (uint32_t) buffer4_realsize && + buffer4 != NULL && + buffer4_temp != NULL && + buffer4_realsize > 0 + ) + { + memcpy( + buffer4, + buffer4_temp, + buffer4_realsize * sizeof(uint32_t) + ); + *buffer4_outsize = buffer4_realsize; + } else + { + // dbus_message_unref(msg); + // return -1; + *buffer4_outsize = 0; + } + + + // free msg + dbus_message_unref(msg); + + dbus_connection_close(conn); + dbus_connection_unref(conn); + + return 0; +} + + +/** + * Call a method on a remote object + */ +void +method_call_destroy_threadpool( + const char *workername +) +{ + DBusConnection *conn = NULL; + DBusMessage *msg; + DBusMessageIter args; + // DBusConnection* conn; + DBusError err; + DBusPendingCall *pending; + dbus_bool_t bResult; + int ret; + int iType; + unsigned char name[] = "threadpool"; + unsigned char *charp; + dbus_uint32_t retcode; + + // initialiset the errors + dbus_error_init(&err); + + char dbusname[1024]; + if (conn == NULL) + { + // connect to the system bus and check for errors + conn = dbus_bus_get_private(DBUS_BUS_SESSION, &err); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Connection Error (%s)\n", err.message); + dbus_error_free(&err); + } + if (NULL == conn) + { + return; + } + + memset((uint8_t *) dbusname, 0, 1024); + struct timeval tv; + gettimeofday(&tv, NULL); + uint64_t u64time = (long unsigned int) (tv.tv_sec * 1000000 + tv.tv_usec); + srand(u64time); + sprintf(dbusname, + "%s.method.caller%16.16lx%16.16lx", + workername, + u64time, + (long unsigned int) rand() + ); + // request our name on the bus + ret = + dbus_bus_request_name( + conn, + dbusname, + DBUS_NAME_FLAG_REPLACE_EXISTING, + &err + ); + if (dbus_error_is_set(&err)) + { + fprintf(stderr, "Name Error (%s)\n", err.message); + dbus_error_free(&err); + dbus_connection_flush(conn); + } + if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) + { + dbus_connection_flush(conn); + return; + } + } + + // create a new method call and check for errors + char objname[1024]; + char interfacename[1024]; + memset((uint8_t *) dbusname, 0, 1024); + sprintf(dbusname, "%s.method.server", workername); + memset((uint8_t *) objname, 0, 1024); + sprintf(objname, "/%s/method/Object", workername); + memset((uint8_t *) interfacename, 0, 1024); + sprintf(interfacename, "%s.method.Type", workername); + msg = + dbus_message_new_method_call( + // "test.method.server", // target for the method call + dbusname, + // "/test/method/Object", // object to call on + objname, + // "test.method.Type", // interface to call on + interfacename, + "Destroy" // method name + ); + if (NULL == msg) + { + fprintf(stderr, "Message Null\n"); + dbus_connection_flush(conn); + return; + } + + + // append arguments + dbus_message_iter_init_append(msg, &args); + + charp = name; + if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &charp)) + { + fprintf(stderr, "Out Of Memory!\n"); + exit(1); + } + + // send message and get a handle for a reply + if (!dbus_connection_send_with_reply(conn, msg, &pending, -1)) + { // -1 is default timeout + fprintf(stderr, "Out Of Memory!\n"); + exit(1); + } + if (NULL == pending) + { + fprintf(stderr, "Pending Call Null\n"); + exit(1); + } + dbus_connection_flush(conn); + + printf("\n"); + printf("Method Call Destroy Threadpool Sent. \n"); + + // free message + dbus_message_unref(msg); + + // block until we recieve a reply + dbus_pending_call_block(pending); + + // get the reply message + msg = dbus_pending_call_steal_reply(pending); + if (NULL == msg) + { + fprintf(stderr, "Reply Null\n"); + exit(1); + } + // free the pending message handle + dbus_pending_call_unref(pending); + + // read the parameters + bResult = + dbus_message_iter_init( + msg, + &args + ); + if (!bResult) + { + fprintf(stderr, "Message has no arguments!\n"); + exit(1); + } + + iType = + dbus_message_iter_get_arg_type( + &args + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + exit(1); + } + dbus_message_iter_get_basic( + &args, + &retcode + ); + + printf("Got Reply of Method Call Destroy Threadpool: \n"); + printf(" retcode = 0x%8x \n", retcode); + + // free reply + dbus_message_unref(msg); + + dbus_connection_close(conn); + dbus_connection_unref(conn); +} + + +#ifdef GP_PROXY_WORKER + +void * +reply_to_method_call_teec_inicont( + // DBusMessage* msg, + // DBusConnection* conn + void *thdfargs +) +{ + DBusMsgConn *DBusMCP; + DBusMessage *msg; + DBusConnection *conn; + DBusMessage *reply; + DBusMessageIter args; + dbus_bool_t bResult; + DBusMessageIter structIter; + int iType; + unsigned char *charp; + // char* param = ""; + unsigned char *name = NULL; + dbus_int32_t name_size; + dbus_int32_t in_fd; + unsigned char *in_ta_path = NULL; + dbus_int32_t in_ta_path_size; + dbus_uint64_t in_session_list_next; + dbus_uint64_t in_session_list_prev; + dbus_uint64_t in_shrd_mem_list_next; + dbus_uint64_t in_shrd_mem_list_prev; + dbus_uint64_t in_share_buffer_buffer; + dbus_int64_t in_share_buffer_buffer_barrier; + dbus_uint32_t teecresult; + dbus_int32_t fd; + // unsigned char ta_path[] = "/vendor/bin/rsa_demo_ta"; + // dbus_int32_t ta_path_size = strlen((const char *)ta_path); + unsigned char *ta_path = NULL; + dbus_int32_t ta_path_size = 0; + dbus_uint64_t session_list_next; + dbus_uint64_t session_list_prev; + dbus_uint64_t shrd_mem_list_next; + dbus_uint64_t shrd_mem_list_prev; + dbus_uint64_t share_buffer_buffer; + dbus_int64_t share_buffer_buffer_barrier; + dbus_uint64_t context_addr; + dbus_uint32_t serial = 0; + +#ifdef GP_PROXY + pthread_mutex_t * mutex_workerrec; + pthread_cond_t * cond_notbusy; + wr_t * workerrec; +#endif + +#ifdef GP_WORKER + pthread_mutex_t *mutex_tcl; + pthread_mutex_t *mutex_tsl; + tcl_t *tcl; + tsl_t *tsl; +#endif + + DBusMCP = (DBusMsgConn *) thdfargs; + msg = DBusMCP->msg; + conn = DBusMCP->conn; +#ifdef GP_PROXY + mutex_workerrec = DBusMCP->mutex_workerrec; + cond_notbusy = DBusMCP->cond_notbusy; + workerrec = DBusMCP->workerrec; +#endif +#ifdef GP_WORKER + mutex_tcl = DBusMCP->mutex_tcl; + mutex_tsl = DBusMCP->mutex_tsl; + tcl = DBusMCP->tcl; + tsl = DBusMCP->tsl; +#endif + + // read the parameters + bResult = + dbus_message_iter_init( + msg, + &args + ); + if (!bResult) + { + fprintf(stderr, "Message has no arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_recurse( + &args, + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &name_size); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (name_size > 0) + { + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_STRING + ) + { + fprintf(stderr, "Argument is not STRING.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &name); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_fd); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_ta_path_size + ); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + // fprintf(stderr, "Debug in_ta_path_size = %d \n", in_ta_path_size); + if (in_ta_path_size > 0) + { + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_STRING + ) + { + fprintf(stderr, "Argument is not STRING.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_ta_path); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_list_next); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_list_prev); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_shrd_mem_list_next); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_shrd_mem_list_prev); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_share_buffer_buffer); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT64 + ) + { + fprintf(stderr, "Argument is not INT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_share_buffer_buffer_barrier); + + printf("Received method call Teec Initialize Context: \n"); + printf(" in name = %s \n", name); + printf(" in name_size = %d \n", name_size); + printf(" in_fd = 0x %8.8x \n", in_fd); + printf(" in_ta_path = %s \n", in_ta_path); + printf(" in_ta_path_size = %d \n", in_ta_path_size); +#if 0 + printf(" in_session_list_next = 0x %16.16lx \n", in_session_list_next); + printf(" in_session_list_prev = 0x %16.16lx \n", in_session_list_prev); + printf(" in_shrd_mem_list_next = 0x %16.16lx \n", in_shrd_mem_list_next); + printf(" in_shrd_mem_list_prev = 0x %16.16lx \n", in_shrd_mem_list_prev); + printf(" in_share_buffer_buffer = 0x %16.16lx \n", in_share_buffer_buffer); + printf(" in_share_buffer_buffer_barrier = 0x %16.16lx \n", in_share_buffer_buffer_barrier); +#endif + +#ifdef GP_WORKER + //////////////////////////////////////////////////////////////////////////////////////////////// + TEEC_Context *contextIns = (TEEC_Context *) malloc(sizeof(TEEC_Context)); + + TEEC_Result result; + + contextIns->fd = in_fd; + contextIns->ta_path = in_ta_path; + contextIns->session_list.next = (struct ListNode *) in_session_list_next; + contextIns->session_list.prev = (struct ListNode *) in_session_list_prev; + contextIns->shrd_mem_list.next = (struct ListNode *) in_shrd_mem_list_next; + contextIns->shrd_mem_list.prev = (struct ListNode *) in_shrd_mem_list_prev; + contextIns->share_buffer.buffer = (void *) in_share_buffer_buffer; + contextIns->share_buffer.buffer_barrier.__align = (long long int) in_share_buffer_buffer_barrier; + // typedef struct { + // volatile int __val[4*sizeof(long)/sizeof(int)]; + // } sem_t; + // + // typedef union + // { + // char __size[__SIZEOF_SEM_T]; + // long long int __align; + // } sem_t; + struct timeval start, end; + gettimeofday(&start, NULL); + result = TEEC_InitializeContext(NULL, contextIns); + gettimeofday(&end, NULL); + uint32_t cost = 0; + cost += (1000000 * end.tv_sec + end.tv_usec) - (1000000 * start.tv_sec + start.tv_usec); + if (result != TEEC_SUCCESS) + { + printf("Teec InitilizeContext Failed.\n"); + printf(" teecresult = 0x %8.8x.\n", result); + + teecresult = result; + fd = 0; + ta_path_size = 0; + ta_path = NULL; + charp = ta_path; + session_list_next = 0; + session_list_prev = 0; + shrd_mem_list_next = 0; + shrd_mem_list_prev = 0; + share_buffer_buffer = 0; + share_buffer_buffer_barrier = 0; + context_addr = 0; + } else + { + printf("Teec InitilizeContext Succed, cost time: %ld us \n", cost); + + tcn_t *tcnIns = (tcn_t *) malloc(sizeof(tcn_t)); + tcnIns->self = contextIns; + struct timeval tvcreate; + gettimeofday(&tvcreate, NULL); + tcnIns->createtime = tvcreate; + + pthread_mutex_lock(mutex_tcl); + if (tcl->first == NULL) + { + tcnIns->next = NULL; + tcnIns->prev = NULL; + tcl->first = tcnIns; + tcl->last = tcnIns; + tcl->count = 1; + } else + { + tcnIns->prev = tcl->last; + tcnIns->next = NULL; + tcl->last->next = tcnIns; + tcl->last = tcnIns; + tcl->count = tcl->count + 1; + } + pthread_mutex_unlock(mutex_tcl); + + teecresult = result; + fd = contextIns->fd; + if (contextIns->ta_path != NULL) + { + ta_path_size = strlen((const char *) contextIns->ta_path); + } else + { + ta_path_size = 0; + } + ta_path = contextIns->ta_path; + charp = ta_path; + session_list_next = (dbus_uint64_t) contextIns->session_list.next; + session_list_prev = (dbus_uint64_t) contextIns->session_list.prev; + shrd_mem_list_next = (dbus_uint64_t) contextIns->shrd_mem_list.next; + shrd_mem_list_prev = (dbus_uint64_t) contextIns->shrd_mem_list.prev; + share_buffer_buffer = (dbus_uint64_t) contextIns->share_buffer.buffer; + share_buffer_buffer_barrier = contextIns->share_buffer.buffer_barrier.__align; + + // context_addr = (dbus_uint64_t)contextIns; + struct timeval tv; + gettimeofday(&tv, NULL); + uint64_t u64time = (long unsigned int) (tv.tv_sec * 1000000 + tv.tv_usec); + srand(u64time); + context_addr = (dbus_uint64_t) DBusMCP->workernum + + u64time + + (long unsigned int) rand(); + + printf(" context fd = 0x %8.8x \n", contextIns->fd); + printf(" context address = 0x %16.16lx \n", context_addr); + } + + // TEEC_FinalizeContext(&contextIns); + // printf("Teec FinalizedContext.\n"); + //////////////////////////////////////////////////////////////////////////////////////////////// +#else + ta_path = (unsigned char *)malloc(1024 * sizeof(char)); + ta_path_size = 1024; + memset((char *)ta_path, 0, 1024); + uint32_t context_tapath_outsize; + + char workername[1024]; + memset((char *)workername, 0, 1024); + int ifound = 0; + int iworker; + for( ; ; ) + { + pthread_mutex_lock(mutex_workerrec); + for (iworker = 0; iworker < MAX_NUM_WORKER; iworker++) + { + if (workerrec[iworker].busy == 0) + { + sprintf(workername, "%s%d", "gpworker", iworker); + workerrec[iworker].busy = 1; + ifound = 1; + break; + } + } + if (ifound == 0) + { + pthread_cond_wait(cond_notbusy, mutex_workerrec); + } + pthread_mutex_unlock(mutex_workerrec); + + if (ifound == 1) + { + break; + } + } + + method_call_teec_inicont( + workername, + + name, + name_size, + in_fd, + in_ta_path, + in_ta_path_size, + in_session_list_next, + in_session_list_prev, + in_shrd_mem_list_next, + in_shrd_mem_list_prev, + in_share_buffer_buffer, + in_share_buffer_buffer_barrier, + + + &teecresult, + + &fd, + ta_path, + ta_path_size, + &session_list_next, + &session_list_prev, + &shrd_mem_list_next, + &shrd_mem_list_prev, + &share_buffer_buffer, + &share_buffer_buffer_barrier, + &context_addr, + + &context_tapath_outsize + ); + + if (teecresult == 0) + { + pthread_mutex_lock(mutex_workerrec); + workerrec[iworker].context_fd = fd; + workerrec[iworker].context_addr = context_addr; + workerrec[iworker].first = NULL; + workerrec[iworker].last = NULL; + workerrec[iworker].sessionid_count = 0; + struct timeval tvcreate; + gettimeofday(&tvcreate, NULL); + workerrec[iworker].context_createtime = tvcreate; + pthread_mutex_unlock(mutex_workerrec); + } + else + { + workerrec[iworker].busy = 0; + } + + if (ta_path_size >= context_tapath_outsize) { + ta_path_size = context_tapath_outsize; + charp = ta_path; + } + else + { + ta_path_size = 0; + charp = NULL; + } + + //////////////////////////////////////////////////////////////////////////////////////////////// +#endif + + // create a reply from the message + reply = dbus_message_new_method_return(msg); + +#if 0 + teecresult = 0; + fd = 0x04; + charp = ta_path; + session_list_next = 0xea3500a8; + session_list_prev = 0xea3500a8; + shrd_mem_list_next = 0xea3500b8; + shrd_mem_list_prev = 0xea3500b8; + share_buffer_buffer = 0; + share_buffer_buffer_barrier = 0xdd901c10; +#endif + + // add the arguments to the reply + dbus_message_iter_init_append(reply, &args); + dbus_message_iter_open_container( + &args, + DBUS_TYPE_STRUCT, + NULL, + &structIter + ); + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &teecresult + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &fd + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + DBusError err; + // initialise the errors + dbus_error_init(&err); + + if (ta_path_size > 0 && + charp != NULL && + strlen((const char *) charp) > 0 + ) + { + if (dbus_validate_utf8((const char *) charp, &err) == true) + { + ta_path_size = strlen((const char *) charp); + } else + { + ta_path_size = 0; + } + } else + { + ta_path_size = 0; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &ta_path_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (ta_path_size > 0) + { + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_STRING, + &charp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &session_list_next + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &session_list_prev + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &shrd_mem_list_prev + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &shrd_mem_list_next + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &share_buffer_buffer + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT64, + &share_buffer_buffer_barrier + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &context_addr + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_close_container( + &args, + &structIter + ); + + // send the reply && flush the connection + serial = 100; + if (!dbus_connection_send(conn, reply, &serial)) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_unref(reply); + dbus_message_unref(msg); + dbus_connection_flush(conn); + // dbus_connection_close(conn); + // dbus_connection_unref(conn); + + free(thdfargs); + + // sleep(2); + +#if 0 + #ifdef GP_WORKER + +#else + if (ta_path == NULL) + { + free(ta_path); + } +#endif +#endif + + return NULL; +} + + +void * +reply_to_method_call_teec_fincont( + void *thdfargs +) +{ + DBusMsgConn *DBusMCP; + DBusMessage *msg; + DBusConnection *conn; + DBusMessage *reply; + DBusMessageIter args; + dbus_bool_t bResult; + DBusMessageIter structIter; + int iType; + unsigned char *charp; + // char* param = ""; + dbus_int32_t in_fd; + unsigned char *in_ta_path = NULL; + dbus_int32_t in_ta_path_size; + dbus_uint64_t in_session_list_next; + dbus_uint64_t in_session_list_prev; + dbus_uint64_t in_shrd_mem_list_next; + dbus_uint64_t in_shrd_mem_list_prev; + dbus_uint64_t in_share_buffer_buffer; + dbus_int64_t in_share_buffer_buffer_barrier; + dbus_uint64_t in_context_addr; + + dbus_int32_t fd; + dbus_int32_t ta_path_size = 0; + dbus_uint64_t session_list_next; + dbus_uint64_t session_list_prev; + dbus_uint64_t shrd_mem_list_next; + dbus_uint64_t shrd_mem_list_prev; + dbus_uint64_t share_buffer_buffer; + dbus_int64_t share_buffer_buffer_barrier; + dbus_uint32_t serial = 0; + +#ifdef GP_PROXY + pthread_mutex_t * mutex_workerrec; + pthread_cond_t * cond_notbusy; + wr_t * workerrec; +#endif + +#ifdef GP_WORKER + pthread_mutex_t *mutex_tcl; + tcl_t *tcl; + tsl_t *tsl; +#endif + + DBusMCP = (DBusMsgConn *) thdfargs; + msg = DBusMCP->msg; + conn = DBusMCP->conn; +#ifdef GP_PROXY + mutex_workerrec = DBusMCP->mutex_workerrec; + cond_notbusy = DBusMCP->cond_notbusy; + workerrec = DBusMCP->workerrec; +#endif +#ifdef GP_WORKER + mutex_tcl = DBusMCP->mutex_tcl; + tcl = DBusMCP->tcl; + tsl = DBusMCP->tsl; +#endif + + // read the parameters + bResult = + dbus_message_iter_init( + msg, + &args + ); + if (!bResult) + { + fprintf(stderr, "Message has no arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_recurse( + &args, + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_fd); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_ta_path_size + ); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + // fprintf(stderr, "Debug in_ta_path_size = %d \n", in_ta_path_size); + if (in_ta_path_size > 0) + { + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_STRING + ) + { + fprintf(stderr, "Argument is not STRING.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_ta_path); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_list_next); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_list_prev); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_shrd_mem_list_next); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_shrd_mem_list_prev); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_share_buffer_buffer); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT64 + ) + { + fprintf(stderr, "Argument is not INT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_share_buffer_buffer_barrier); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_context_addr); + + printf("Received method call Teec Finalize Context: \n"); + printf(" in_fd = 0x %8.8x \n", in_fd); + printf(" in_ta_path_size = %d \n", in_ta_path_size); + + DBusError err; + dbus_error_init(&err); + if (in_ta_path_size > 0 && in_ta_path != NULL && dbus_validate_path((const char *) in_ta_path, &err) == true) + { + printf(" in_ta_path = %s \n", in_ta_path); + } +#if 0 + printf(" in_session_list_next = 0x %16.16lx \n", in_session_list_next); + printf(" in_session_list_prev = 0x %16.16lx \n", in_session_list_prev); + printf(" in_shrd_mem_list_next = 0x %16.16lx \n", in_shrd_mem_list_next); + printf(" in_shrd_mem_list_prev = 0x %16.16lx \n", in_shrd_mem_list_prev); + printf(" in_share_buffer_buffer = 0x %16.16lx \n", in_share_buffer_buffer); + printf(" in_share_buffer_buffer_barrier = 0x %16.16lx \n", in_share_buffer_buffer_barrier); +#endif + printf(" in_context_addr = 0x %16.16lx \n", in_context_addr); + + + unsigned char *ta_path = NULL; +#ifdef GP_WORKER + //////////////////////////////////////////////////////////////////////////////////////////////// + TEEC_Context *contextIns; + tcn_t *tcnIns; + TEEC_Result result; + + contextIns = NULL; + pthread_mutex_lock(mutex_tcl); + if (tcl->first != NULL) + { + tcnIns = tcl->first; + do + { + if (tcnIns->self->fd == in_fd) + { + contextIns = tcnIns->self; + break; + } + tcnIns = tcnIns->next; + } while (tcnIns != NULL); + } + pthread_mutex_unlock(mutex_tcl); + + if (contextIns == NULL) + { + if (tcl->first == NULL) + { + printf("The teec context list is null. \n"); + // teecresult = TEEC_ERROR_CONTEXT_LIST_NULL; + } else + { + printf("Can't find the teec context. \n"); + // teecresult = TEEC_ERROR_NO_CONTEXT_MATCH; + } + + fd = 0; + ta_path_size = 0; + charp = NULL; + session_list_prev = 0; + shrd_mem_list_next = 0; + shrd_mem_list_prev = 0; + share_buffer_buffer = 0; + share_buffer_buffer_barrier = 0; + } else + { + // contextIns.fd = in_fd; + contextIns->ta_path = in_ta_path; + contextIns->session_list.next = (struct ListNode *) in_session_list_next; + contextIns->session_list.prev = (struct ListNode *) in_session_list_prev; + contextIns->shrd_mem_list.next = (struct ListNode *) in_shrd_mem_list_next; + contextIns->shrd_mem_list.prev = (struct ListNode *) in_shrd_mem_list_prev; + contextIns->share_buffer.buffer = (void *) in_share_buffer_buffer; + contextIns->share_buffer.buffer_barrier.__align = (long long int) in_share_buffer_buffer_barrier; + // typedef struct { + // volatile int __val[4*sizeof(long)/sizeof(int)]; + // } sem_t; + // + // typedef union + // { + // char __size[__SIZEOF_SEM_T]; + // long long int __align; + // } sem_t; + + struct timeval start, end; + gettimeofday(&start, NULL); + TEEC_FinalizeContext(contextIns); + gettimeofday(&end, NULL); + uint32_t cost = 0; + cost += (1000000 * end.tv_sec + end.tv_usec) - (1000000 * start.tv_sec + start.tv_usec); + + printf("Teec FinalizeContext executed, cost time: %ld us \n", cost); + + fd = contextIns->fd; + if (contextIns->ta_path != NULL) + { + ta_path_size = strlen((const char *) contextIns->ta_path); + ta_path = contextIns->ta_path; + } else + { + ta_path_size = 0; + ta_path = NULL; + } + charp = ta_path; + session_list_next = (dbus_uint64_t) contextIns->session_list.next; + session_list_prev = (dbus_uint64_t) contextIns->session_list.prev; + shrd_mem_list_next = (dbus_uint64_t) contextIns->shrd_mem_list.next; + shrd_mem_list_prev = (dbus_uint64_t) contextIns->shrd_mem_list.prev; + share_buffer_buffer = (dbus_uint64_t) contextIns->share_buffer.buffer; + share_buffer_buffer_barrier = contextIns->share_buffer.buffer_barrier.__align; + + tcn_t *tcnTemp; + tcnTemp = tcnIns->prev; + if (tcnTemp != NULL) + { + tcnTemp->next = tcnIns->next; + } + tcnTemp = tcnIns->next; + if (tcnTemp != NULL) + { + tcnTemp->prev = tcnIns->prev; + } + pthread_mutex_lock(mutex_tcl); + if (tcl->last == tcnIns) + { + tcl->last = tcnIns->prev; + } + if (tcl->first == tcnIns) + { + tcl->first = tcnIns->next; + } + tcl->count = tcl->count - 1; + pthread_mutex_unlock(mutex_tcl); + free(contextIns); + free(tcnIns); + } + //////////////////////////////////////////////////////////////////////////////////////////////// +#else + ta_path = (unsigned char *)malloc(1024 * sizeof(char)); + ta_path_size = 1024; + memset((char *)ta_path, 0, 1024); + uint32_t context_tapath_outsize; + + char workername[1024]; + memset((char *)workername, 0, 1024); + int ifound = 0; + int iworker; + + pthread_mutex_lock(mutex_workerrec); + for (iworker = 0; iworker < MAX_NUM_WORKER; iworker++) + { + if (workerrec[iworker].context_fd == in_fd && + workerrec[iworker].context_addr == in_context_addr + ) + { + sprintf(workername, "%s%d", "gpworker", iworker); + ifound = 1; + break; + } + } + pthread_mutex_unlock(mutex_workerrec); + + if (ifound == 0) + { + printf("Can't find the worker for the context. \n"); + + // teecresult = 0xAAAA0017; + + fd = 0; + ta_path_size = 0; + charp = NULL; + session_list_prev = 0; + shrd_mem_list_next = 0; + shrd_mem_list_prev = 0; + share_buffer_buffer = 0; + share_buffer_buffer_barrier = 0; + } + else + { + pthread_mutex_unlock(mutex_workerrec); + sin_t * sinIns = NULL; + sin_t * sinInsPrev = NULL; + sinIns = workerrec[iworker].last; + if (sinIns != NULL) + { + dbus_uint32_t in_session_seesionid; + dbus_uint32_t in_session_serviceid_timelow = 0; + dbus_uint32_t in_session_serviceid_timemid = 0; + dbus_uint32_t in_session_serviceid_timehiandver = 0; + dbus_uint32_t in_session_serviceid_clockseqandnode_size = 8; + dbus_uint32_t in_session_serviceid_clockseqandnode[8]; + dbus_uint32_t in_session_opscnt = 0; + dbus_uint64_t in_session_head_next = 0; + dbus_uint64_t in_session_head_prev = 0; + dbus_uint64_t in_session_context; + + dbus_uint32_t seesionid; + dbus_uint32_t serviceid_timelow; + dbus_uint32_t serviceid_timemid; + dbus_uint32_t serviceid_timehiandver; + dbus_uint32_t * serviceid_clockseqandnode; + int serviceid_clockseqandnode_realsize; + dbus_uint32_t opscnt; + dbus_uint64_t head_next; + dbus_uint64_t head_prev; + dbus_uint64_t context; + + for ( ; ; ) + { + in_session_seesionid = sinIns->session_id; + in_session_context = workerrec[iworker].context_addr; + + pthread_mutex_unlock(mutex_workerrec); + + for (int iind = 0; iind < 8; iind++) + { + in_session_serviceid_clockseqandnode[iind] = 0; + } + + uint32_t serviceid_clockseqandnode_outsize_temp; + serviceid_clockseqandnode_realsize = 8; + serviceid_clockseqandnode = + (dbus_uint32_t *)malloc( + serviceid_clockseqandnode_realsize * sizeof(dbus_uint32_t) + ); + + printf("\nMethod call teec closesession. (Called by Proxy before fin context) \n"); + + method_call_teec_closesession( + workername, + + in_session_seesionid, + in_session_serviceid_timelow, + in_session_serviceid_timemid, + in_session_serviceid_timehiandver, + in_session_serviceid_clockseqandnode, + in_session_serviceid_clockseqandnode_size, + in_session_opscnt, + in_session_head_next, + in_session_head_prev, + in_session_context, + + &seesionid, + &serviceid_timelow, + &serviceid_timemid, + &serviceid_timehiandver, + serviceid_clockseqandnode, + serviceid_clockseqandnode_realsize, + &serviceid_clockseqandnode_outsize_temp, + &opscnt, + &head_next, + &head_prev, + &context + ); + + if (serviceid_clockseqandnode != NULL) { + free(serviceid_clockseqandnode); + } + + pthread_mutex_lock(mutex_workerrec); + + sinInsPrev = sinIns->prev; + free(sinIns); + if (sinInsPrev == NULL) + // if (sinIns == workerrec[iworker].first) + { + // free(sinIns); + break; + } + sinIns = sinInsPrev; + } + } + pthread_mutex_unlock(mutex_workerrec); + + method_call_teec_fincont( + workername, + + in_fd, + in_ta_path, + in_ta_path_size, + in_session_list_next, + in_session_list_prev, + in_shrd_mem_list_next, + in_shrd_mem_list_prev, + in_share_buffer_buffer, + in_share_buffer_buffer_barrier, + in_context_addr, + + &fd, + ta_path, + ta_path_size, + &session_list_next, + &session_list_prev, + &shrd_mem_list_next, + &shrd_mem_list_prev, + &share_buffer_buffer, + &share_buffer_buffer_barrier, + + &context_tapath_outsize + ); + + pthread_mutex_lock(mutex_workerrec); + workerrec[iworker].busy = 0; + pthread_cond_signal(cond_notbusy); + workerrec[iworker].context_fd = 0; + workerrec[iworker].context_addr = 0xffffffff; + workerrec[iworker].sessionid_count = 0; + workerrec[iworker].first = NULL; + workerrec[iworker].last = NULL; + pthread_mutex_unlock(mutex_workerrec); + + if (ta_path_size >= context_tapath_outsize) { + ta_path_size = context_tapath_outsize; + charp = ta_path; + } + else + { + ta_path_size = 0; + charp = NULL; + } + + } // end of else found == 1 + //////////////////////////////////////////////////////////////////////////////////////////////// + +#endif + + // create a reply from the message + reply = dbus_message_new_method_return(msg); + + // add the arguments to the reply + dbus_message_iter_init_append(reply, &args); + dbus_message_iter_open_container( + &args, + DBUS_TYPE_STRUCT, + NULL, + &structIter + ); + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &fd + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + // DBusError err; + // initialise the errors + // dbus_error_init(&err); + + if (ta_path_size > 0 && + charp != NULL + // && strlen((const char *) charp) > 0 + ) + { + // if (dbus_validate_utf8((const char *) charp, &err) == true) + if (dbus_validate_path((const char *) charp, &err) == true) + { + ta_path_size = strlen((const char *) charp); + } else + { + ta_path_size = 0; + } + } else + { + ta_path_size = 0; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &ta_path_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + fprintf(stderr, "%s %d: reply fincont, tapath size = %d \n", __FILE__, __LINE__, ta_path_size); + if (ta_path_size > 0) + { + fprintf(stderr, "%s %d: reply fincont, tapath = %s \n", __FILE__, __LINE__, charp); + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_STRING, + &charp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &session_list_next + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &session_list_prev + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &shrd_mem_list_prev + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &shrd_mem_list_next + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &share_buffer_buffer + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT64, + &share_buffer_buffer_barrier + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_close_container( + &args, + &structIter + ); + + // send the reply && flush the connection + serial = 100; + if (!dbus_connection_send(conn, reply, &serial)) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_unref(reply); + dbus_message_unref(msg); + dbus_connection_flush(conn); + // dbus_connection_close(conn); + // dbus_connection_unref(conn); + free(thdfargs); + + // sleep(2); + +#if 0 + #ifdef GP_WORKER + +#else + if (ta_path == NULL) + { + free(ta_path); + } +#endif +#endif + + return NULL; +} + + +void * +reply_to_method_call_teec_opensession( + void *thdfargs +) +{ + DBusMsgConn *DBusMCP; + DBusMessage *msg; + DBusConnection *conn; + DBusMessage *reply; + DBusMessageIter args; + dbus_bool_t bResult; + DBusMessageIter structIter; + DBusMessageIter ArrayIter; + int iType; + unsigned char *charp; + char buf[2]; + buf[0] = DBUS_TYPE_UINT32; + buf[1] = '\0'; + + // char* param = ""; + dbus_int32_t in_fd; + unsigned char *in_ta_path = NULL; + dbus_int32_t in_ta_path_size; + dbus_uint64_t in_session_list_next; + dbus_uint64_t in_session_list_prev; + dbus_uint64_t in_shrd_mem_list_next; + dbus_uint64_t in_shrd_mem_list_prev; + dbus_uint64_t in_share_buffer_buffer; + dbus_int64_t in_share_buffer_buffer_barrier; + dbus_uint32_t teecresult; + dbus_int32_t fd; + + dbus_uint32_t in_destination_timelow; + dbus_uint32_t in_destination_timemid; + dbus_uint32_t in_destination_timehiandver; + + dbus_uint32_t in_connectionmethod; + dbus_uint64_t in_connectiondata; + dbus_uint32_t in_operation_started; + dbus_uint32_t in_operation_paramtypes; + dbus_int32_t in_destination_clockseqandnode_size; + int in_destination_clockseqandnode_realsize; + dbus_uint32_t *in_destination_clockseqandnode; + + dbus_uint64_t in_operation_param1_tmpref_buffer; + dbus_uint32_t in_operation_param1_tmpref_size; + dbus_uint64_t in_operation_param1_memref_parent; + dbus_uint32_t in_operation_param1_memref_size; + dbus_uint32_t in_operation_param1_memref_offset; + dbus_uint32_t in_operation_param1_value_a; + dbus_uint32_t in_operation_param1_value_b; + dbus_int32_t in_operation_param1_ionref_ionsharefd; + dbus_uint32_t in_operation_param1_ionref_ionsize; + + dbus_uint64_t in_operation_param2_tmpref_buffer; + dbus_uint32_t in_operation_param2_tmpref_size; + dbus_uint64_t in_operation_param2_memref_parent; + dbus_uint32_t in_operation_param2_memref_size; + dbus_uint32_t in_operation_param2_memref_offset; + dbus_uint32_t in_operation_param2_value_a; + dbus_uint32_t in_operation_param2_value_b; + dbus_int32_t in_operation_param2_ionref_ionsharefd; + dbus_uint32_t in_operation_param2_ionref_ionsize; + + dbus_uint64_t in_operation_param3_tmpref_buffer; + dbus_uint32_t in_operation_param3_tmpref_size; + dbus_uint64_t in_operation_param3_memref_parent; + dbus_uint32_t in_operation_param3_memref_size; + dbus_uint32_t in_operation_param3_memref_offset; + dbus_uint32_t in_operation_param3_value_a; + dbus_uint32_t in_operation_param3_value_b; + dbus_int32_t in_operation_param3_ionref_ionsharefd; + dbus_uint32_t in_operation_param3_ionref_ionsize; + + dbus_uint64_t in_operation_param4_tmpref_buffer; + dbus_uint32_t in_operation_param4_tmpref_size; + dbus_uint64_t in_operation_param4_memref_parent; + dbus_uint32_t in_operation_param4_memref_size; + dbus_uint32_t in_operation_param4_memref_offset; + dbus_uint32_t in_operation_param4_value_a; + dbus_uint32_t in_operation_param4_value_b; + dbus_int32_t in_operation_param4_ionref_ionsharefd; + dbus_uint32_t in_operation_param4_ionref_ionsize; + + dbus_uint64_t in_operation_session; + dbus_int32_t in_operation_cancelflag; + dbus_uint32_t in_returnorigin; + + dbus_uint64_t in_context_addr; + + // unsigned char ta_path[] = "/vendor/bin/rsa_demo_ta"; + // dbus_int32_t ta_path_size = strlen((const char *)ta_path); + unsigned char *ta_path; + dbus_int32_t ta_path_size; + dbus_uint64_t session_list_next; + dbus_uint64_t session_list_prev; + dbus_uint64_t shrd_mem_list_next; + dbus_uint64_t shrd_mem_list_prev; + dbus_uint64_t share_buffer_buffer; + dbus_int64_t share_buffer_buffer_barrier; + + dbus_uint32_t seesionid; + dbus_uint32_t serviceid_timelow; + dbus_uint32_t serviceid_timemid; + dbus_uint32_t serviceid_timehiandver; + dbus_uint32_t *serviceid_clockseqandnode; + int serviceid_clockseqandnode_realsize; + dbus_int32_t serviceid_clockseqandnode_outsize; + dbus_uint32_t opscnt; + dbus_uint64_t head_next; + dbus_uint64_t head_prev; + dbus_uint64_t context; + + dbus_uint32_t started; + dbus_uint32_t paramtypes; + + dbus_uint64_t operation_param1_tmpref_buffer; + dbus_uint32_t operation_param1_tmpref_size; + dbus_uint64_t operation_param1_memref_parent; + dbus_uint32_t operation_param1_memref_size; + dbus_uint32_t operation_param1_memref_offset; + dbus_uint32_t operation_param1_value_a; + dbus_uint32_t operation_param1_value_b; + dbus_int32_t operation_param1_ionref_ionsharefd; + dbus_uint32_t operation_param1_ionref_ionsize; + + dbus_uint64_t operation_param2_tmpref_buffer; + dbus_uint32_t operation_param2_tmpref_size; + dbus_uint64_t operation_param2_memref_parent; + dbus_uint32_t operation_param2_memref_size; + dbus_uint32_t operation_param2_memref_offset; + dbus_uint32_t operation_param2_value_a; + dbus_uint32_t operation_param2_value_b; + dbus_int32_t operation_param2_ionref_ionsharefd; + dbus_uint32_t operation_param2_ionref_ionsize; + + dbus_uint64_t operation_param3_tmpref_buffer; + dbus_uint32_t operation_param3_tmpref_size; + dbus_uint64_t operation_param3_memref_parent; + dbus_uint32_t operation_param3_memref_size; + dbus_uint32_t operation_param3_memref_offset; + dbus_uint32_t operation_param3_value_a; + dbus_uint32_t operation_param3_value_b; + dbus_int32_t operation_param3_ionref_ionsharefd; + dbus_uint32_t operation_param3_ionref_ionsize; + + dbus_uint64_t operation_param4_tmpref_buffer; + dbus_uint32_t operation_param4_tmpref_size; + dbus_uint64_t operation_param4_memref_parent; + dbus_uint32_t operation_param4_memref_size; + dbus_uint32_t operation_param4_memref_offset; + dbus_uint32_t operation_param4_value_a; + dbus_uint32_t operation_param4_value_b; + dbus_int32_t operation_param4_ionref_ionsharefd; + dbus_uint32_t operation_param4_ionref_ionsize; + + dbus_uint64_t operation_session; + dbus_int32_t operation_cancelflag; + dbus_uint32_t returnorigin; + dbus_uint32_t serial = 0; + +#ifdef GP_PROXY + pthread_mutex_t * mutex_workerrec; + wr_t * workerrec; +#endif + +#ifdef GP_WORKER + pthread_mutex_t *mutex_tcl; + pthread_mutex_t *mutex_tsl; + tcl_t *tcl; + tsl_t *tsl; +#endif + + DBusMCP = (DBusMsgConn *) thdfargs; + msg = DBusMCP->msg; + conn = DBusMCP->conn; +#ifdef GP_PROXY + mutex_workerrec = DBusMCP->mutex_workerrec; + workerrec = DBusMCP->workerrec; +#endif +#ifdef GP_WORKER + mutex_tcl = DBusMCP->mutex_tcl; + mutex_tsl = DBusMCP->mutex_tsl; + tcl = DBusMCP->tcl; + tsl = DBusMCP->tsl; +#endif + + // read the parameters + bResult = + dbus_message_iter_init( + msg, + &args + ); + if (!bResult) + { + fprintf(stderr, "Message has no arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_recurse( + &args, + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_get_basic( + &structIter, + &in_fd); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_ta_path_size + ); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + // fprintf(stderr, "Debug in_ta_path_size = %d \n", in_ta_path_size); + if (in_ta_path_size > 0) + { + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_STRING + ) + { + fprintf(stderr, "Argument is not STRING.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_ta_path); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_list_next); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_list_prev); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_shrd_mem_list_next); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_shrd_mem_list_prev); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_share_buffer_buffer); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT64 + ) + { + fprintf(stderr, "Argument is not INT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_share_buffer_buffer_barrier); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32, line %d. \n", __LINE__); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_destination_timelow); + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32, line %d. \n", __LINE__); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_destination_timemid); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32, line %d. \n", __LINE__); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_destination_timehiandver); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_destination_clockseqandnode_size); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (in_destination_clockseqandnode_size > 0) + { + dbus_message_iter_recurse( + &structIter, + &ArrayIter); + + iType = + dbus_message_iter_get_arg_type( + &ArrayIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32, line %d. \n", __LINE__); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_fixed_array( + &ArrayIter, + &in_destination_clockseqandnode, + &in_destination_clockseqandnode_realsize + ); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32, line %d. \n", __LINE__); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_get_basic( + &structIter, + &in_connectionmethod); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_connectiondata); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_started); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_paramtypes); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_tmpref_buffer); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_tmpref_size); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_memref_parent); + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_memref_size); + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_memref_offset); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_value_a); + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_value_b); + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_ionref_ionsharefd); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_ionref_ionsize); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_tmpref_buffer); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_tmpref_size); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_memref_parent); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_memref_size); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_memref_offset); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_value_a); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_value_b); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_ionref_ionsharefd); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_ionref_ionsize); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_tmpref_buffer); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_tmpref_size); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_memref_parent); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_memref_size); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_memref_offset); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_value_a); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_value_b); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_ionref_ionsharefd); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_ionref_ionsize); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_tmpref_buffer); + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_tmpref_size); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_memref_parent); + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_memref_size); + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_memref_offset); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_value_a); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_value_b); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_ionref_ionsharefd); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_ionref_ionsize); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_session); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_cancelflag); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_returnorigin); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_context_addr); + + printf("Received method call Teec Open Session: \n"); + printf(" in_fd = 0x %8.8x \n", in_fd); + printf(" in_ta_path = %s \n", in_ta_path); + printf(" in_ta_path_size = %d \n", in_ta_path_size); +#if 0 + printf(" in_session_list_next = 0x %16.16lx \n", in_session_list_next); + printf(" in_session_list_prev = 0x %16.16lx \n", in_session_list_prev); + printf(" in_shrd_mem_list_next = 0x %16.16lx \n", in_shrd_mem_list_next); + printf(" in_shrd_mem_list_prev = 0x %16.16lx \n", in_shrd_mem_list_prev); + printf(" in_share_buffer_buffer = 0x %16.16lx \n", in_share_buffer_buffer); + printf(" in_share_buffer_buffer_barrier = 0x %16.16lx \n", in_share_buffer_buffer_barrier); + + printf(" in_destination_timelow = 0x %8.8x \n", in_destination_timelow); + printf(" in_destination_timemid = 0x %8.8x \n", in_destination_timemid); + printf(" in_destination_timehiandver = 0x %8.8x \n", in_destination_timehiandver); + if ( in_destination_clockseqandnode_realsize > 0 ) + { + printf(" in_destination_clockseqandnode = \n"); + printf(" "); + for (int i = 0; i < in_destination_clockseqandnode_realsize; i++) { + printf(" %8.8x", in_destination_clockseqandnode[i]); + } + printf("\n"); + } + else + { + printf(" in_destination_clockseqandnode addr = 0x %16.16lx \n", + (long unsigned int)in_destination_clockseqandnode + ); + } + printf(" in_destination_clockseqandnode_size = 0x %8.8x \n", in_destination_clockseqandnode_size); + + printf(" in_connectionmethod = 0x %8.8x \n", in_connectionmethod); + printf(" in_connectiondata = 0x %16.16lx \n", in_connectiondata); + + printf(" in_operation_started = 0x %8.8x \n", in_operation_started); + printf(" in_operation_paramtypes = 0x %8.8x \n", in_operation_paramtypes); + + printf(" in_operation_param1_tmpref_buffer = 0x %16.16lx \n", in_operation_param1_tmpref_buffer); + printf(" in_operation_param1_tmpref_size = 0x %8.8x \n", in_operation_param1_tmpref_size); + printf(" in_operation_param1_memref_parent = 0x %16.16lx \n", in_operation_param1_memref_parent); + printf(" in_operation_param1_memref_size = 0x %8.8x \n", in_operation_param1_memref_size); + printf(" in_operation_param1_memref_offset = 0x %8.8x \n", in_operation_param1_memref_offset); + printf(" in_operation_param1_value_a = 0x %8.8x \n", in_operation_param1_value_a); + printf(" in_operation_param1_value_b = 0x %8.8x \n", in_operation_param1_value_b); + printf(" in_operation_param1_ionref_ionsharefd = 0x %8.8x \n", + in_operation_param1_ionref_ionsharefd); + printf(" in_operation_param1_ionref_ionsize = 0x %8.8x \n", in_operation_param1_ionref_ionsize); + + printf(" in_operation_param2_tmpref_buffer = 0x %16.16lx \n", in_operation_param2_tmpref_buffer); + printf(" in_operation_param2_tmpref_size = 0x %8.8x \n", in_operation_param2_tmpref_size); + printf(" in_operation_param2_memref_parent = 0x %16.16lx \n", in_operation_param2_memref_parent); + printf(" in_operation_param2_memref_size = 0x %8.8x \n", in_operation_param2_memref_size); + printf(" in_operation_param2_memref_offset = 0x %8.8x \n", in_operation_param2_memref_offset); + printf(" in_operation_param2_value_a = 0x %8.8x \n", in_operation_param3_value_a); + printf(" in_operation_param2_value_b = 0x %8.8x \n", in_operation_param3_value_b); + printf(" in_operation_param2_ionref_ionsharefd = 0x %8.8x \n", in_operation_param3_ionref_ionsharefd); + printf(" in_operation_param2_ionref_ionsize = 0x %8.8x \n", in_operation_param3_ionref_ionsize); + + printf(" in_operation_param3_tmpref_buffer = 0x %16.16lx \n", in_operation_param3_tmpref_buffer); + printf(" in_operation_param3_tmpref_size = 0x %8.8x \n", in_operation_param3_tmpref_size); + printf(" in_operation_param3_memref_parent = 0x %16.16lx \n", in_operation_param3_memref_parent); + printf(" in_operation_param3_memref_size = 0x %8.8x \n", in_operation_param3_memref_size); + printf(" in_operation_param3_memref_offset = 0x %8.8x \n", in_operation_param3_memref_offset); + printf(" in_operation_param3_value_a = 0x %8.8x \n", in_operation_param3_value_a); + printf(" in_operation_param3_value_b = 0x %8.8x \n", in_operation_param3_value_b); + printf(" in_operation_param3_ionref_ionsharefd = 0x %8.8x \n", in_operation_param3_ionref_ionsharefd); + printf(" in_operation_param3_ionref_ionsize = 0x %8.8x \n", in_operation_param3_ionref_ionsize); + + printf(" in_operation_param4_tmpref_buffer = 0x %16.16lx \n", in_operation_param4_tmpref_buffer); + printf(" in_operation_param4_tmpref_size = 0x %8.8x \n", in_operation_param4_tmpref_size); + printf(" in_operation_param4_memref_parent = 0x %16.16lx \n", in_operation_param4_memref_parent); + printf(" in_operation_param4_memref_size = 0x %8.8x \n", in_operation_param4_memref_size); + printf(" in_operation_param4_memref_offset = 0x %8.8x \n", in_operation_param4_memref_offset); + printf(" in_operation_param4_value_a = 0x %8.8x \n", in_operation_param4_value_a); + printf(" in_operation_param4_value_b = 0x %8.8x \n", in_operation_param4_value_b); + printf(" in_operation_param4_ionref_ionsharefd = 0x %8.8x \n", in_operation_param4_ionref_ionsharefd); + printf(" in_operation_param4_ionref_ionsize = 0x %8.8x \n", in_operation_param4_ionref_ionsize); + + printf(" in_operation_session = 0x %16.16lx \n", in_operation_session); + printf(" in_operation_cancelflag = 0x %8.8x \n", in_operation_cancelflag); + + printf(" in_returnorigin = 0x %8.8x \n", in_returnorigin); +#endif + printf(" in_context_addr = 0x %16.16lx \n", in_context_addr); + +#ifdef GP_WORKER + //////////////////////////////////////////////////////////////////////////////////////////////// + + TEEC_Context *contextIns; + tcn_t *tcnIns; + + TEEC_UUID destinationIns; + void *in_connectiondata_temp; + TEEC_Operation operationIns; + uint32_t origin; + TEEC_Result result; + + contextIns = NULL; + pthread_mutex_lock(mutex_tcl); + if (tcl->first != NULL) + { + tcnIns = tcl->first; + do + { + if (tcnIns->self->fd == in_fd) + { + contextIns = tcnIns->self; + break; + } + tcnIns = tcnIns->next; + } while (tcnIns != NULL); + } + pthread_mutex_unlock(mutex_tcl); + + if (contextIns == NULL) + { + if (tcl->first == NULL) + { + printf("The teec context list is null. \n"); + teecresult = TEEC_ERROR_CONTEXT_LIST_NULL; + } else + { + printf("Can't find the teec context. \n"); + teecresult = TEEC_ERROR_NO_CONTEXT_MATCH; + } + + fd = 0; + ta_path_size = 0; + ta_path = NULL; + charp = ta_path; + session_list_next = 0; + session_list_prev = 0; + shrd_mem_list_next = 0; + shrd_mem_list_prev = 0; + share_buffer_buffer = 0; + share_buffer_buffer_barrier = 0; + + seesionid = 0; + serviceid_timelow = 0; + serviceid_timemid = 0; + serviceid_timehiandver = 0; + serviceid_clockseqandnode_realsize = 0; + serviceid_clockseqandnode = NULL; + serviceid_clockseqandnode_outsize = 0; + opscnt = 0; + head_next = 0; + head_prev = 0; + context = 0; + + started = 0; + paramtypes = 0; + + operation_param1_tmpref_buffer = 0; + operation_param1_tmpref_size = 0; + operation_param1_memref_parent = 0; + operation_param1_memref_size = 0; + operation_param1_memref_offset = 0; + operation_param1_value_a = 0; + operation_param1_value_b = 0; + operation_param1_ionref_ionsharefd = 0; + operation_param1_ionref_ionsize = 0; + + operation_param2_tmpref_buffer = 0; + operation_param2_tmpref_size = 0; + operation_param2_memref_parent = 0; + operation_param2_memref_size = 0; + operation_param2_memref_offset = 0; + operation_param2_value_a = 0; + operation_param2_value_b = 0; + operation_param2_ionref_ionsharefd = 0; + operation_param2_ionref_ionsize = 0; + + operation_param3_tmpref_buffer = 0; + operation_param3_tmpref_size = 0; + operation_param3_memref_parent = 0; + operation_param3_memref_size = 0; + operation_param3_memref_offset = 0; + operation_param3_value_a = 0; + operation_param3_value_b = 0; + operation_param3_ionref_ionsharefd = 0; + operation_param3_ionref_ionsize = 0; + + operation_param4_tmpref_buffer = 0; + operation_param4_tmpref_size = 0; + operation_param4_memref_parent = 0; + operation_param4_memref_size = 0; + operation_param4_memref_offset = 0; + operation_param4_value_a = 0; + operation_param4_value_b = 0; + operation_param4_ionref_ionsharefd = 0; + operation_param4_ionref_ionsize = 0; + + operation_session = 0; + operation_cancelflag = 0; + + returnorigin = 0; + } else + { + TEEC_Session *sessionIns = (TEEC_Session *) malloc(sizeof(TEEC_Session)); + + // contextIns->fd = in_fd; + contextIns->ta_path = in_ta_path; + // typedef struct { + // volatile int __val[4*sizeof(long)/sizeof(int)]; + // } sem_t; + // + // typedef union + // { + // char __size[__SIZEOF_SEM_T]; + // long long int __align; + // } sem_t; + + destinationIns.timeLow = in_destination_timelow; + destinationIns.timeMid = in_destination_timemid; + destinationIns.timeHiAndVersion = in_destination_timehiandver; + for (int i = 0; + i < in_destination_clockseqandnode_size; + i++) + { + destinationIns.clockSeqAndNode[i] = in_destination_clockseqandnode[i]; + } + + in_connectiondata_temp = (void *) in_connectiondata; + // in_connectiondata_temp = NULL; + + + memset(&operationIns, 0, sizeof(operationIns)); + operationIns.started = in_operation_started; + operationIns.paramTypes = in_operation_paramtypes; + + origin = in_returnorigin; + + struct timeval start, end; + gettimeofday(&start, NULL); + result = + TEEC_OpenSession( + contextIns, + sessionIns, + &destinationIns, + in_connectionmethod, + in_connectiondata_temp, // NULL + &operationIns, + &origin + ); + gettimeofday(&end, NULL); + uint32_t cost = 0; + cost += (1000000 * end.tv_sec + end.tv_usec) - (1000000 * start.tv_sec + start.tv_usec); + + if (result != TEEC_SUCCESS) + { + printf("Teec OpenSession Failed. \n"); + printf(" teecresult = 0x %8.8x.\n", result); + + teecresult = result; + + fd = 0; + ta_path_size = 0; + ta_path = NULL; + charp = ta_path; + session_list_next = 0; + session_list_prev = 0; + shrd_mem_list_next = 0; + shrd_mem_list_prev = 0; + share_buffer_buffer = 0; + share_buffer_buffer_barrier = 0; + + seesionid = 0; + serviceid_timelow = 0; + serviceid_timemid = 0; + serviceid_timehiandver = 0; + serviceid_clockseqandnode_realsize = 0; + serviceid_clockseqandnode = NULL; + serviceid_clockseqandnode_outsize = 0; + opscnt = 0; + head_next = 0; + head_prev = 0; + context = 0; + + started = 0; + paramtypes = 0; + + operation_param1_tmpref_buffer = 0; + operation_param1_tmpref_size = 0; + operation_param1_memref_parent = 0; + operation_param1_memref_size = 0; + operation_param1_memref_offset = 0; + operation_param1_value_a = 0; + operation_param1_value_b = 0; + operation_param1_ionref_ionsharefd = 0; + operation_param1_ionref_ionsize = 0; + + operation_param2_tmpref_buffer = 0; + operation_param2_tmpref_size = 0; + operation_param2_memref_parent = 0; + operation_param2_memref_size = 0; + operation_param2_memref_offset = 0; + operation_param2_value_a = 0; + operation_param2_value_b = 0; + operation_param2_ionref_ionsharefd = 0; + operation_param2_ionref_ionsize = 0; + + operation_param3_tmpref_buffer = 0; + operation_param3_tmpref_size = 0; + operation_param3_memref_parent = 0; + operation_param3_memref_size = 0; + operation_param3_memref_offset = 0; + operation_param3_value_a = 0; + operation_param3_value_b = 0; + operation_param3_ionref_ionsharefd = 0; + operation_param3_ionref_ionsize = 0; + + operation_param4_tmpref_buffer = 0; + operation_param4_tmpref_size = 0; + operation_param4_memref_parent = 0; + operation_param4_memref_size = 0; + operation_param4_memref_offset = 0; + operation_param4_value_a = 0; + operation_param4_value_b = 0; + operation_param4_ionref_ionsharefd = 0; + operation_param4_ionref_ionsize = 0; + + operation_session = 0; + operation_cancelflag = 0; + + returnorigin = 0; + } else + { + printf("Teec OpenSession Succed, cost time: %ld us \n", cost); + + tsn_t *tsnIns = (tsn_t *) malloc(sizeof(tsn_t)); + tsnIns->self = sessionIns; + struct timeval tvcreate; + gettimeofday(&tvcreate, NULL); + tsnIns->createtime = tvcreate; + pthread_mutex_lock(mutex_tsl); + if (tsl->first == NULL) + { + tsnIns->next = NULL; + tsnIns->prev = NULL; + tsl->first = tsnIns; + tsl->last = tsnIns; + tsl->count = 1; + } else + { + tsnIns->prev = tsl->last; + tsnIns->next = NULL; + tsl->last->next = tsnIns; + tsl->last = tsnIns; + tsl->count = tsl->count + 1; + } + pthread_mutex_unlock(mutex_tsl); + + teecresult = result; + + fd = contextIns->fd; + if (contextIns->ta_path != NULL) + { + ta_path_size = strlen((const char *) contextIns->ta_path); + } else + { + ta_path_size = 0; + } + ta_path = contextIns->ta_path; + charp = ta_path; + session_list_next = (dbus_uint64_t) contextIns->session_list.next; + session_list_prev = (dbus_uint64_t) contextIns->session_list.prev; + shrd_mem_list_next = (dbus_uint64_t) contextIns->shrd_mem_list.next; + shrd_mem_list_prev = (dbus_uint64_t) contextIns->shrd_mem_list.prev; + share_buffer_buffer = (dbus_uint64_t) contextIns->share_buffer.buffer; + share_buffer_buffer_barrier = contextIns->share_buffer.buffer_barrier.__align; + + seesionid = sessionIns->session_id; + serviceid_timelow = sessionIns->service_id.timeLow; + serviceid_timemid = sessionIns->service_id.timeMid; + serviceid_timehiandver = sessionIns->service_id.timeHiAndVersion; + if (sessionIns->service_id.clockSeqAndNode != NULL) + { + serviceid_clockseqandnode_realsize = 8; + serviceid_clockseqandnode = + (dbus_uint32_t *) malloc( + serviceid_clockseqandnode_realsize * sizeof(dbus_uint32_t) + ); + for (int iind = 0; iind < 8; iind++) + { + uint8_t u8Temp; + u8Temp = sessionIns->service_id.clockSeqAndNode[iind]; + serviceid_clockseqandnode[iind] = (dbus_uint32_t) u8Temp; + } + serviceid_clockseqandnode_outsize = 8; + } else + { + serviceid_clockseqandnode_realsize = 0; + serviceid_clockseqandnode = NULL; + serviceid_clockseqandnode_outsize = 0; + } + opscnt = sessionIns->ops_cnt; + head_next = (dbus_uint64_t) sessionIns->head.next; + head_prev = (dbus_uint64_t) sessionIns->head.prev; + context = (dbus_uint64_t) sessionIns->context; + + started = operationIns.started; + paramtypes = operationIns.paramTypes; + + operation_param1_tmpref_buffer = (dbus_uint64_t) operationIns.params[0].tmpref.buffer; + operation_param1_tmpref_size = operationIns.params[0].tmpref.size; + operation_param1_memref_parent = (dbus_uint64_t) operationIns.params[0].memref.parent; + operation_param1_memref_size = operationIns.params[0].memref.size; + operation_param1_memref_offset = operationIns.params[0].memref.offset; + operation_param1_value_a = operationIns.params[0].value.a; + operation_param1_value_b = operationIns.params[0].value.b; + operation_param1_ionref_ionsharefd = operationIns.params[0].ionref.ion_share_fd; + operation_param1_ionref_ionsize = operationIns.params[0].ionref.ion_size; + + operation_param2_tmpref_buffer = (dbus_uint64_t) operationIns.params[1].tmpref.buffer; + operation_param2_tmpref_size = operationIns.params[1].tmpref.size; + operation_param2_memref_parent = (dbus_uint64_t) operationIns.params[1].memref.parent; + operation_param2_memref_size = operationIns.params[1].memref.size; + operation_param2_memref_offset = operationIns.params[1].memref.offset; + operation_param2_value_a = operationIns.params[1].value.a; + operation_param2_value_b = operationIns.params[1].value.b; + operation_param2_ionref_ionsharefd = operationIns.params[1].ionref.ion_share_fd; + operation_param2_ionref_ionsize = operationIns.params[1].ionref.ion_size; + + operation_param3_tmpref_buffer = (dbus_uint64_t) operationIns.params[2].tmpref.buffer; + operation_param3_tmpref_size = operationIns.params[2].tmpref.size; + operation_param3_memref_parent = (dbus_uint64_t) operationIns.params[2].memref.parent; + operation_param3_memref_size = operationIns.params[2].memref.size; + operation_param3_memref_offset = operationIns.params[2].memref.offset; + operation_param3_value_a = operationIns.params[2].value.a; + operation_param3_value_b = operationIns.params[2].value.b; + operation_param3_ionref_ionsharefd = operationIns.params[2].ionref.ion_share_fd; + operation_param3_ionref_ionsize = operationIns.params[2].ionref.ion_size; + + operation_param4_tmpref_buffer = (dbus_uint64_t) operationIns.params[3].tmpref.buffer; + operation_param4_tmpref_size = operationIns.params[3].tmpref.size; + operation_param4_memref_parent = (dbus_uint64_t) operationIns.params[3].memref.parent; + operation_param4_memref_size = operationIns.params[3].memref.size; + operation_param4_memref_offset = operationIns.params[3].memref.offset; + operation_param4_value_a = operationIns.params[3].value.a; + operation_param4_value_b = operationIns.params[3].value.b; + operation_param4_ionref_ionsharefd = operationIns.params[3].ionref.ion_share_fd; + operation_param4_ionref_ionsize = operationIns.params[3].ionref.ion_size; + + operation_session = (dbus_uint64_t) operationIns.session; + operation_cancelflag = operationIns.cancel_flag; + + returnorigin = origin; + + printf(" ret sessionid = 0x %8.8x \n", seesionid); + printf(" ret context = 0x %16.16lx \n", context); + +#if 0 + printf("Call TEEC_CloseSession inputs: \n"); + printf(" session_seesionid = 0x %8.8x \n", sessionIns->session_id); + printf(" session_serviceid_timelow = 0x %8.8x \n", sessionIns->service_id.timeLow); + printf(" session_serviceid_timemid = 0x %4.4x \n", sessionIns->service_id.timeMid); + printf(" session_serviceid_timehiandver = 0x %4.4x \n", + sessionIns->service_id.timeHiAndVersion); + printf(" session_serviceid_clockseqandnode = \n"); + printf(" "); + for (int i = 0; i < 8; i++) { + printf(" %2.2x", sessionIns->service_id.clockSeqAndNode[i]); + } + printf("\n"); + printf(" session_opscnt = 0x %8.8x \n", sessionIns->ops_cnt); + printf(" session_head_next = 0x %16.16lx \n", sessionIns->head.next); + printf(" session_head_prev = 0x %16.16lx \n", sessionIns->head.prev); + printf(" session_context = 0x %16.16lx \n", sessionIns->context); + + // TEEC_CloseSession(sessionIns); + // printf("Teec CloseSession. \n"); +#endif + } + } + //////////////////////////////////////////////////////////////////////////////////////////////// +#else + ta_path = (unsigned char *)malloc(1024 * sizeof(char)); + ta_path_size = 1024; + memset((char *)ta_path, 0, 1024); + uint32_t context_tapath_outsize; + uint32_t serviceid_clockseqandnode_outsize_temp; + uint32_t returnorigin_temp; + serviceid_clockseqandnode_realsize = 8; + serviceid_clockseqandnode = + (dbus_uint32_t *)malloc( + serviceid_clockseqandnode_realsize * sizeof(dbus_uint32_t) + ); + + char workername[1024]; + memset((char *)workername, 0, 1024); + int ifound = 0; + int iworker; + + pthread_mutex_lock(mutex_workerrec); + for (iworker = 0; iworker < MAX_NUM_WORKER; iworker++) + { + if (workerrec[iworker].context_fd == in_fd && + workerrec[iworker].context_addr == in_context_addr + ) + { + sprintf(workername, "%s%d", "gpworker", iworker); + ifound = 1; + break; + } + } + pthread_mutex_unlock(mutex_workerrec); + + if (ifound == 0) + { + printf("Can't find the woker for the context. \n"); + + teecresult = 0xAAAA0017; + + fd = 0x0; + ta_path = NULL; + charp = ta_path; + session_list_next = 0x0; + session_list_prev = 0x0; + shrd_mem_list_next = 0x0; + shrd_mem_list_prev = 0x0; + share_buffer_buffer = 0; + share_buffer_buffer_barrier = 0x0; + + seesionid = 0x0; + serviceid_timelow = 0x0; + serviceid_timemid = 0x0; + serviceid_timehiandver = 0x0; + serviceid_clockseqandnode_realsize = 0; + serviceid_clockseqandnode = + (dbus_uint32_t *)malloc( + serviceid_clockseqandnode_realsize * sizeof(dbus_uint32_t) + ); + for (int i = 0; i < serviceid_clockseqandnode_realsize ; i++) { + serviceid_clockseqandnode[i] = 0x0; + } + serviceid_clockseqandnode_outsize = 0; + opscnt = 0x0; + head_next = 0x0; + head_prev = 0x0; + context = 0x0; + + started = 0x0; + paramtypes = 0x0; + + operation_param1_tmpref_buffer = 0x0; + operation_param1_tmpref_size = 0x0; + operation_param1_memref_parent = 0x0; + operation_param1_memref_size = 0x0; + operation_param1_memref_offset = 0x0; + operation_param1_value_a = 0x0; + operation_param1_value_b = 0x0; + operation_param1_ionref_ionsharefd = 0x0; + operation_param1_ionref_ionsize = 0x0; + + operation_param2_tmpref_buffer = 0x0; + operation_param2_tmpref_size = 0x0; + operation_param2_memref_parent = 0x0; + operation_param2_memref_size = 0x0; + operation_param2_memref_offset = 0x0; + operation_param2_value_a = 0x0; + operation_param2_value_b = 0x0; + operation_param2_ionref_ionsharefd = 0x0; + operation_param2_ionref_ionsize = 0x0; + + operation_param3_tmpref_buffer = 0x0; + operation_param3_tmpref_size = 0x0; + operation_param3_memref_parent = 0x0; + operation_param3_memref_size = 0x0; + operation_param3_memref_offset = 0x0; + operation_param3_value_a = 0x0; + operation_param3_value_b = 0x0; + operation_param3_ionref_ionsharefd = 0x0; + operation_param3_ionref_ionsize = 0x0; + + operation_param4_tmpref_buffer = 0x0; + operation_param4_tmpref_size = 0x0; + operation_param4_memref_parent = 0x0; + operation_param4_memref_size = 0x0; + operation_param4_memref_offset = 0x0; + operation_param4_value_a = 0x0; + operation_param4_value_b = 0x0; + operation_param4_ionref_ionsharefd = 0x0; + operation_param4_ionref_ionsize = 0x0; + + operation_session = 0x0; + operation_cancelflag = 0x0; + + returnorigin = 0x0; + } + else + { + method_call_teec_opensession( + workername, + + in_fd, + in_ta_path, + in_ta_path_size, + in_session_list_next, + in_session_list_prev, + in_shrd_mem_list_next, + in_shrd_mem_list_prev, + in_share_buffer_buffer, + in_share_buffer_buffer_barrier, + + in_destination_timelow, + in_destination_timemid, + in_destination_timehiandver, + in_destination_clockseqandnode, + in_destination_clockseqandnode_realsize, + + in_connectionmethod, + in_connectiondata, + + in_operation_started, + in_operation_paramtypes, + + in_operation_param1_tmpref_buffer, + in_operation_param1_tmpref_size, + in_operation_param1_memref_parent, + in_operation_param1_memref_size, + in_operation_param1_memref_offset, + in_operation_param1_value_a, + in_operation_param1_value_b, + in_operation_param1_ionref_ionsharefd, + in_operation_param1_ionref_ionsize, + + in_operation_param2_tmpref_buffer, + in_operation_param2_tmpref_size, + in_operation_param2_memref_parent, + in_operation_param2_memref_size, + in_operation_param2_memref_offset, + in_operation_param2_value_a, + in_operation_param2_value_b, + in_operation_param2_ionref_ionsharefd, + in_operation_param2_ionref_ionsize, + + in_operation_param3_tmpref_buffer, + in_operation_param3_tmpref_size, + in_operation_param3_memref_parent, + in_operation_param3_memref_size, + in_operation_param3_memref_offset, + in_operation_param3_value_a, + in_operation_param3_value_b, + in_operation_param3_ionref_ionsharefd, + in_operation_param3_ionref_ionsize, + + in_operation_param4_tmpref_buffer, + in_operation_param4_tmpref_size, + in_operation_param4_memref_parent, + in_operation_param4_memref_size, + in_operation_param4_memref_offset, + in_operation_param4_value_a, + in_operation_param4_value_b, + in_operation_param4_ionref_ionsharefd, + in_operation_param4_ionref_ionsize, + + in_operation_session, + in_operation_cancelflag, + + in_returnorigin, + + in_context_addr, + + + &teecresult, + + &fd, + ta_path, + ta_path_size, + &context_tapath_outsize, + &session_list_next, + &session_list_prev, + &shrd_mem_list_next, + &shrd_mem_list_prev, + &share_buffer_buffer, + &share_buffer_buffer_barrier, + + &seesionid, + &serviceid_timelow, + &serviceid_timemid, + &serviceid_timehiandver, + serviceid_clockseqandnode, + serviceid_clockseqandnode_realsize, + &serviceid_clockseqandnode_outsize_temp, + &opscnt, + &head_next, + &head_prev, + &context, + + &started, + ¶mtypes, + + &operation_param1_tmpref_buffer, + &operation_param1_tmpref_size, + &operation_param1_memref_parent, + &operation_param1_memref_size, + &operation_param1_memref_offset, + &operation_param1_value_a, + &operation_param1_value_b, + &operation_param1_ionref_ionsharefd, + &operation_param1_ionref_ionsize, + + &operation_param2_tmpref_buffer, + &operation_param2_tmpref_size, + &operation_param2_memref_parent, + &operation_param2_memref_size, + &operation_param2_memref_offset, + &operation_param2_value_a, + &operation_param2_value_b, + &operation_param2_ionref_ionsharefd, + &operation_param2_ionref_ionsize, + + &operation_param3_tmpref_buffer, + &operation_param3_tmpref_size, + &operation_param3_memref_parent, + &operation_param3_memref_size, + &operation_param3_memref_offset, + &operation_param3_value_a, + &operation_param3_value_b, + &operation_param3_ionref_ionsharefd, + &operation_param3_ionref_ionsize, + + &operation_param4_tmpref_buffer, + &operation_param4_tmpref_size, + &operation_param4_memref_parent, + &operation_param4_memref_size, + &operation_param4_memref_offset, + &operation_param4_value_a, + &operation_param4_value_b, + &operation_param4_ionref_ionsharefd, + &operation_param4_ionref_ionsize, + + &operation_session, + &operation_cancelflag, + + &returnorigin_temp + ); + + if (teecresult == 0) { + pthread_mutex_lock(mutex_workerrec); + + sin_t * sinIns = (sin_t *)malloc(sizeof(sin_t)); + sinIns->session_id = seesionid; + struct timeval tvcreate; + gettimeofday(&tvcreate, NULL); + sinIns->session_createtime = tvcreate; + if (workerrec[iworker].first == NULL) + { + sinIns->next = NULL; + sinIns->prev = NULL; + workerrec[iworker].first = sinIns; + workerrec[iworker].last = sinIns; + workerrec[iworker].sessionid_count = 1; + } + else + { + sinIns->prev = workerrec[iworker].last; + sinIns->next = NULL; + workerrec[iworker].last->next = sinIns; + workerrec[iworker].last = sinIns; + workerrec[iworker].sessionid_count = + workerrec[iworker].sessionid_count + 1; + } + pthread_mutex_unlock(mutex_workerrec); + } + + serviceid_clockseqandnode_outsize = + serviceid_clockseqandnode_outsize_temp; + returnorigin = returnorigin_temp; + + if (ta_path_size >= context_tapath_outsize) { + ta_path_size = context_tapath_outsize; + charp = ta_path; + } + else + { + ta_path_size = 0; + charp = NULL; + } + + if ( + serviceid_clockseqandnode_realsize >= serviceid_clockseqandnode_outsize && + 8 >= serviceid_clockseqandnode_outsize + ) + { + serviceid_clockseqandnode_realsize = serviceid_clockseqandnode_outsize; + } + else + { + serviceid_clockseqandnode_realsize = 0; + serviceid_clockseqandnode_outsize = 0; + } + + } // end of else found == 1 + + //////////////////////////////////////////////////////////////////////////////////////////////// +#endif + + + // create a reply from the message + reply = dbus_message_new_method_return(msg); + + // add the arguments to the reply + dbus_message_iter_init_append(reply, &args); + dbus_message_iter_open_container( + &args, + DBUS_TYPE_STRUCT, + NULL, + &structIter + ); + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &teecresult + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &fd + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + DBusError err; + // initialise the errors + dbus_error_init(&err); + + if (ta_path_size > 0 && + charp != NULL && + strlen((const char *) charp) > 0 + ) + { + if (dbus_validate_utf8((const char *) charp, &err) == true) + { + ta_path_size = strlen((const char *) charp); + } else + { + ta_path_size = 0; + } + } else + { + ta_path_size = 0; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &ta_path_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (ta_path_size > 0) + { + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_STRING, + &charp + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &session_list_next + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &session_list_prev + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &shrd_mem_list_prev + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &shrd_mem_list_next + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &share_buffer_buffer + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT64, + &share_buffer_buffer_barrier + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &seesionid + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &serviceid_timelow + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &serviceid_timemid + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &serviceid_timehiandver + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &serviceid_clockseqandnode_outsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (serviceid_clockseqandnode_outsize > 0 && + serviceid_clockseqandnode != NULL + ) + { + dbus_message_iter_open_container( + &structIter, + DBUS_TYPE_ARRAY, + buf, + &ArrayIter + ); + + bResult = + dbus_message_iter_append_fixed_array( + &ArrayIter, + DBUS_TYPE_UINT32, + &serviceid_clockseqandnode, + serviceid_clockseqandnode_realsize + ); + + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return NULL; + } + + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &opscnt + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &head_next + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &head_prev + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &context + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &started + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + ¶mtypes + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param1_tmpref_buffer + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param1_tmpref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param1_memref_parent + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param1_memref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param1_memref_offset + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param1_value_a + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param1_value_b + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &operation_param1_ionref_ionsharefd + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param1_ionref_ionsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param2_tmpref_buffer + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param2_tmpref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param2_memref_parent + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param2_memref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param2_memref_offset + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param2_value_a + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param2_value_b + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &operation_param2_ionref_ionsharefd + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param2_ionref_ionsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param3_tmpref_buffer + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param3_tmpref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param3_memref_parent + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param3_memref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param3_memref_offset + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param3_value_a + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param3_value_b + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &operation_param3_ionref_ionsharefd + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param3_ionref_ionsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param4_tmpref_buffer + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param4_tmpref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param4_memref_parent + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param4_memref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param4_memref_offset + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param4_value_a + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param4_value_b + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &operation_param4_ionref_ionsharefd + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param4_ionref_ionsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_session + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &operation_cancelflag + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &returnorigin + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_close_container( + &args, + &structIter + ); + + // send the reply && flush the connection + serial = 100; + if (!dbus_connection_send(conn, reply, &serial)) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + // dbus_connection_close(conn); + // dbus_connection_unref(conn); + free(thdfargs); + + // sleep(2); + +#if 0 + #ifdef GP_WORKER + +#else + if (ta_path == NULL) + { + free(ta_path); + } + if (serviceid_clockseqandnode == NULL) + { + free(serviceid_clockseqandnode); + } +#endif +#endif + + return NULL; +} + + +void * +reply_to_method_call_teec_closesession( + void *thdfargs +) +{ + DBusMsgConn *DBusMCP; + DBusMessage *msg; + DBusConnection *conn; + DBusMessage *reply; + DBusMessageIter args; + dbus_bool_t bResult; + DBusMessageIter structIter; + DBusMessageIter ArrayIter; + int iType; + char buf[2]; + buf[0] = DBUS_TYPE_UINT32; + buf[1] = '\0'; + + dbus_uint32_t in_session_seesionid; + dbus_uint32_t in_session_serviceid_timelow; + dbus_uint32_t in_session_serviceid_timemid; + dbus_uint32_t in_session_serviceid_timehiandver; + dbus_uint32_t in_session_serviceid_clockseqandnode_size; + dbus_uint32_t *in_session_serviceid_clockseqandnode; + int in_session_serviceid_clockseqandnode_realsize; + dbus_uint32_t in_session_opscnt; + dbus_uint64_t in_session_head_next; + dbus_uint64_t in_session_head_prev; + dbus_uint64_t in_session_context; + + dbus_uint32_t seesionid; + dbus_uint32_t serviceid_timelow; + dbus_uint32_t serviceid_timemid; + dbus_uint32_t serviceid_timehiandver; + dbus_uint32_t *serviceid_clockseqandnode; + int serviceid_clockseqandnode_realsize; + dbus_int32_t serviceid_clockseqandnode_outsize; + dbus_uint32_t opscnt; + dbus_uint64_t head_next; + dbus_uint64_t head_prev; + dbus_uint64_t context; + + dbus_uint32_t serial = 0; + +#ifdef GP_PROXY + pthread_mutex_t * mutex_workerrec; + wr_t * workerrec; +#endif + +#ifdef GP_WORKER + pthread_mutex_t *mutex_tcl; + pthread_mutex_t *mutex_tsl; + tcl_t *tcl; + tsl_t *tsl; +#endif + + DBusMCP = (DBusMsgConn *) thdfargs; + msg = DBusMCP->msg; + conn = DBusMCP->conn; +#ifdef GP_PROXY + mutex_workerrec = DBusMCP->mutex_workerrec; + workerrec = DBusMCP->workerrec; +#endif +#ifdef GP_WORKER + mutex_tcl = DBusMCP->mutex_tcl; + mutex_tsl = DBusMCP->mutex_tsl; + tcl = DBusMCP->tcl; + tsl = DBusMCP->tsl; +#endif + + // read the parameters + bResult = + dbus_message_iter_init( + msg, + &args + ); + if (!bResult) + { + fprintf(stderr, "Message has no arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_recurse( + &args, + &structIter + ); + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_get_basic( + &structIter, + &in_session_seesionid); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_serviceid_timelow + ); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_serviceid_timemid); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_serviceid_timehiandver); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_serviceid_clockseqandnode_size); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (in_session_serviceid_clockseqandnode_size > 0) + { + dbus_message_iter_recurse( + &structIter, + &ArrayIter); + + iType = + dbus_message_iter_get_arg_type( + &ArrayIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32, line %d. \n", __LINE__); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_fixed_array( + &ArrayIter, + &in_session_serviceid_clockseqandnode, + &in_session_serviceid_clockseqandnode_realsize + ); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32, line %d. \n", __LINE__); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_get_basic( + &structIter, + &in_session_opscnt); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_head_next); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_head_prev); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_context); + + printf("Received method call Teec Close Session: \n"); + printf(" in_session_seesionid = 0x %8.8x \n", in_session_seesionid); +#if 0 + printf(" in_session_serviceid_timelow = 0x %8.8x \n", in_session_serviceid_timelow); + printf(" in_session_serviceid_timemid = 0x %8.8x \n", in_session_serviceid_timemid); + printf(" in_session_serviceid_timehiandver = 0x %8.8x \n", + in_session_serviceid_timehiandver); + printf(" in_session_serviceid_clockseqandnode = \n"); + printf(" "); + for (int i = 0; i < in_session_serviceid_clockseqandnode_realsize; i++) { + printf(" %8.8x", in_session_serviceid_clockseqandnode[i]); + } + printf("\n"); + printf(" in_session_serviceid_clockseqandnode_size = 0x %8.8x \n", + in_session_serviceid_clockseqandnode_size); + printf(" in_session_opscnt = 0x %8.8x \n", in_session_opscnt); + printf(" in_session_head_next = 0x %16.16lx \n", in_session_head_next); + printf(" in_session_head_prev = 0x %16.16lx \n", in_session_head_prev); +#endif + printf(" in_session_context = 0x %16.16lx \n", in_session_context); + + +#ifdef GP_WORKER + //////////////////////////////////////////////////////////////////////////////////////////////// + + TEEC_Session *sessionIns; + tsn_t *tsnIns; + + sessionIns = NULL; + pthread_mutex_lock(mutex_tsl); + if (tsl->first != NULL) + { + tsnIns = tsl->first; + do + { + if (tsnIns->self->session_id == in_session_seesionid) + { + sessionIns = tsnIns->self; + break; + } + tsnIns = tsnIns->next; + } while (tsnIns != NULL); + } + pthread_mutex_unlock(mutex_tsl); + + if (sessionIns == NULL) + { + if (tsl->first == NULL) + { + printf("The teec session list is null. \n"); + // teecresult = TEEC_ERROR_SESSION_LIST_NULL; + } else + { + printf("Can't find the teec session. \n"); + // teecresult = TEEC_ERROR_NO_SESSION_MATCH; + } + + seesionid = 0x0; + serviceid_timelow = 0x0; + serviceid_timemid = 0x0; + serviceid_timehiandver = 0x0; + opscnt = 0x0; + head_next = 0x0; + head_prev = 0x0; + context = 0x0; + + serviceid_clockseqandnode_realsize = 8; + serviceid_clockseqandnode = + (dbus_uint32_t *) malloc( + serviceid_clockseqandnode_realsize * sizeof(dbus_uint32_t) + ); + for (int i = 0; i < serviceid_clockseqandnode_realsize; i++) + { + serviceid_clockseqandnode[i] = 0x0; + } + serviceid_clockseqandnode_outsize = 8; + } else + { + sessionIns->session_id = in_session_seesionid; +#if 0 + sessionIns->service_id.timeLow = in_session_serviceid_timelow; + sessionIns->service_id.timeMid = in_session_serviceid_timemid; + sessionIns->service_id.timeHiAndVersion = in_session_serviceid_timehiandver; + if ( in_session_serviceid_clockseqandnode_realsize <= 8 && + in_session_serviceid_clockseqandnode_realsize > 0 && + in_session_serviceid_clockseqandnode != NULL + ) + { + for (int i = 0; i < in_session_serviceid_clockseqandnode_realsize; i++) { + sessionIns->service_id.clockSeqAndNode[i] = + (uint8_t)(in_session_serviceid_clockseqandnode[i] & 0x000000ff); + } + } + else + { + for (int i = 0; i < 8; i++) { + sessionIns->service_id.clockSeqAndNode[i] = 0; + } + } + sessionIns->ops_cnt = in_session_opscnt; + sessionIns->head.next = (struct ListNode *)in_session_head_next; + sessionIns->head.prev = (struct ListNode *)in_session_head_prev; + // sessionIns->context = (TEEC_Context *)in_session_context; +#endif + +#if 0 + printf("Call TEEC_CloseSession inputs: \n"); + printf(" session_seesionid = 0x %8.8x \n", sessionIns->session_id); + printf(" session_serviceid_timelow = 0x %8.8x \n", sessionIns->service_id.timeLow); + printf(" session_serviceid_timemid = 0x %4.4x \n", sessionIns->service_id.timeMid); + printf(" session_serviceid_timehiandver = 0x %4.4x \n", + sessionIns->service_id.timeHiAndVersion); + printf(" session_serviceid_clockseqandnode = \n"); + printf(" "); + for (int i = 0; i < 8; i++) { + printf(" %2.2x", sessionIns->service_id.clockSeqAndNode[i]); + } + printf("\n"); + printf(" session_opscnt = 0x %8.8x \n", sessionIns->ops_cnt); + printf(" session_head_next = 0x %16.16lx \n", sessionIns->head.next); + printf(" session_head_prev = 0x %16.16lx \n", sessionIns->head.prev); + printf(" session_context = 0x %16.16lx \n", sessionIns->context); +#endif + struct timeval start, end; + gettimeofday(&start, NULL); + TEEC_CloseSession( + sessionIns + ); + gettimeofday(&end, NULL); + uint32_t cost = 0; + cost += (1000000 * end.tv_sec + end.tv_usec) - (1000000 * start.tv_sec + start.tv_usec); + + printf("Teec CloseSession executed, cost time: %ld us \n", cost); + + seesionid = sessionIns->session_id; + serviceid_timelow = sessionIns->service_id.timeLow; + serviceid_timemid = sessionIns->service_id.timeMid; + serviceid_timehiandver = sessionIns->service_id.timeHiAndVersion; +#if 0 + printf(" in_session_serviceid_clockseqandnode = \n"); + printf(" "); + for (int i = 0; i < 8; i++) { + printf(" %2.2x", in_session_serviceid_clockseqandnode[i]); + } + printf("\n"); +#endif + if (sessionIns->service_id.clockSeqAndNode != NULL) + { + serviceid_clockseqandnode_realsize = 8; + serviceid_clockseqandnode = + (dbus_uint32_t *) malloc( + serviceid_clockseqandnode_realsize * sizeof(dbus_uint32_t) + ); + for (int iind = 0; iind < 8; iind++) + { + uint8_t u8Temp; + u8Temp = sessionIns->service_id.clockSeqAndNode[iind]; + serviceid_clockseqandnode[iind] = (dbus_uint32_t) u8Temp; + } + serviceid_clockseqandnode_outsize = 8; + } else + { + serviceid_clockseqandnode_realsize = 0; + serviceid_clockseqandnode = NULL; + serviceid_clockseqandnode_outsize = 0; + } + opscnt = sessionIns->ops_cnt; + head_next = (dbus_uint64_t) sessionIns->head.next; + head_prev = (dbus_uint64_t) sessionIns->head.prev; + context = (dbus_uint64_t) sessionIns->context; + + printf(" ret sessionid = 0x %8.8x \n", seesionid); + printf(" ret context = 0x %16.16lx \n", context); + + tsn_t *tsnTemp; + tsnTemp = tsnIns->prev; + if (tsnTemp != NULL) + { + tsnTemp->next = tsnIns->next; + } + tsnTemp = tsnIns->next; + if (tsnTemp != NULL) + { + tsnTemp->prev = tsnIns->prev; + } + pthread_mutex_lock(mutex_tsl); + if (tsl->last == tsnIns) + { + tsl->last = tsnIns->prev; + } + if (tsl->first == tsnIns) + { + tsl->first = tsnIns->next; + } + tsl->count = tsl->count - 1; + pthread_mutex_unlock(mutex_tsl); + free(sessionIns); + free(tsnIns); + } + //////////////////////////////////////////////////////////////////////////////////////////////// +#else + + uint32_t serviceid_clockseqandnode_outsize_temp; + serviceid_clockseqandnode_realsize = 8; + serviceid_clockseqandnode = + (dbus_uint32_t *)malloc( + serviceid_clockseqandnode_realsize * sizeof(dbus_uint32_t) + ); + + char workername[1024]; + memset((char *)workername, 0, 1024); + // sprintf(workername, "%s", "gpworker1"); + int ifound = 0; + int iworker; + sin_t * sinIns; + + pthread_mutex_lock(mutex_workerrec); + for (iworker = 0; iworker < MAX_NUM_WORKER; iworker++) + { + if (workerrec[iworker].context_addr == in_session_context) + { + sinIns = NULL; + if (workerrec[iworker].first != NULL) + { + sinIns = workerrec[iworker].first; + do + { + if (sinIns->session_id == in_session_seesionid) + { + sprintf(workername, "%s%d", "gpworker", iworker); + ifound = 1; + break; + } + sinIns = sinIns->next; + }while (sinIns != NULL); + + + if ( ifound == 1 ) + { + break; + } + } + } + } + pthread_mutex_unlock(mutex_workerrec); + + + if (ifound == 0) + { + printf("Can't find the worker for the session and the context. \n"); + + seesionid = 0x0; + serviceid_timelow = 0x0; + serviceid_timemid = 0x0; + serviceid_timehiandver = 0x0; + opscnt = 0x0; + head_next = 0x0; + head_prev = 0x0; + context = 0x0; + + serviceid_clockseqandnode_realsize = 8; + serviceid_clockseqandnode = + (dbus_uint32_t *)malloc( + serviceid_clockseqandnode_realsize * sizeof(dbus_uint32_t) + ); + for (int i = 0; i < serviceid_clockseqandnode_realsize ; i++) { + serviceid_clockseqandnode[i] = 0x0; + } + serviceid_clockseqandnode_outsize = 8; + } + else + { + method_call_teec_closesession( + workername, + + in_session_seesionid, + in_session_serviceid_timelow, + in_session_serviceid_timemid, + in_session_serviceid_timehiandver, + in_session_serviceid_clockseqandnode, + in_session_serviceid_clockseqandnode_realsize, + in_session_opscnt, + in_session_head_next, + in_session_head_prev, + in_session_context, + + &seesionid, + &serviceid_timelow, + &serviceid_timemid, + &serviceid_timehiandver, + serviceid_clockseqandnode, + serviceid_clockseqandnode_realsize, + &serviceid_clockseqandnode_outsize_temp, + &opscnt, + &head_next, + &head_prev, + &context + ); + + pthread_mutex_lock(mutex_workerrec); + sin_t * sinTemp; + sinTemp = sinIns->prev; + if (sinTemp != NULL) + { + sinTemp->next = sinIns->next; + } + sinTemp = sinIns->next; + if (sinTemp != NULL) + { + sinTemp->prev = sinIns->prev; + } + if (workerrec[iworker].last == sinIns) + { + workerrec[iworker].last = sinIns->prev; + } + if (workerrec[iworker].first == sinIns) + { + workerrec[iworker].first = sinIns->next; + } + free(sinIns); + workerrec[iworker].sessionid_count = + workerrec[iworker].sessionid_count - 1; + pthread_mutex_unlock(mutex_workerrec); + + serviceid_clockseqandnode_outsize = serviceid_clockseqandnode_outsize_temp; + + if ( + serviceid_clockseqandnode_realsize >= serviceid_clockseqandnode_outsize && + 8 >= serviceid_clockseqandnode_outsize + ) + { + serviceid_clockseqandnode_realsize = serviceid_clockseqandnode_outsize; + } + else + { + serviceid_clockseqandnode_realsize = 0; + serviceid_clockseqandnode_outsize = 0; + } + + }// end of else found == 1 +#endif + + + // create a reply from the message + reply = dbus_message_new_method_return(msg); + + // add the arguments to the reply + dbus_message_iter_init_append(reply, &args); + dbus_message_iter_open_container( + &args, + DBUS_TYPE_STRUCT, + NULL, + &structIter + ); + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &seesionid + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &serviceid_timelow + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &serviceid_timemid + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &serviceid_timehiandver + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &serviceid_clockseqandnode_outsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (serviceid_clockseqandnode_outsize > 0 && + serviceid_clockseqandnode != NULL + ) + { + dbus_message_iter_open_container( + &structIter, + DBUS_TYPE_ARRAY, + buf, + &ArrayIter + ); + + bResult = + dbus_message_iter_append_fixed_array( + &ArrayIter, + DBUS_TYPE_UINT32, + &serviceid_clockseqandnode, + serviceid_clockseqandnode_realsize + ); + + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return NULL; + } + + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &opscnt + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &head_next + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &head_prev + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &context + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_close_container( + &args, + &structIter + ); + + // send the reply && flush the connection + serial = 100; + if (!dbus_connection_send(conn, reply, &serial)) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + // dbus_connection_close(conn); + // dbus_connection_unref(conn); + free(thdfargs); + + // sleep(2); + + return NULL; +} + + +void * +reply_to_method_call_teec_invokecommand( + void *thdfargs +) +{ + DBusMsgConn *DBusMCP; + DBusMessage *msg; + DBusConnection *conn; + DBusMessage *reply; + DBusMessageIter args; + dbus_bool_t bResult; + DBusMessageIter structIter; + DBusMessageIter ArrayIter; + int iType; + char buf[2]; + buf[0] = DBUS_TYPE_UINT32; + buf[1] = '\0'; + + dbus_uint32_t in_session_sessionid; + dbus_uint32_t in_session_serviceid_timelow; + dbus_uint32_t in_session_serviceid_timemid; + dbus_uint32_t in_session_serviceid_timehiandver; + dbus_uint32_t in_session_serviceid_clockseqandnode_size; + dbus_uint32_t *in_session_serviceid_clockseqandnode; + int in_session_serviceid_clockseqandnode_realsize; + dbus_uint32_t in_session_opscnt; + dbus_uint64_t in_session_head_next; + dbus_uint64_t in_session_head_prev; + dbus_uint64_t in_session_context; + + dbus_uint32_t in_commandid; + + dbus_uint32_t in_operation_started; + dbus_uint32_t in_operation_paramtypes; + + dbus_uint64_t in_operation_param1_tmpref_buffer; + dbus_uint32_t in_operation_param1_tmpref_size; + dbus_uint64_t in_operation_param1_memref_parent; + dbus_uint32_t in_operation_param1_memref_parent_flag; + dbus_uint32_t in_operation_param1_memref_size; + dbus_uint32_t in_operation_param1_memref_offset; + dbus_uint32_t in_operation_param1_value_a; + dbus_uint32_t in_operation_param1_value_b; + dbus_int32_t in_operation_param1_ionref_ionsharefd; + dbus_uint32_t in_operation_param1_ionref_ionsize; + + dbus_uint64_t in_operation_param2_tmpref_buffer; + dbus_uint32_t in_operation_param2_tmpref_size; + dbus_uint64_t in_operation_param2_memref_parent; + dbus_uint32_t in_operation_param2_memref_parent_flag; + dbus_uint32_t in_operation_param2_memref_size; + dbus_uint32_t in_operation_param2_memref_offset; + dbus_uint32_t in_operation_param2_value_a; + dbus_uint32_t in_operation_param2_value_b; + dbus_int32_t in_operation_param2_ionref_ionsharefd; + dbus_uint32_t in_operation_param2_ionref_ionsize; + + dbus_uint64_t in_operation_param3_tmpref_buffer; + dbus_uint32_t in_operation_param3_tmpref_size; + dbus_uint64_t in_operation_param3_memref_parent; + dbus_uint32_t in_operation_param3_memref_parent_flag; + dbus_uint32_t in_operation_param3_memref_size; + dbus_uint32_t in_operation_param3_memref_offset; + dbus_uint32_t in_operation_param3_value_a; + dbus_uint32_t in_operation_param3_value_b; + dbus_int32_t in_operation_param3_ionref_ionsharefd; + dbus_uint32_t in_operation_param3_ionref_ionsize; + + dbus_uint64_t in_operation_param4_tmpref_buffer; + dbus_uint32_t in_operation_param4_tmpref_size; + dbus_uint64_t in_operation_param4_memref_parent; + dbus_uint32_t in_operation_param4_memref_parent_flag; + dbus_uint32_t in_operation_param4_memref_size; + dbus_uint32_t in_operation_param4_memref_offset; + dbus_uint32_t in_operation_param4_value_a; + dbus_uint32_t in_operation_param4_value_b; + dbus_int32_t in_operation_param4_ionref_ionsharefd; + dbus_uint32_t in_operation_param4_ionref_ionsize; + + dbus_uint64_t in_operation_session; + dbus_int32_t in_operation_cancelflag; + + dbus_uint32_t in_returnorigin; + + dbus_uint32_t in_buffer1_size; + dbus_uint32_t *in_buffer1; + int in_buffer1_realsize; + dbus_uint32_t in_buffer2_size; + dbus_uint32_t *in_buffer2; + int in_buffer2_realsize; + dbus_uint32_t in_buffer3_size; + dbus_uint32_t *in_buffer3; + int in_buffer3_realsize; + dbus_uint32_t in_buffer4_size; + dbus_uint32_t *in_buffer4; + int in_buffer4_realsize; + + dbus_int32_t lt_flag; + + dbus_uint32_t teecresult; + + dbus_uint32_t sessionid; + dbus_uint32_t serviceid_timelow; + dbus_uint32_t serviceid_timemid; + dbus_uint32_t serviceid_timehiandver; + dbus_uint32_t *serviceid_clockseqandnode; + int serviceid_clockseqandnode_realsize; + dbus_uint32_t serviceid_clockseqandnode_outsize; + dbus_uint32_t opscnt; + dbus_uint64_t head_next; + dbus_uint64_t head_prev; + dbus_uint64_t context; + + dbus_uint32_t started; + dbus_uint32_t paramtypes; + + dbus_uint64_t operation_param1_tmpref_buffer; + dbus_uint32_t operation_param1_tmpref_size; + dbus_uint64_t operation_param1_memref_parent; + dbus_uint32_t operation_param1_memref_parent_flag; + dbus_uint32_t operation_param1_memref_size; + dbus_uint32_t operation_param1_memref_offset; + dbus_uint32_t operation_param1_value_a; + dbus_uint32_t operation_param1_value_b; + dbus_int32_t operation_param1_ionref_ionsharefd; + dbus_uint32_t operation_param1_ionref_ionsize; + + dbus_uint64_t operation_param2_tmpref_buffer; + dbus_uint32_t operation_param2_tmpref_size; + dbus_uint64_t operation_param2_memref_parent; + dbus_uint32_t operation_param2_memref_parent_flag; + dbus_uint32_t operation_param2_memref_size; + dbus_uint32_t operation_param2_memref_offset; + dbus_uint32_t operation_param2_value_a; + dbus_uint32_t operation_param2_value_b; + dbus_int32_t operation_param2_ionref_ionsharefd; + dbus_uint32_t operation_param2_ionref_ionsize; + + dbus_uint64_t operation_param3_tmpref_buffer; + dbus_uint32_t operation_param3_tmpref_size; + dbus_uint64_t operation_param3_memref_parent; + dbus_uint32_t operation_param3_memref_parent_flag; + dbus_uint32_t operation_param3_memref_size; + dbus_uint32_t operation_param3_memref_offset; + dbus_uint32_t operation_param3_value_a; + dbus_uint32_t operation_param3_value_b; + dbus_int32_t operation_param3_ionref_ionsharefd; + dbus_uint32_t operation_param3_ionref_ionsize; + + dbus_uint64_t operation_param4_tmpref_buffer; + dbus_uint32_t operation_param4_tmpref_size; + dbus_uint64_t operation_param4_memref_parent; + dbus_uint32_t operation_param4_memref_parent_flag; + dbus_uint32_t operation_param4_memref_size; + dbus_uint32_t operation_param4_memref_offset; + dbus_uint32_t operation_param4_value_a; + dbus_uint32_t operation_param4_value_b; + dbus_int32_t operation_param4_ionref_ionsharefd; + dbus_uint32_t operation_param4_ionref_ionsize; + + dbus_uint64_t operation_session; + dbus_int32_t operation_cancelflag; + + dbus_uint32_t returnorigin; + + dbus_uint32_t *buffer1; + int buffer1_realsize; + dbus_uint32_t buffer1_outsize; + dbus_uint32_t *buffer2; + int buffer2_realsize; + dbus_uint32_t buffer2_outsize; + dbus_uint32_t *buffer3; + int buffer3_realsize; + dbus_uint32_t buffer3_outsize; + dbus_uint32_t *buffer4; + int buffer4_realsize; + dbus_uint32_t buffer4_outsize; + + dbus_uint32_t serial = 0; + +#ifdef GP_PROXY + pthread_mutex_t * mutex_workerrec; + wr_t * workerrec; +#endif + +#ifdef GP_WORKER + pthread_mutex_t *mutex_tcl; + pthread_mutex_t *mutex_tsl; + tcl_t *tcl; + tsl_t *tsl; +#endif + + DBusMCP = (DBusMsgConn *) thdfargs; + msg = DBusMCP->msg; + conn = DBusMCP->conn; +#ifdef GP_PROXY + mutex_workerrec = DBusMCP->mutex_workerrec; + workerrec = DBusMCP->workerrec; +#endif +#ifdef GP_WORKER + mutex_tcl = DBusMCP->mutex_tcl; + mutex_tsl = DBusMCP->mutex_tsl; + tcl = DBusMCP->tcl; + tsl = DBusMCP->tsl; +#endif + + // read the parameters + bResult = + dbus_message_iter_init( + msg, + &args + ); + if (!bResult) + { + fprintf(stderr, "Message has no arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_recurse( + &args, + &structIter + ); + + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_sessionid); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_serviceid_timelow + ); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_serviceid_timemid); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_serviceid_timehiandver); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_serviceid_clockseqandnode_size); + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (in_session_serviceid_clockseqandnode_size > 0) + { + dbus_message_iter_recurse( + &structIter, + &ArrayIter); + + iType = + dbus_message_iter_get_arg_type( + &ArrayIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32, line %d. \n", __LINE__); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_fixed_array( + &ArrayIter, + &in_session_serviceid_clockseqandnode, + &in_session_serviceid_clockseqandnode_realsize + ); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32, line %d. \n", __LINE__); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_get_basic( + &structIter, + &in_session_opscnt); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_head_next); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_head_prev); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_session_context); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_commandid); + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_started); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_paramtypes); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_tmpref_buffer); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_tmpref_size); + + bResult = dbus_message_iter_next(&structIter); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = dbus_message_iter_get_arg_type(&structIter); + if (iType != DBUS_TYPE_UINT64) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_memref_parent); + + bResult = dbus_message_iter_next(&structIter); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = dbus_message_iter_get_arg_type(&structIter); + if (iType != DBUS_TYPE_UINT32) + { + fprintf(stderr, "Argument is not UINT32. \n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_memref_parent_flag); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_memref_size); + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_memref_offset); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_value_a); + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_value_b); + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_ionref_ionsharefd); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param1_ionref_ionsize); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_tmpref_buffer); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_tmpref_size); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_memref_parent); + + bResult = dbus_message_iter_next(&structIter); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = dbus_message_iter_get_arg_type(&structIter); + if (iType != DBUS_TYPE_UINT32) + { + fprintf(stderr, "Argument is not UINT32. \n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_memref_parent_flag); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_memref_size); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_memref_offset); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_value_a); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_value_b); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_ionref_ionsharefd); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param2_ionref_ionsize); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_tmpref_buffer); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_tmpref_size); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_memref_parent); + + bResult = dbus_message_iter_next(&structIter); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = dbus_message_iter_get_arg_type(&structIter); + if (iType != DBUS_TYPE_UINT32) + { + fprintf(stderr, "Argument is not UINT32. \n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_memref_parent_flag); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_memref_size); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_memref_offset); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_value_a); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_value_b); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_ionref_ionsharefd); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param3_ionref_ionsize); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_tmpref_buffer); + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_tmpref_size); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_memref_parent); + + bResult = dbus_message_iter_next(&structIter); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = dbus_message_iter_get_arg_type(&structIter); + if (iType != DBUS_TYPE_UINT32) + { + fprintf(stderr, "Argument is not UINT32. \n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_memref_parent_flag); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_memref_size); + + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_memref_offset); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_value_a); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_value_b); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_ionref_ionsharefd); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_param4_ionref_ionsize); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT64 + ) + { + fprintf(stderr, "Argument is not UINT64.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_session); + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_operation_cancelflag); + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_returnorigin); + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_buffer1_size); + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (in_buffer1_size > 0) + { + dbus_message_iter_recurse( + &structIter, + &ArrayIter); + + iType = + dbus_message_iter_get_arg_type( + &ArrayIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32, line %d. \n", __LINE__); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_fixed_array( + &ArrayIter, + &in_buffer1, + &in_buffer1_realsize + ); + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_buffer2_size); + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (in_buffer2_size > 0) + { + dbus_message_iter_recurse( + &structIter, + &ArrayIter); + + iType = + dbus_message_iter_get_arg_type( + &ArrayIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32, line %d. \n", __LINE__); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_fixed_array( + &ArrayIter, + &in_buffer2, + &in_buffer2_realsize + ); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_buffer3_size); + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (in_buffer3_size > 0) + { + dbus_message_iter_recurse( + &structIter, + &ArrayIter); + + iType = + dbus_message_iter_get_arg_type( + &ArrayIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32, line %d. \n", __LINE__); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_fixed_array( + &ArrayIter, + &in_buffer3, + &in_buffer3_realsize + ); + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + } + + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not INT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + &in_buffer4_size); + + if (in_buffer4_size > 0) + { + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_iter_recurse( + &structIter, + &ArrayIter); + + iType = + dbus_message_iter_get_arg_type( + &ArrayIter + ); + if ( + iType != DBUS_TYPE_UINT32 + ) + { + fprintf(stderr, "Argument is not UINT32, line %d. \n", __LINE__); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_fixed_array( + &ArrayIter, + &in_buffer4, + &in_buffer4_realsize + ); + } + + bResult = + dbus_message_iter_next( + &structIter + ); + if (!bResult) + { + fprintf(stderr, "Message has too few arguments!\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + iType = + dbus_message_iter_get_arg_type( + &structIter + ); + if ( + iType != DBUS_TYPE_INT32 + ) + { + fprintf(stderr, "Argument is not UINT32.\n"); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + dbus_message_iter_get_basic( + &structIter, + <_flag); + + printf("Received method call TEEC_InvokeCommand: \n"); + printf(" lt_flag = %d \n", lt_flag); + printf(" in_session_sessionid = 0x %8.8x \n", in_session_sessionid); +#if 0 + printf(" in_session_serviceid_timelow = 0x %8.8x \n", in_session_serviceid_timelow); + printf(" in_session_serviceid_timemid = 0x %8.8x \n", in_session_serviceid_timemid); + printf(" in_session_serviceid_timehiandver = 0x %8.8x \n", + in_session_serviceid_timehiandver); + printf(" in_session_serviceid_clockseqandnode = \n"); + printf(" "); + for (int i = 0; i < in_session_serviceid_clockseqandnode_realsize; i++) { + printf(" %2.2x", in_session_serviceid_clockseqandnode[i]); + } + printf("\n"); + printf(" in serviceid_clockseqandnode_size = 0x %8.8x \n", + in_session_serviceid_clockseqandnode_size); + printf(" in_session_opscnt = 0x %8.8x \n", in_session_opscnt); + printf(" in_session_head_next = 0x %16.16lx \n", in_session_head_next); + printf(" in_session_head_prev = 0x %16.16lx \n", in_session_head_prev); +#endif + printf(" in_session_context = 0x %16.16lx \n", in_session_context); +#if 0 + printf(" commandid = 0x %8.8x \n", in_commandid); + + printf(" in_operation_started = 0x %8.8x \n", in_operation_started); + printf(" in_operation_paramtypes = 0x %8.8x \n", in_operation_paramtypes); + + printf(" in_operation_param1_tmpref_buffer = 0x %16.16lx \n", in_operation_param1_tmpref_buffer); + printf(" in_operation_param1_tmpref_size = 0x %8.8x \n", in_operation_param1_tmpref_size); + printf(" in_operation_param1_memref_parent = 0x %16.16lx \n", in_operation_param1_memref_parent); + printf(" in_operation_param1_memref_size = 0x %8.8x \n", in_operation_param1_memref_size); + printf(" in_operation_param1_memref_offset = 0x %8.8x \n", in_operation_param1_memref_offset); + printf(" in_operation_param1_value_a = 0x %8.8x \n", in_operation_param1_value_a); + printf(" in_operation_param1_value_b = 0x %8.8x \n", in_operation_param1_value_b); + printf(" in_operation_param1_ionref_ionsharefd = 0x %8.8x \n",in_operation_param2_ionref_ionsharefd); + printf(" in_operation_param1_ionref_ionsize = 0x %8.8x \n", in_operation_param2_ionref_ionsize); + + printf(" in_operation_param2_tmpref_buffer = 0x %16.16lx \n", in_operation_param2_tmpref_buffer); + printf(" in_operation_param2_tmpref_size = 0x %8.8x \n", in_operation_param2_tmpref_size); + printf(" in_operation_param2_memref_parent = 0x %16.16lx \n", in_operation_param2_memref_parent); + printf(" in_operation_param2_memref_size = 0x %8.8x \n", in_operation_param2_memref_size); + printf(" in_operation_param2_memref_offset = 0x %8.8x \n", in_operation_param2_memref_offset); + printf(" in_operation_param2_value_a = 0x %8.8x \n", in_operation_param3_value_a); + printf(" in_operation_param2_value_b = 0x %8.8x \n", in_operation_param3_value_b); + printf(" in_operation_param2_ionref_ionsharefd = 0x %8.8x \n", in_operation_param3_ionref_ionsharefd); + printf(" in_operation_param2_ionref_ionsize = 0x %8.8x \n", in_operation_param3_ionref_ionsize); + + printf(" in_operation_param3_tmpref_buffer = 0x %16.16lx \n", in_operation_param3_tmpref_buffer); + printf(" in_operation_param3_tmpref_size = 0x %8.8x \n", in_operation_param3_tmpref_size); + printf(" in_operation_param3_memref_parent = 0x %16.16lx \n", in_operation_param3_memref_parent); + printf(" in_operation_param3_memref_size = 0x %8.8x \n", in_operation_param3_memref_size); + printf(" in_operation_param3_memref_offset = 0x %8.8x \n", in_operation_param3_memref_offset); + printf(" in_operation_param3_value_a = 0x %8.8x \n", in_operation_param3_value_a); + printf(" in_operation_param3_value_b = 0x %8.8x \n", in_operation_param3_value_b); + printf(" in_operation_param3_ionref_ionsharefd = 0x %8.8x \n", in_operation_param3_ionref_ionsharefd); + printf(" in_operation_param3_ionref_ionsize = 0x %8.8x \n", in_operation_param3_ionref_ionsize); + + printf(" in_operation_param4_tmpref_buffer = 0x %16.16lx \n", in_operation_param4_tmpref_buffer); + printf(" in_operation_param4_tmpref_size = 0x %8.8x \n", in_operation_param4_tmpref_size); + printf(" in_operation_param4_memref_parent = 0x %16.16lx \n", in_operation_param4_memref_parent); + printf(" in_operation_param4_memref_size = 0x %8.8x \n", in_operation_param4_memref_size); + printf(" in_operation_param4_memref_offset = 0x %8.8x \n", in_operation_param4_memref_offset); + printf(" in_operation_param4_value_a = 0x %8.8x \n", in_operation_param4_value_a); + printf(" in_operation_param4_value_b = 0x %8.8x \n", in_operation_param4_value_b); + printf(" in_operation_param4_ionref_ionsharefd = 0x %8.8x \n", in_operation_param4_ionref_ionsharefd); + printf(" in_operation_param4_ionref_ionsize = 0x %8.8x \n", in_operation_param4_ionref_ionsize); + + printf(" in_operation_session = 0x %16.16lx \n", in_operation_session); + printf(" in_operation_cancelflag = 0x %8.8x \n", in_operation_cancelflag); + + printf(" in_returnorigin = 0x %8.8x \n", in_returnorigin); + + printf(" in_buffer1 = \n"); + if (in_buffer1_size > 0) { + printf(" "); + for (int i = 0; i < in_buffer1_realsize; i++) { + printf(" %2.2x", in_buffer1[i]); + } + printf("\n"); + } +#endif + +#if 0 + printf(" in_buffer1_size = 0x %8.8x \n", + in_buffer1_size); +#endif + +#if 0 + printf(" in_buffer2 = \n"); + if (in_buffer2_size > 0) { + printf(" "); + for (int i = 0; i < in_buffer2_realsize; i++) { + printf(" %2.2x", in_buffer2[i]); + } + printf("\n"); + } + printf(" in_buffer2_size = 0x %8.8x \n", + in_buffer2_size); + + printf(" in_buffer3 = \n"); + if (in_buffer3_size > 0) { + printf(" "); + for (int i = 0; i < in_buffer3_realsize; i++) { + printf(" %2.2x", in_buffer3[i]); + } + printf("\n"); + } + printf(" in_buffer3_size = 0x %8.8x \n", + in_buffer3_size); + + printf(" in_buffer4 = \n"); + if (in_buffer4_size > 0) { + printf(" "); + for (int i = 0; i < in_buffer4_realsize; i++) { + printf(" %2.2x", in_buffer4[i]); + } + printf("\n"); + } + printf(" in_buffer4_size = 0x %8.8x \n", + in_buffer4_size); +#endif + +#ifdef GP_WORKER + ////////////////////////////////////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////////////////////////////////////// + TEEC_Session *sessionIns; + TEEC_Session *sessionIns_temp= (TEEC_Session *) malloc(sizeof(TEEC_Session)); + tsn_t *tsnIns_temp = (tsn_t *) malloc(sizeof(tsn_t)); + tsn_t *tsnIns; + sessionIns = NULL; + + TEEC_Context *contextIns; + TEEC_Context *contextIns_temp = (TEEC_Context *) malloc(sizeof(TEEC_Context)); + + tcn_t *tcnIns_temp = (tcn_t *) malloc(sizeof(tcn_t)); + tcnIns_temp->self = contextIns_temp; + tcn_t *tcnIns; + contextIns = NULL; + + + if(lt_flag == 1){ + struct timeval ltstart, ltend; + gettimeofday(<start, NULL); + pthread_mutex_lock(mutex_tcl); + pthread_mutex_lock(mutex_tsl); + //if(tcl_flag == 0) + //{ + if(load_tcl(tcl,tcnIns_temp,in_session_sessionid) != 0){ + printf("session 0x %8.8x load_tcl error\n",in_session_sessionid); + } + //} + //tcnIns_temp->self->ta_path = + if(load_tsl(tsl,tsnIns_temp,tcnIns_temp,sessionIns_temp,in_session_sessionid) != 0){ + printf("session 0x %8.8x load_tsl error\n",in_session_sessionid); + } + pthread_mutex_unlock(mutex_tsl); + pthread_mutex_unlock(mutex_tcl); + gettimeofday(<end, NULL); + int zi64Time = (ltend.tv_sec - ltstart.tv_sec) * 1000000 + + (ltend.tv_usec - ltstart.tv_usec); + printf("gpworker huifu xxxxxx used time: %ld us. \n", zi64Time); + } + + pthread_mutex_lock(mutex_tsl); + tsnIns = tsl->first; + printf("tsl count = %d\n",tsl->count); + printf("session_id = 0x %8.8x \n",in_session_sessionid); + while(tsnIns != NULL){ + printf("tsnIns->self->session_id = 0x %8.8x \n",tsnIns->self->session_id); + printf("tsnIns->self = %p \n",tsnIns->self); + tsnIns = tsnIns->next; + } + if (tsl->first != NULL) + { + tsnIns = tsl->first; + do + { + printf("in find tsnIns->self->session_id = 0x %8.8x \n",tsnIns->self->session_id); + if (tsnIns->self->session_id == in_session_sessionid) + { + sessionIns = tsnIns->self; + break; + } + tsnIns = tsnIns->next; + //printf("tsnIns->self->session_id = 0x %8.8x \n",tsnIns->self->session_id); + } while (tsnIns != NULL); + } + pthread_mutex_unlock(mutex_tsl); + + + if (sessionIns != NULL) + { + pthread_mutex_lock(mutex_tcl); + if (tcl->first != NULL) + { + tcnIns = tcl->first; + do + { + contextIns = tcnIns->self; + if (contextIns == sessionIns->context) + { + printf("find tcnIns->self = 0x %8.8x \n",tcnIns->self); + break; + } + tcnIns = tcnIns->next; + } while (tcnIns != NULL); + } + pthread_mutex_unlock(mutex_tcl); + } + + if (sessionIns == NULL || contextIns == NULL) + { + if (sessionIns == NULL) + { + if (tsl->first == NULL) + { + printf("The teec session list is null. \n"); + teecresult = TEEC_ERROR_SESSION_LIST_NULL; + } else + { + printf("Can't find the teec session. \n"); + + teecresult = TEEC_ERROR_NO_SESSION_MATCH; + } + } + + if (contextIns == NULL) + { + if (tcl->first == NULL) + { + printf("The teec context list is null. \n"); + teecresult = TEEC_ERROR_CONTEXT_LIST_NULL; + } else + { + printf("Can't find the teec context. \n"); + teecresult = TEEC_ERROR_NO_CONTEXT_MATCH; + } + } + + sessionid = 0; + serviceid_timelow = 0; + serviceid_timemid = 0; + serviceid_timehiandver = 0; + serviceid_clockseqandnode_realsize = 0; + serviceid_clockseqandnode = NULL; + serviceid_clockseqandnode_outsize = 0; + opscnt = 0; + head_next = 0; + head_prev = 0; + context = 0; + + started = 0; + paramtypes = 0; + + operation_param1_tmpref_buffer = 0; + operation_param1_tmpref_size = 0; + operation_param1_memref_parent = 0; + operation_param1_memref_parent_flag = 0; + operation_param1_memref_size = 0; + operation_param1_memref_offset = 0; + operation_param1_value_a = 0; + operation_param1_value_b = 0; + operation_param1_ionref_ionsharefd = 0; + operation_param1_ionref_ionsize = 0; + + operation_param2_tmpref_buffer = 0; + operation_param2_tmpref_size = 0; + operation_param2_memref_parent = 0; + operation_param2_memref_parent_flag = 0; + operation_param2_memref_size = 0; + operation_param2_memref_offset = 0; + operation_param2_value_a = 0; + operation_param2_value_b = 0; + operation_param2_ionref_ionsharefd = 0; + operation_param2_ionref_ionsize = 0; + + operation_param3_tmpref_buffer = 0; + operation_param3_tmpref_size = 0; + operation_param3_memref_parent = 0; + operation_param3_memref_parent_flag = 0; + operation_param3_memref_size = 0; + operation_param3_memref_offset = 0; + operation_param3_value_a = 0; + operation_param3_value_b = 0; + operation_param3_ionref_ionsharefd = 0; + operation_param3_ionref_ionsize = 0; + + operation_param4_tmpref_buffer = 0; + operation_param4_tmpref_size = 0; + operation_param4_memref_parent = 0; + operation_param4_memref_parent_flag = 0; + operation_param4_memref_size = 0; + operation_param4_memref_offset = 0; + operation_param4_value_a = 0; + operation_param4_value_b = 0; + operation_param4_ionref_ionsharefd = 0; + operation_param4_ionref_ionsize = 0; + + operation_session = 0; + operation_cancelflag = 0; + + returnorigin = 0xff; + + buffer1_realsize = 0; + buffer1 = NULL; + buffer1_outsize = 0; + buffer2_realsize = 0; + buffer2 = NULL; + buffer2_outsize = 0; + buffer3_realsize = 0; + buffer3 = NULL; + buffer3_outsize = 0; + buffer4_realsize = 0; + buffer4 = NULL; + buffer4_outsize = 0; + } + else + { + teecresult = TEEC_SUCCESS; + + sessionIns->session_id = in_session_sessionid; + sessionIns->service_id.timeLow = in_session_serviceid_timelow; + sessionIns->service_id.timeMid = in_session_serviceid_timemid; + sessionIns->service_id.timeHiAndVersion = in_session_serviceid_timehiandver; + if (in_session_serviceid_clockseqandnode_realsize <= 8 && + in_session_serviceid_clockseqandnode_realsize > 0 && + in_session_serviceid_clockseqandnode != NULL + ) + { + for (int i = 0; i < in_session_serviceid_clockseqandnode_realsize; i++) + { + sessionIns->service_id.clockSeqAndNode[i] = + (uint8_t)(in_session_serviceid_clockseqandnode[i] & 0x000000ff); + } + } else + { + for (int i = 0; i < 8; i++) + { + sessionIns->service_id.clockSeqAndNode[i] = 0; + } + } + sessionIns->ops_cnt = in_session_opscnt; + sessionIns->head.next = (struct ListNode *) in_session_head_next; + sessionIns->head.prev = (struct ListNode *) in_session_head_prev; + // sessionIns->context = (TEEC_Context *)in_session_context; + + + TEEC_Operation operationIns; + + operationIns.started = in_operation_started; + operationIns.paramTypes = in_operation_paramtypes; + + ///////////////////////////////////////////////////////////////////////////////////////////// + ///////////////////////////////////////////////////////////////////////////////////////////// + + uint8_t *buffer1_temp = NULL; + TEEC_SharedMemory shareBuffer1; + bool sb1AllReged = false; + switch ( + TEEC_PARAM_TYPE_GET(operationIns.paramTypes, 0) + ) + { + case TEEC_VALUE_INPUT: + case TEEC_VALUE_INOUT: + { + operationIns.params[0].value.a = in_operation_param1_value_a; + operationIns.params[0].value.b = in_operation_param1_value_b; + + break; + } + + case TEEC_MEMREF_TEMP_INPUT: + case TEEC_MEMREF_TEMP_INOUT: + { + if ( + in_buffer1 != NULL && + in_buffer1_size > 0 + ) + { + uint32_t buffer1_temp_size; + buffer1_temp_size = in_buffer1_size; + buffer1_temp = (uint8_t *) malloc(buffer1_temp_size * sizeof(uint8_t)); + for (int isize = 0; isize < in_buffer1_size; isize++) + { + buffer1_temp[isize] = (uint8_t)(in_buffer1[isize] & 0x000000ff); + } + + operationIns.params[0].tmpref.buffer = (void *) buffer1_temp; + operationIns.params[0].tmpref.size = buffer1_temp_size; + } + + break; + } + + case TEEC_MEMREF_TEMP_OUTPUT: + { + if ( + in_operation_param1_tmpref_size > 0 + ) + { + buffer1_temp = (uint8_t *) malloc(in_operation_param1_tmpref_size * sizeof(uint8_t)); + operationIns.params[0].tmpref.buffer = (void *) buffer1_temp; + operationIns.params[0].tmpref.size = in_operation_param1_tmpref_size; + } + + break; + } + + + case TEEC_MEMREF_WHOLE: + { + switch (in_operation_param1_memref_parent_flag) + { + case TEEC_MEM_INPUT: + case TEEC_MEM_INOUT: + { + if ( + in_buffer1 != NULL && + in_buffer1_size > 0 + ) + { + memset(&shareBuffer1, 0, sizeof(shareBuffer1)); + shareBuffer1.size = in_buffer1_size; + shareBuffer1.flags = in_operation_param1_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer1); + if (retASM) + { + printf("Alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb1AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + memset(shareBuffer1.buffer, 0, shareBuffer1.size); + for (int isize = 0; isize < in_buffer1_size; isize++) + { + *((uint8_t * )(shareBuffer1.buffer) + isize) = + (uint8_t)(in_buffer1[isize] & 0x000000ff); + } + operationIns.params[0].memref.parent = &shareBuffer1; + // operationIns.params[0].memref.parent->flags = + // in_operation_param1_memref_parent_flag; + operationIns.params[0].memref.size = shareBuffer1.size; + } + } + + break; + } + + case TEEC_MEM_OUTPUT: + { + if ( + in_operation_param1_memref_size > 0 + ) + { + memset(&shareBuffer1, 0, sizeof(shareBuffer1)); + shareBuffer1.size = in_operation_param1_memref_size; + shareBuffer1.flags = in_operation_param1_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer1); + if (retASM) + { + printf("Alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb1AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + operationIns.params[0].memref.parent = &shareBuffer1; + operationIns.params[0].memref.size = shareBuffer1.size; + } + + } + + break; + } + + default: + break; + } + + break; + } + + + case TEEC_MEMREF_PARTIAL_INPUT: + case TEEC_MEMREF_PARTIAL_INOUT: + { + if ( + in_buffer1 != NULL && + in_buffer1_size > 0 + ) + { + memset(&shareBuffer1, 0, sizeof(shareBuffer1)); + shareBuffer1.size = in_buffer1_size; + shareBuffer1.flags = in_operation_param1_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer1); + if (retASM) + { + printf("Alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb1AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + memset(shareBuffer1.buffer, 0, shareBuffer1.size); + for (int isize = 0; isize < in_buffer1_size; isize++) + { + *((uint8_t * )(shareBuffer1.buffer) + isize) = + (uint8_t)(in_buffer1[isize] & 0x000000ff); + } + operationIns.params[0].memref.parent = &shareBuffer1; + operationIns.params[0].memref.offset = in_operation_param1_memref_offset; + operationIns.params[0].memref.size = in_operation_param1_memref_size; + } + } + + break; + } + + case TEEC_MEMREF_PARTIAL_OUTPUT: + { + if (in_operation_param1_memref_size > 0) + { + memset(&shareBuffer1, 0, sizeof(shareBuffer1)); + shareBuffer1.size = in_buffer1_size; + shareBuffer1.flags = in_operation_param1_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer1); + if (retASM) + { + printf("Alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb1AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + operationIns.params[0].memref.parent = &shareBuffer1; + operationIns.params[0].memref.offset = in_operation_param1_memref_offset; + operationIns.params[0].memref.size = in_operation_param1_memref_size; + } + + } + + break; + } + + + default: + break; + } + + ///////////////////////////////////////////////////////////////////////////////////////////// + ///////////////////////////////////////////////////////////////////////////////////////////// + + uint8_t *buffer2_temp = NULL; + TEEC_SharedMemory shareBuffer2; + bool sb2AllReged = false; + switch ( + TEEC_PARAM_TYPE_GET(operationIns.paramTypes, 1) + ) + { + case TEEC_VALUE_INPUT: + case TEEC_VALUE_INOUT: + { + operationIns.params[1].value.a = in_operation_param2_value_a; + operationIns.params[1].value.b = in_operation_param2_value_b; + + break; + } + + case TEEC_MEMREF_TEMP_INPUT: + case TEEC_MEMREF_TEMP_INOUT: + { + if ( + in_buffer2 != NULL && + in_buffer2_size > 0 + ) + { + uint32_t buffer2_temp_size; + buffer2_temp_size = in_buffer2_size; + buffer2_temp = (uint8_t *) malloc(buffer2_temp_size * sizeof(uint8_t)); + for (int isize = 0; isize < in_buffer2_size; isize++) + { + buffer2_temp[isize] = (uint8_t)(in_buffer2[isize] & 0x000000ff); + } + + operationIns.params[1].tmpref.buffer = (void *) buffer2_temp; + operationIns.params[1].tmpref.size = buffer2_temp_size; + } + + break; + } + + case TEEC_MEMREF_TEMP_OUTPUT: + { + if ( + in_operation_param2_tmpref_size > 0 + ) + { + buffer2_temp = (uint8_t *) malloc(in_operation_param2_tmpref_size * sizeof(uint8_t)); + operationIns.params[1].tmpref.buffer = (void *) buffer2_temp; + operationIns.params[1].tmpref.size = in_operation_param2_tmpref_size; + } + + break; + } + + + case TEEC_MEMREF_WHOLE: + { + switch (in_operation_param2_memref_parent_flag) + { + case TEEC_MEM_INPUT: + case TEEC_MEM_INOUT: + { + if ( + in_buffer2 != NULL && + in_buffer2_size > 0 + ) + { + memset(&shareBuffer2, 0, sizeof(shareBuffer2)); + shareBuffer2.size = in_buffer2_size; + shareBuffer2.flags = in_operation_param2_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer2); + if (retASM) + { + printf("alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb2AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + memset(shareBuffer2.buffer, 0, shareBuffer2.size); + for (int isize = 0; isize < in_buffer2_size; isize++) + { + *((uint8_t * )(shareBuffer2.buffer) + isize) = + (uint8_t)(in_buffer2[isize] & 0x000000ff); + } + operationIns.params[1].memref.parent = &shareBuffer2; + // operationIns.params[1].memref.parent->flags = + // in_operation_param2_memref_parent_flag; + operationIns.params[1].memref.size = shareBuffer2.size; + } + } + + break; + } + + case TEEC_MEM_OUTPUT: + { + if ( + in_operation_param2_memref_size > 0 + ) + { + memset(&shareBuffer2, 0, sizeof(shareBuffer2)); + shareBuffer2.size = in_operation_param2_memref_size; + shareBuffer2.flags = in_operation_param2_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer2); + if (retASM) + { + printf("alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb2AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + operationIns.params[1].memref.parent = &shareBuffer2; + // operationIns.params[1].memref.parent->flags = + // in_operation_param2_memref_parent_flag; + operationIns.params[1].memref.size = shareBuffer2.size; + } + + } + + break; + } + + default: + break; + } + + break; + } + + + case TEEC_MEMREF_PARTIAL_INPUT: + case TEEC_MEMREF_PARTIAL_INOUT: + { + if ( + in_buffer2 != NULL && + in_buffer2_size > 0 + ) + { + memset(&shareBuffer2, 0, sizeof(shareBuffer2)); + shareBuffer2.size = in_buffer2_size; + shareBuffer2.flags = in_operation_param2_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer2); + if (retASM) + { + printf("Alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb2AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + memset(shareBuffer2.buffer, 0, shareBuffer2.size); + for (int isize = 0; isize < in_buffer2_size; isize++) + { + *((uint8_t * )(shareBuffer2.buffer) + isize) = + (uint8_t)(in_buffer2[isize] & 0x000000ff); + } + operationIns.params[1].memref.parent = &shareBuffer2; + operationIns.params[1].memref.offset = in_operation_param2_memref_offset; + operationIns.params[1].memref.size = in_operation_param2_memref_size; + } + } + + break; + } + + case TEEC_MEMREF_PARTIAL_OUTPUT: + { + if (in_operation_param2_memref_size > 0) + { + memset(&shareBuffer2, 0, sizeof(shareBuffer2)); + shareBuffer2.size = in_buffer2_size; + shareBuffer2.flags = in_operation_param2_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer2); + if (retASM) + { + printf("Alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb2AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + operationIns.params[1].memref.parent = &shareBuffer2; + operationIns.params[1].memref.offset = in_operation_param2_memref_offset; + operationIns.params[1].memref.size = in_operation_param2_memref_size; + } + + } + + break; + } + + + default: + break; + } + + ///////////////////////////////////////////////////////////////////////////////////////////// + ///////////////////////////////////////////////////////////////////////////////////////////// + + uint8_t *buffer3_temp = NULL; + TEEC_SharedMemory shareBuffer3; + bool sb3AllReged = false; + switch ( + TEEC_PARAM_TYPE_GET(operationIns.paramTypes, 2) + ) + { + case TEEC_VALUE_INPUT: + case TEEC_VALUE_INOUT: + { + operationIns.params[2].value.a = in_operation_param3_value_a; + operationIns.params[2].value.b = in_operation_param3_value_b; + + break; + } + + case TEEC_MEMREF_TEMP_INPUT: + case TEEC_MEMREF_TEMP_INOUT: + { + if ( + in_buffer3 != NULL && + in_buffer3_size > 0 + ) + { + uint32_t buffer3_temp_size; + buffer3_temp_size = in_buffer3_size; + buffer3_temp = (uint8_t *) malloc(buffer3_temp_size * sizeof(uint8_t)); + for (int isize = 0; isize < in_buffer3_size; isize++) + { + buffer3_temp[isize] = (uint8_t)(in_buffer3[isize] & 0x000000ff); + } + + operationIns.params[2].tmpref.buffer = (void *) buffer3_temp; + operationIns.params[2].tmpref.size = buffer3_temp_size; + } + + break; + } + + case TEEC_MEMREF_TEMP_OUTPUT: + { + if ( + in_operation_param3_tmpref_size > 0 + ) + { + buffer3_temp = (uint8_t *) malloc(in_operation_param3_tmpref_size * sizeof(uint8_t)); + operationIns.params[2].tmpref.buffer = (void *) buffer3_temp; + operationIns.params[2].tmpref.size = in_operation_param3_tmpref_size; + } + + break; + } + + + case TEEC_MEMREF_WHOLE: + { + switch (in_operation_param3_memref_parent_flag) + { + case TEEC_MEM_INPUT: + case TEEC_MEM_INOUT: + { + if ( + in_buffer3 != NULL && + in_buffer3_size > 0 + ) + { + memset(&shareBuffer3, 0, sizeof(shareBuffer3)); + shareBuffer3.size = in_buffer3_size; + shareBuffer3.flags = in_operation_param3_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer3); + if (retASM) + { + printf("alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb3AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + memset(shareBuffer3.buffer, 0, shareBuffer3.size); + for (int isize = 0; isize < in_buffer3_size; isize++) + { + *((uint8_t * )(shareBuffer3.buffer) + isize) = + (uint8_t)(in_buffer3[isize] & 0x000000ff); + } + operationIns.params[2].memref.parent = &shareBuffer3; + // operationIns.params[2].memref.parent->flags = + // in_operation_param3_memref_parent_flag; + operationIns.params[2].memref.size = shareBuffer3.size; + } + } + + break; + } + + case TEEC_MEM_OUTPUT: + { + if ( + in_operation_param3_memref_size > 0 + ) + { + memset(&shareBuffer3, 0, sizeof(shareBuffer3)); + shareBuffer3.size = in_operation_param3_memref_size; + shareBuffer3.flags = in_operation_param3_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer3); + if (retASM) + { + printf("alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb3AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + operationIns.params[2].memref.parent = &shareBuffer3; + // operationIns.params[2].memref.parent->flags = + // in_operation_param3_memref_parent_flag; + operationIns.params[2].memref.size = shareBuffer3.size; + } + + } + + break; + } + + default: + break; + } + + break; + } + + + case TEEC_MEMREF_PARTIAL_INPUT: + case TEEC_MEMREF_PARTIAL_INOUT: + { + if ( + in_buffer3 != NULL && + in_buffer3_size > 0 + ) + { + memset(&shareBuffer3, 0, sizeof(shareBuffer3)); + shareBuffer3.size = in_buffer3_size; + shareBuffer3.flags = in_operation_param3_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer3); + if (retASM) + { + printf("Alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb3AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + memset(shareBuffer3.buffer, 0, shareBuffer3.size); + for (int isize = 0; isize < in_buffer3_size; isize++) + { + *((uint8_t * )(shareBuffer3.buffer) + isize) = + (uint8_t)(in_buffer3[isize] & 0x000000ff); + } + operationIns.params[2].memref.parent = &shareBuffer3; + operationIns.params[2].memref.offset = in_operation_param3_memref_offset; + operationIns.params[2].memref.size = in_operation_param3_memref_size; + } + } + + break; + } + + case TEEC_MEMREF_PARTIAL_OUTPUT: + { + if (in_operation_param3_memref_size > 0) + { + memset(&shareBuffer3, 0, sizeof(shareBuffer3)); + shareBuffer3.size = in_buffer3_size; + shareBuffer3.flags = in_operation_param3_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer3); + if (retASM) + { + printf("Alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb3AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + operationIns.params[2].memref.parent = &shareBuffer3; + operationIns.params[2].memref.offset = in_operation_param3_memref_offset; + operationIns.params[2].memref.size = in_operation_param3_memref_size; + } + + } + + break; + } + + + default: + break; + } + + ///////////////////////////////////////////////////////////////////////////////////////////// + ///////////////////////////////////////////////////////////////////////////////////////////// + + uint8_t *buffer4_temp = NULL; + TEEC_SharedMemory shareBuffer4; + bool sb4AllReged = false; + switch ( + TEEC_PARAM_TYPE_GET(operationIns.paramTypes, 3) + ) + { + case TEEC_VALUE_INPUT: + case TEEC_VALUE_INOUT: + { + operationIns.params[3].value.a = in_operation_param4_value_a; + operationIns.params[3].value.b = in_operation_param4_value_b; + + break; + } + + case TEEC_MEMREF_TEMP_INPUT: + case TEEC_MEMREF_TEMP_INOUT: + { + if ( + in_buffer4 != NULL && + in_buffer4_size > 0 + ) + { + uint32_t buffer4_temp_size; + buffer4_temp_size = in_buffer4_size; + buffer4_temp = (uint8_t *) malloc(buffer4_temp_size * sizeof(uint8_t)); + for (int isize = 0; isize < in_buffer4_size; isize++) + { + buffer4_temp[isize] = (uint8_t)(in_buffer4[isize] & 0x000000ff); + } + + operationIns.params[3].tmpref.buffer = (void *) buffer4_temp; + operationIns.params[3].tmpref.size = buffer4_temp_size; + } + + break; + } + + case TEEC_MEMREF_TEMP_OUTPUT: + { + if ( + in_operation_param4_tmpref_size > 0 + ) + { + buffer4_temp = (uint8_t *) malloc(in_operation_param4_tmpref_size * sizeof(uint8_t)); + operationIns.params[3].tmpref.buffer = (void *) buffer4_temp; + operationIns.params[3].tmpref.size = in_operation_param4_tmpref_size; + } + + break; + } + + + case TEEC_MEMREF_WHOLE: + { + switch (in_operation_param4_memref_parent_flag) + { + case TEEC_MEM_INPUT: + case TEEC_MEM_INOUT: + { + if ( + in_buffer4 != NULL && + in_buffer4_size > 0 + ) + { + memset(&shareBuffer4, 0, sizeof(shareBuffer4)); + shareBuffer4.size = in_buffer4_size; + shareBuffer4.flags = in_operation_param4_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer4); + if (retASM) + { + printf("alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb4AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + memset(shareBuffer4.buffer, 0, shareBuffer4.size); + for (int isize = 0; isize < in_buffer4_size; isize++) + { + *((uint8_t * )(shareBuffer4.buffer) + isize) = + (uint8_t)(in_buffer4[isize] & 0x000000ff); + } + operationIns.params[3].memref.parent = &shareBuffer4; + // operationIns.params[3].memref.parent->flags = + // in_operation_param4_memref_parent_flag; + operationIns.params[3].memref.size = shareBuffer4.size; + } + } + + break; + } + + case TEEC_MEM_OUTPUT: + { + if ( + in_operation_param4_memref_size > 0 + ) + { + memset(&shareBuffer4, 0, sizeof(shareBuffer4)); + shareBuffer4.size = in_operation_param4_memref_size; + shareBuffer4.flags = in_operation_param4_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer4); + if (retASM) + { + printf("alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb4AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + operationIns.params[3].memref.parent = &shareBuffer4; + // operationIns.params[3].memref.parent->flags = + // in_operation_param4_memref_parent_flag; + operationIns.params[3].memref.size = shareBuffer4.size; + } + + } + + break; + } + + default: + break; + } + + break; + } + + + case TEEC_MEMREF_PARTIAL_INPUT: + case TEEC_MEMREF_PARTIAL_INOUT: + { + if ( + in_buffer4 != NULL && + in_buffer4_size > 0 + ) + { + memset(&shareBuffer4, 0, sizeof(shareBuffer4)); + shareBuffer4.size = in_buffer4_size; + shareBuffer4.flags = in_operation_param4_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer4); + if (retASM) + { + printf("Alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb4AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + memset(shareBuffer4.buffer, 0, shareBuffer4.size); + for (int isize = 0; isize < in_buffer4_size; isize++) + { + *((uint8_t * )(shareBuffer4.buffer) + isize) = + (uint8_t)(in_buffer4[isize] & 0x000000ff); + } + operationIns.params[3].memref.parent = &shareBuffer4; + operationIns.params[3].memref.offset = in_operation_param4_memref_offset; + operationIns.params[3].memref.size = in_operation_param4_memref_size; + } + } + + break; + } + + case TEEC_MEMREF_PARTIAL_OUTPUT: + { + if (in_operation_param4_memref_size > 0) + { + memset(&shareBuffer4, 0, sizeof(shareBuffer4)); + shareBuffer4.size = in_buffer4_size; + shareBuffer4.flags = in_operation_param4_memref_parent_flag; + TEEC_Result retASM = 0; + retASM = TEEC_AllocateSharedMemory(contextIns, &shareBuffer4); + if (retASM) + { + printf("Alloc share memory failed, ret=0x%x.\n", retASM); + teecresult = retASM; + } else + { + sb4AllReged = true; + printf("TEEC_AllocateSharedMemory succecced. \n"); + operationIns.params[3].memref.parent = &shareBuffer4; + operationIns.params[3].memref.offset = in_operation_param4_memref_offset; + operationIns.params[3].memref.size = in_operation_param4_memref_size; + } + + } + + break; + } + + + default: + break; + } + + ///////////////////////////////////////////////////////////////////////////////////////////// + ///////////////////////////////////////////////////////////////////////////////////////////// + + if (teecresult != TEEC_SUCCESS) + { + sessionid = 0; + serviceid_timelow = 0; + serviceid_timemid = 0; + serviceid_timehiandver = 0; + serviceid_clockseqandnode_realsize = 0; + serviceid_clockseqandnode = NULL; + serviceid_clockseqandnode_outsize = 0; + opscnt = 0; + head_next = 0; + head_prev = 0; + context = 0; + + started = 0; + paramtypes = 0; + + operation_param1_tmpref_buffer = 0; + operation_param1_tmpref_size = 0; + operation_param1_memref_parent = 0; + operation_param1_memref_parent_flag = 0; + operation_param1_memref_size = 0; + operation_param1_memref_offset = 0; + operation_param1_value_a = 0; + operation_param1_value_b = 0; + operation_param1_ionref_ionsharefd = 0; + operation_param1_ionref_ionsize = 0; + + operation_param2_tmpref_buffer = 0; + operation_param2_tmpref_size = 0; + operation_param2_memref_parent = 0; + operation_param2_memref_parent_flag = 0; + operation_param2_memref_size = 0; + operation_param2_memref_offset = 0; + operation_param2_value_a = 0; + operation_param2_value_b = 0; + operation_param2_ionref_ionsharefd = 0; + operation_param2_ionref_ionsize = 0; + + operation_param3_tmpref_buffer = 0; + operation_param3_tmpref_size = 0; + operation_param3_memref_parent = 0; + operation_param3_memref_parent_flag = 0; + operation_param3_memref_size = 0; + operation_param3_memref_offset = 0; + operation_param3_value_a = 0; + operation_param3_value_b = 0; + operation_param3_ionref_ionsharefd = 0; + operation_param3_ionref_ionsize = 0; + + operation_param4_tmpref_buffer = 0; + operation_param4_tmpref_size = 0; + operation_param4_memref_parent = 0; + operation_param4_memref_parent_flag = 0; + operation_param4_memref_size = 0; + operation_param4_memref_offset = 0; + operation_param4_value_a = 0; + operation_param4_value_b = 0; + operation_param4_ionref_ionsharefd = 0; + operation_param4_ionref_ionsize = 0; + + operation_session = 0; + operation_cancelflag = 0; + + returnorigin = 0xff; + + buffer1_realsize = 0; + buffer1 = NULL; + buffer1_outsize = 0; + buffer2_realsize = 0; + buffer2 = NULL; + buffer2_outsize = 0; + buffer3_realsize = 0; + buffer3 = NULL; + buffer3_outsize = 0; + buffer4_realsize = 0; + buffer4 = NULL; + buffer4_outsize = 0; + } else + { //start of the input parameter operation success +#if 0 + operationIns.params[0].ionref.ion_share_fd = in_operation_param1_ionref_ionsharefd; + operationIns.params[0].ionref.ion_size = in_operation_param1_ionref_ionsize; + + operationIns.params[1].ionref.ion_share_fd = in_operation_param2_ionref_ionsharefd; + operationIns.params[1].ionref.ion_size = in_operation_param2_ionref_ionsize; + + operationIns.params[2].ionref.ion_share_fd = in_operation_param3_ionref_ionsharefd; + operationIns.params[2].ionref.ion_size = in_operation_param3_ionref_ionsize; + + operationIns.params[3].ionref.ion_share_fd = in_operation_param4_ionref_ionsharefd; + operationIns.params[3].ionref.ion_size = in_operation_param4_ionref_ionsize; +#endif + + operationIns.session = sessionIns; + operationIns.cancel_flag = in_operation_cancelflag; + + uint32_t origin; + origin = in_returnorigin; + + TEEC_Result result; + + struct timeval start, end; + gettimeofday(&start, NULL); + result = + TEEC_InvokeCommand( + sessionIns, + in_commandid, + &operationIns, + &origin + ); + gettimeofday(&end, NULL); + uint32_t cost = 0; + cost += (1000000 * end.tv_sec + end.tv_usec) - (1000000 * start.tv_sec + start.tv_usec); + + if (result != TEEC_SUCCESS) + { + printf("Teec InvokeCommand Failed. \n"); + printf(" teecresult = 0x %8.8x.\n", result); + + teecresult = result; + + sessionid = 0; + serviceid_timelow = 0; + serviceid_timemid = 0; + serviceid_timehiandver = 0; + serviceid_clockseqandnode_realsize = 0; + serviceid_clockseqandnode = NULL; + serviceid_clockseqandnode_outsize = 0; + opscnt = 0; + head_next = 0; + head_prev = 0; + context = 0; + + started = 0; + paramtypes = 0; + + operation_param1_tmpref_buffer = 0; + operation_param1_tmpref_size = 0; + operation_param1_memref_parent = 0; + operation_param1_memref_parent_flag = 0; + operation_param1_memref_size = 0; + operation_param1_memref_offset = 0; + operation_param1_value_a = 0; + operation_param1_value_b = 0; + operation_param1_ionref_ionsharefd = 0; + operation_param1_ionref_ionsize = 0; + + operation_param2_tmpref_buffer = 0; + operation_param2_tmpref_size = 0; + operation_param2_memref_parent = 0; + operation_param2_memref_parent_flag = 0; + operation_param2_memref_size = 0; + operation_param2_memref_offset = 0; + operation_param2_value_a = 0; + operation_param2_value_b = 0; + operation_param2_ionref_ionsharefd = 0; + operation_param2_ionref_ionsize = 0; + + operation_param3_tmpref_buffer = 0; + operation_param3_tmpref_size = 0; + operation_param3_memref_parent = 0; + operation_param3_memref_parent_flag = 0; + operation_param3_memref_size = 0; + operation_param3_memref_offset = 0; + operation_param3_value_a = 0; + operation_param3_value_b = 0; + operation_param3_ionref_ionsharefd = 0; + operation_param3_ionref_ionsize = 0; + + operation_param4_tmpref_buffer = 0; + operation_param4_tmpref_size = 0; + operation_param4_memref_parent = 0; + operation_param4_memref_parent_flag = 0; + operation_param4_memref_size = 0; + operation_param4_memref_offset = 0; + operation_param4_value_a = 0; + operation_param4_value_b = 0; + operation_param4_ionref_ionsharefd = 0; + operation_param4_ionref_ionsize = 0; + + operation_session = 0; + operation_cancelflag = 0; + + returnorigin = 0xff; + + buffer1_realsize = 0; + buffer1 = NULL; + buffer1_outsize = 0; + buffer2_realsize = 0; + buffer2 = NULL; + buffer2_outsize = 0; + buffer3_realsize = 0; + buffer3 = NULL; + buffer3_outsize = 0; + buffer4_realsize = 0; + buffer4 = NULL; + buffer4_outsize = 0; + } else + { // start of the invoke command success + printf("Teec InvokeCommand Succed, cost time: %ld us \n", cost); + + teecresult = result; + + sessionid = sessionIns->session_id; + serviceid_timelow = sessionIns->service_id.timeLow; + serviceid_timemid = sessionIns->service_id.timeMid; + serviceid_timehiandver = sessionIns->service_id.timeHiAndVersion; + if (sessionIns->service_id.clockSeqAndNode != NULL) + { + serviceid_clockseqandnode_realsize = 8; + serviceid_clockseqandnode = + (dbus_uint32_t *) malloc( + serviceid_clockseqandnode_realsize * sizeof(dbus_uint32_t) + ); + for (int iind = 0; iind < 8; iind++) + { + uint8_t u8Temp; + u8Temp = sessionIns->service_id.clockSeqAndNode[iind]; + serviceid_clockseqandnode[iind] = (dbus_uint32_t) u8Temp; + } + serviceid_clockseqandnode_outsize = 8; + } else + { + serviceid_clockseqandnode_realsize = 0; + serviceid_clockseqandnode = NULL; + serviceid_clockseqandnode_outsize = 0; + } + opscnt = sessionIns->ops_cnt; + head_next = (dbus_uint64_t) sessionIns->head.next; + head_prev = (dbus_uint64_t) sessionIns->head.prev; + context = (dbus_uint64_t) sessionIns->context; + + started = operationIns.started; + paramtypes = operationIns.paramTypes; + + ////////////////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////////////////// + + switch ( + TEEC_PARAM_TYPE_GET(operationIns.paramTypes, 0) + ) + { + case TEEC_VALUE_INOUT: + case TEEC_VALUE_OUTPUT: + { + operation_param1_value_a = operationIns.params[0].value.a; + operation_param1_value_b = operationIns.params[0].value.b; + + buffer1_realsize = 0; + buffer1 = NULL; + buffer1_outsize = 0; + + break; + } + + case TEEC_MEMREF_TEMP_INOUT: + case TEEC_MEMREF_TEMP_OUTPUT: + { + if (operationIns.params[0].tmpref.buffer != NULL && + operationIns.params[0].tmpref.size > 0 + ) + { + buffer1_realsize = operationIns.params[0].tmpref.size; + buffer1 = + (dbus_uint32_t *) malloc( + buffer1_realsize * sizeof(dbus_uint32_t) + ); + for (int iind = 0; iind < buffer1_realsize; iind++) + { + uint8_t u8Temp; + u8Temp = (uint8_t) * ((uint8_t * )(operationIns.params[0].tmpref.buffer) + iind); + buffer1[iind] = (dbus_uint32_t) u8Temp; + } + buffer1_outsize = buffer1_realsize; + } else + { + buffer1_realsize = 0; + buffer1 = NULL; + buffer1_outsize = 0; + } + + operation_param1_tmpref_buffer = (dbus_uint64_t) operationIns.params[0].tmpref.buffer; + operation_param1_tmpref_size = operationIns.params[0].tmpref.size; + + break; + } + + + case TEEC_MEMREF_WHOLE: + { + switch (operationIns.params[0].memref.parent->flags) + { + case TEEC_MEM_OUTPUT: + case TEEC_MEM_INOUT: + { + + if (operationIns.params[0].memref.parent->buffer != NULL && + operationIns.params[0].memref.parent->size > 0 + ) + { + buffer1_realsize = operationIns.params[0].memref.parent->size; + buffer1 = + (dbus_uint32_t *) malloc( + buffer1_realsize * sizeof(dbus_uint32_t) + ); + for (int iind = 0; iind < buffer1_realsize; iind++) + { + uint8_t u8Temp; + u8Temp = (uint8_t) * ((uint8_t * ) + (operationIns.params[0].memref.parent->buffer) + iind); + buffer1[iind] = (dbus_uint32_t) u8Temp; + } + buffer1_outsize = buffer1_realsize; + } else + { + buffer1_realsize = 0; + buffer1 = NULL; + buffer1_outsize = 0; + } + + operation_param1_memref_parent = + (dbus_uint64_t) operationIns.params[0].memref.parent->buffer; + operation_param1_memref_parent_flag = + (dbus_uint32_t) operationIns.params[0].memref.parent->flags; + operation_param1_memref_size = + operationIns.params[0].memref.parent->size; + + break; + } + + default: + break; + } + + break; + } + + + case TEEC_MEMREF_PARTIAL_OUTPUT: + case TEEC_MEMREF_PARTIAL_INOUT: + { + if (operationIns.params[0].memref.parent->buffer != NULL && + operationIns.params[0].memref.parent->size > 0 + ) + { + buffer1_realsize = operationIns.params[0].memref.parent->size; + buffer1 = + (dbus_uint32_t *) malloc(buffer1_realsize * sizeof(dbus_uint32_t)); + for (int iind = 0; iind < buffer1_realsize; iind++) + { + uint8_t u8Temp; + u8Temp = (uint8_t) * ((uint8_t * ) + (operationIns.params[0].memref.parent->buffer) + iind); + buffer1[iind] = (dbus_uint32_t) u8Temp; + } + buffer1_outsize = buffer1_realsize; + } else + { + buffer1_realsize = 0; + buffer1 = NULL; + buffer1_outsize = 0; + } + + operation_param1_memref_parent = + (dbus_uint64_t) operationIns.params[0].memref.parent->buffer; + operation_param1_memref_parent_flag = + (dbus_uint32_t) operationIns.params[0].memref.parent->flags; + operation_param1_memref_offset = operationIns.params[0].memref.offset; + operation_param1_memref_size = + operationIns.params[0].memref.size; + + break; + } + + + default: + { + buffer1_realsize = 0; + buffer1 = NULL; + buffer1_outsize = 0; + } + } + + operation_param1_ionref_ionsharefd = operationIns.params[0].ionref.ion_share_fd; + operation_param1_ionref_ionsize = operationIns.params[0].ionref.ion_size; + + ////////////////////////////////////////////////////////////////////////////////// + + switch ( + TEEC_PARAM_TYPE_GET(operationIns.paramTypes, 1) + ) + { + case TEEC_VALUE_INOUT: + case TEEC_VALUE_OUTPUT: + { + operation_param2_value_a = operationIns.params[1].value.a; + operation_param2_value_b = operationIns.params[1].value.b; + + buffer2_realsize = 0; + buffer2 = NULL; + buffer2_outsize = 0; + + break; + } + + case TEEC_MEMREF_TEMP_INOUT: + case TEEC_MEMREF_TEMP_OUTPUT: + { + if (operationIns.params[1].tmpref.buffer != NULL && + operationIns.params[1].tmpref.size > 0 + ) + { + buffer2_realsize = operationIns.params[1].tmpref.size; + buffer2 = + (dbus_uint32_t *) malloc( + buffer2_realsize * sizeof(dbus_uint32_t) + ); + for (int iind = 0; iind < buffer2_realsize; iind++) + { + uint8_t u8Temp; + u8Temp = (uint8_t) * ((uint8_t * )(operationIns.params[1].tmpref.buffer) + iind); + buffer2[iind] = (dbus_uint32_t) u8Temp; + } + buffer2_outsize = buffer2_realsize; + } else + { + buffer2_realsize = 0; + buffer2 = NULL; + buffer2_outsize = 0; + } + + operation_param2_tmpref_buffer = (dbus_uint64_t) operationIns.params[1].tmpref.buffer; + operation_param2_tmpref_size = operationIns.params[1].tmpref.size; + + break; + } + + + case TEEC_MEMREF_WHOLE: + { + switch (operationIns.params[1].memref.parent->flags) + { + case TEEC_MEM_OUTPUT: + case TEEC_MEM_INOUT: + { + + if (operationIns.params[1].memref.parent->buffer != NULL && + operationIns.params[1].memref.parent->size > 0 + ) + { + buffer2_realsize = operationIns.params[1].memref.parent->size; + buffer2 = + (dbus_uint32_t *) malloc( + buffer2_realsize * sizeof(dbus_uint32_t) + ); + for (int iind = 0; iind < buffer2_realsize; iind++) + { + uint8_t u8Temp; + u8Temp = (uint8_t) * ((uint8_t * ) + (operationIns.params[1].memref.parent->buffer) + iind); + buffer2[iind] = (dbus_uint32_t) u8Temp; + } + buffer2_outsize = buffer2_realsize; + } else + { + buffer2_realsize = 0; + buffer2 = NULL; + buffer2_outsize = 0; + } + + operation_param2_memref_parent = + (dbus_uint64_t) operationIns.params[1].memref.parent->buffer; + operation_param2_memref_parent_flag = + (dbus_uint32_t) operationIns.params[1].memref.parent->flags; + operation_param2_memref_size = + operationIns.params[1].memref.parent->size; + + break; + } + + default: + break; + } + + break; + } + + + case TEEC_MEMREF_PARTIAL_OUTPUT: + case TEEC_MEMREF_PARTIAL_INOUT: + { + if (operationIns.params[1].memref.parent->buffer != NULL && + operationIns.params[1].memref.parent->size > 0 + ) + { + buffer2_realsize = operationIns.params[1].memref.parent->size; + buffer2 = + (dbus_uint32_t *) malloc(buffer2_realsize * sizeof(dbus_uint32_t)); + for (int iind = 0; iind < buffer2_realsize; iind++) + { + uint8_t u8Temp; + u8Temp = (uint8_t) * ((uint8_t * ) + (operationIns.params[1].memref.parent->buffer) + iind); + buffer2[iind] = (dbus_uint32_t) u8Temp; + } + buffer2_outsize = buffer2_realsize; + } else + { + buffer2_realsize = 0; + buffer2 = NULL; + buffer2_outsize = 0; + } + + operation_param2_memref_parent = + (dbus_uint64_t) operationIns.params[1].memref.parent->buffer; + operation_param2_memref_parent_flag = + (dbus_uint32_t) operationIns.params[1].memref.parent->flags; + operation_param2_memref_offset = operationIns.params[1].memref.offset; + operation_param2_memref_size = + operationIns.params[1].memref.size; + + break; + } + + + default: + { + buffer2_realsize = 0; + buffer2 = NULL; + buffer2_outsize = 0; + } + } + + operation_param2_ionref_ionsharefd = operationIns.params[1].ionref.ion_share_fd; + operation_param2_ionref_ionsize = operationIns.params[1].ionref.ion_size; + + ////////////////////////////////////////////////////////////////////////////////// + + switch ( + TEEC_PARAM_TYPE_GET(operationIns.paramTypes, 2) + ) + { + case TEEC_VALUE_INOUT: + case TEEC_VALUE_OUTPUT: + { + operation_param3_value_a = operationIns.params[2].value.a; + operation_param3_value_b = operationIns.params[2].value.b; + + buffer3_realsize = 0; + buffer3 = NULL; + buffer3_outsize = 0; + + break; + } + + case TEEC_MEMREF_TEMP_INOUT: + case TEEC_MEMREF_TEMP_OUTPUT: + { + if (operationIns.params[2].tmpref.buffer != NULL && + operationIns.params[2].tmpref.size > 0 + ) + { + buffer3_realsize = operationIns.params[2].tmpref.size; + buffer3 = + (dbus_uint32_t *) malloc( + buffer3_realsize * sizeof(dbus_uint32_t) + ); + for (int iind = 0; iind < buffer3_realsize; iind++) + { + uint8_t u8Temp; + u8Temp = (uint8_t) * ((uint8_t * )(operationIns.params[2].tmpref.buffer) + iind); + buffer3[iind] = (dbus_uint32_t) u8Temp; + } + buffer3_outsize = buffer3_realsize; + } else + { + buffer3_realsize = 0; + buffer3 = NULL; + buffer3_outsize = 0; + } + + operation_param3_tmpref_buffer = (dbus_uint64_t) operationIns.params[2].tmpref.buffer; + operation_param3_tmpref_size = operationIns.params[2].tmpref.size; + + break; + } + + + case TEEC_MEMREF_WHOLE: + { + switch (operationIns.params[2].memref.parent->flags) + { + case TEEC_MEM_OUTPUT: + case TEEC_MEM_INOUT: + { + + if (operationIns.params[2].memref.parent->buffer != NULL && + operationIns.params[2].memref.parent->size > 0 + ) + { + buffer3_realsize = operationIns.params[2].memref.parent->size; + buffer3 = + (dbus_uint32_t *) malloc( + buffer3_realsize * sizeof(dbus_uint32_t) + ); + for (int iind = 0; iind < buffer3_realsize; iind++) + { + uint8_t u8Temp; + u8Temp = (uint8_t) * ((uint8_t * ) + (operationIns.params[2].memref.parent->buffer) + iind); + buffer3[iind] = (dbus_uint32_t) u8Temp; + } + buffer3_outsize = buffer3_realsize; + } else + { + buffer3_realsize = 0; + buffer3 = NULL; + buffer3_outsize = 0; + } + + operation_param3_memref_parent = + (dbus_uint64_t) operationIns.params[2].memref.parent->buffer; + operation_param3_memref_parent_flag = + (dbus_uint32_t) operationIns.params[2].memref.parent->flags; + operation_param3_memref_size = + operationIns.params[2].memref.parent->size; + + break; + } + + default: + break; + } + + break; + } + + + case TEEC_MEMREF_PARTIAL_OUTPUT: + case TEEC_MEMREF_PARTIAL_INOUT: + { + if (operationIns.params[2].memref.parent->buffer != NULL && + operationIns.params[2].memref.parent->size > 0 + ) + { + buffer3_realsize = operationIns.params[2].memref.parent->size; + buffer3 = + (dbus_uint32_t *) malloc(buffer3_realsize * sizeof(dbus_uint32_t)); + for (int iind = 0; iind < buffer3_realsize; iind++) + { + uint8_t u8Temp; + u8Temp = (uint8_t) * ((uint8_t * ) + (operationIns.params[2].memref.parent->buffer) + iind); + buffer3[iind] = (dbus_uint32_t) u8Temp; + } + buffer3_outsize = buffer3_realsize; + } else + { + buffer3_realsize = 0; + buffer3 = NULL; + buffer3_outsize = 0; + } + + operation_param3_memref_parent = + (dbus_uint64_t) operationIns.params[2].memref.parent->buffer; + operation_param3_memref_parent_flag = + (dbus_uint32_t) operationIns.params[2].memref.parent->flags; + operation_param3_memref_offset = operationIns.params[2].memref.offset; + operation_param3_memref_size = + operationIns.params[2].memref.size; + + break; + } + + + default: + { + buffer3_realsize = 0; + buffer3 = NULL; + buffer3_outsize = 0; + } + } + + operation_param3_ionref_ionsharefd = operationIns.params[2].ionref.ion_share_fd; + operation_param3_ionref_ionsize = operationIns.params[2].ionref.ion_size; + + ////////////////////////////////////////////////////////////////////////////////// + + switch ( + TEEC_PARAM_TYPE_GET(operationIns.paramTypes, 3) + ) + { + case TEEC_VALUE_INOUT: + case TEEC_VALUE_OUTPUT: + { + operation_param4_value_a = operationIns.params[3].value.a; + operation_param4_value_b = operationIns.params[3].value.b; + + buffer4_realsize = 0; + buffer4 = NULL; + buffer4_outsize = 0; + + break; + } + + case TEEC_MEMREF_TEMP_INOUT: + case TEEC_MEMREF_TEMP_OUTPUT: + { + if (operationIns.params[3].tmpref.buffer != NULL && + operationIns.params[3].tmpref.size > 0 + ) + { + buffer4_realsize = operationIns.params[3].tmpref.size; + buffer4 = + (dbus_uint32_t *) malloc( + buffer4_realsize * sizeof(dbus_uint32_t) + ); + for (int iind = 0; iind < buffer4_realsize; iind++) + { + uint8_t u8Temp; + u8Temp = (uint8_t) * ((uint8_t * )(operationIns.params[3].tmpref.buffer) + iind); + buffer4[iind] = (dbus_uint32_t) u8Temp; + } + buffer4_outsize = buffer4_realsize; + } else + { + buffer4_realsize = 0; + buffer4 = NULL; + buffer4_outsize = 0; + } + + operation_param4_tmpref_buffer = (dbus_uint64_t) operationIns.params[3].tmpref.buffer; + operation_param4_tmpref_size = operationIns.params[3].tmpref.size; + + break; + } + + + case TEEC_MEMREF_WHOLE: + { + switch (operationIns.params[3].memref.parent->flags) + { + case TEEC_MEM_OUTPUT: + case TEEC_MEM_INOUT: + { + + if (operationIns.params[3].memref.parent->buffer != NULL && + operationIns.params[3].memref.parent->size > 0 + ) + { + buffer4_realsize = operationIns.params[3].memref.parent->size; + buffer4 = + (dbus_uint32_t *) malloc( + buffer4_realsize * sizeof(dbus_uint32_t) + ); + for (int iind = 0; iind < buffer4_realsize; iind++) + { + uint8_t u8Temp; + u8Temp = (uint8_t) * ((uint8_t * ) + (operationIns.params[3].memref.parent->buffer) + iind); + buffer4[iind] = (dbus_uint32_t) u8Temp; + } + buffer4_outsize = buffer4_realsize; + } else + { + buffer4_realsize = 0; + buffer4 = NULL; + buffer4_outsize = 0; + } + + operation_param4_memref_parent = + (dbus_uint64_t) operationIns.params[3].memref.parent->buffer; + operation_param4_memref_parent_flag = + (dbus_uint32_t) operationIns.params[3].memref.parent->flags; + operation_param4_memref_size = + operationIns.params[3].memref.parent->size; + + break; + } + + default: + break; + } + + break; + } + + + case TEEC_MEMREF_PARTIAL_OUTPUT: + case TEEC_MEMREF_PARTIAL_INOUT: + { + if (operationIns.params[3].memref.parent->buffer != NULL && + operationIns.params[3].memref.parent->size > 0 + ) + { + buffer4_realsize = operationIns.params[3].memref.parent->size; + buffer4 = + (dbus_uint32_t *) malloc(buffer4_realsize * sizeof(dbus_uint32_t)); + for (int iind = 0; iind < buffer4_realsize; iind++) + { + uint8_t u8Temp; + u8Temp = (uint8_t) * ((uint8_t * ) + (operationIns.params[3].memref.parent->buffer) + iind); + buffer4[iind] = (dbus_uint32_t) u8Temp; + } + buffer4_outsize = buffer4_realsize; + } else + { + buffer4_realsize = 0; + buffer4 = NULL; + buffer4_outsize = 0; + } + + operation_param4_memref_parent = + (dbus_uint64_t) operationIns.params[3].memref.parent->buffer; + operation_param4_memref_parent_flag = + (dbus_uint32_t) operationIns.params[3].memref.parent->flags; + operation_param4_memref_offset = operationIns.params[3].memref.offset; + operation_param4_memref_size = + operationIns.params[3].memref.size; + + break; + } + + + default: + { + buffer4_realsize = 0; + buffer4 = NULL; + buffer4_outsize = 0; + } + } + + operation_param4_ionref_ionsharefd = operationIns.params[3].ionref.ion_share_fd; + operation_param4_ionref_ionsize = operationIns.params[3].ionref.ion_size; + + ////////////////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////////////////// + + operation_session = (dbus_uint64_t) operationIns.session; + operation_cancelflag = operationIns.cancel_flag; + + returnorigin = origin; + } + + if (buffer1_temp != NULL) + { + free(buffer1_temp); + } + if (buffer2_temp != NULL) + { + free(buffer2_temp); + } + if (buffer3_temp != NULL) + { + free(buffer3_temp); + } + if (buffer4_temp != NULL) + { + free(buffer4_temp); + } + + if (sb1AllReged == true) + { + TEEC_ReleaseSharedMemory(&shareBuffer1); + printf("TEEC_ReleaseSharedMemory. \n"); + } + + if (sb2AllReged == true) + { + TEEC_ReleaseSharedMemory(&shareBuffer2); + printf("TEEC_ReleaseSharedMemory. \n"); + } + + if (sb3AllReged == true) + { + TEEC_ReleaseSharedMemory(&shareBuffer3); + printf("TEEC_ReleaseSharedMemory. \n"); + } + + if (sb4AllReged == true) + { + TEEC_ReleaseSharedMemory(&shareBuffer4); + printf("TEEC_ReleaseSharedMemory. \n"); + } + + } // end of the invoke command success + + } // end of the input parameter operation success + + if(lt_flag == 0){ + struct timeval ltstart, ltend; + gettimeofday(<start, NULL); + int result; + pthread_mutex_lock(mutex_tsl); + printf(" store_tsl %d sessionid = 0x %8.8x \n",__LINE__,in_session_sessionid); + result = store_tsl(tsl,tsnIns); + if(result != 0){ + printf("session %d store_tsl error\n",in_session_sessionid); + } + pthread_mutex_unlock(mutex_tsl); + printf("gpworker %d tsl clean\n",__LINE__); + + pthread_mutex_lock(mutex_tcl); + printf(" store_tcl %d sessionid = 0x %8.8x \n",__LINE__,in_session_sessionid); + result = store_context(tcl,contextIns,tcnIns,in_session_sessionid,tsl); + if(result != 0){ + printf("session %d store_tcl error\n",in_session_sessionid); + } + + pthread_mutex_unlock(mutex_tcl); + printf("gpworker %d tcl clean\n",__LINE__); + gettimeofday(<end, NULL); + int zi64Time = (ltend.tv_sec - ltstart.tv_sec) * 1000000 + + (ltend.tv_usec - ltstart.tv_usec); + printf("gpworker baocun xxxxxx used time: %ld us. \n", zi64Time); + } + + ////////////////////////////////////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////////////////////////////////////// +#else + if (in_buffer1_size > 0) { + } + else + { + in_buffer1_realsize = 0; + } + if (in_buffer2_size > 0) { + } + else + { + in_buffer2_realsize = 0; + } + if (in_buffer3_size > 0) { + } + else + { + in_buffer3_realsize = 0; + } + if (in_buffer4_size > 0) { + } + else + { + in_buffer4_realsize = 0; + } + + serviceid_clockseqandnode_realsize = 8; + serviceid_clockseqandnode = + (dbus_uint32_t *)malloc( + serviceid_clockseqandnode_realsize * sizeof(dbus_uint32_t) + ); + uint32_t serviceid_clockseqandnode_outsize_temp; + uint32_t returnorigin_temp; + + uint32_t * buffer1_temp = NULL; + uint32_t buffer1_size = 4096; + uint32_t buffer1_outsize_temp; + buffer1_temp = + (uint32_t *)malloc( buffer1_size * sizeof(uint32_t) ); + + uint32_t buffer2_size = 4096; + uint32_t * buffer2_temp = NULL; + uint32_t buffer2_outsize_temp; + buffer2_temp = + (uint32_t *)malloc( buffer2_size * sizeof(uint32_t) ); + + uint32_t buffer3_size = 4096; + uint32_t * buffer3_temp = NULL; + uint32_t buffer3_outsize_temp; + buffer3_temp = + (uint32_t *)malloc( buffer3_size * sizeof(uint32_t) ); + + uint32_t buffer4_size = 4096; + uint32_t * buffer4_temp = NULL; + uint32_t buffer4_outsize_temp; + buffer4_temp = + (uint32_t *)malloc( buffer4_size * sizeof(uint32_t) ); + + char workername[1024]; + memset((char *)workername, 0, 1024); + int ifound = 0; + int iworker; + sin_t * sinIns; + + pthread_mutex_lock(mutex_workerrec); + for (iworker = 0; iworker < MAX_NUM_WORKER; iworker++) + { + if (workerrec[iworker].context_addr == in_session_context) + { + sinIns = NULL; + if (workerrec[iworker].first != NULL) + { + sinIns = workerrec[iworker].first; + do + { + if (sinIns->session_id == in_session_sessionid) + { + sprintf(workername, "%s%d", "gpworker", iworker); + ifound = 1; + break; + } + sinIns = sinIns->next; + }while (sinIns != NULL); + + if ( ifound == 1 ) + { + break; + } + } + } + } + pthread_mutex_unlock(mutex_workerrec); + + if (ifound == 0) + { + printf("Can't find the worker for the session and the context. \n"); + + teecresult = 0xAAAA0017; + + sessionid = 0x0; + serviceid_timelow = 0x0; + serviceid_timemid = 0x0; + serviceid_timehiandver = 0x0; + opscnt = 0x0; + head_next = 0x0; + head_prev = 0x0; + context = 0x0; + started = 0x0; + paramtypes = 0x0; + + serviceid_clockseqandnode_realsize = 8; + serviceid_clockseqandnode = + (dbus_uint32_t *)malloc( + serviceid_clockseqandnode_realsize * sizeof(dbus_uint32_t) + ); + for (int i = 0; i < serviceid_clockseqandnode_realsize ; i++) { + serviceid_clockseqandnode[i] = 0x0; + } + serviceid_clockseqandnode_outsize = 8; + + operation_param1_tmpref_buffer = 0x0; + operation_param1_tmpref_size = 0x0; + operation_param1_memref_parent = 0x0; + operation_param1_memref_size = 0x0; + operation_param1_memref_offset = 0x0; + operation_param1_value_a = 0x0; + operation_param1_value_b = 0x0; + operation_param1_ionref_ionsharefd = 0x0; + operation_param1_ionref_ionsize = 0x0; + + operation_param2_tmpref_buffer = 0x0; + operation_param2_tmpref_size = 0x0; + operation_param2_memref_parent = 0x0; + operation_param2_memref_size = 0x0; + operation_param2_memref_offset = 0x0; + operation_param2_value_a = 0x0; + operation_param2_value_b = 0x0; + operation_param2_ionref_ionsharefd = 0x0; + operation_param2_ionref_ionsize = 0x0; + + operation_param3_tmpref_buffer = 0x0; + operation_param3_tmpref_size = 0x0; + operation_param3_memref_parent = 0x0; + operation_param3_memref_size = 0x0; + operation_param3_memref_offset = 0x0; + operation_param3_value_a = 0x0; + operation_param3_value_b = 0x0; + operation_param3_ionref_ionsharefd = 0x0; + operation_param3_ionref_ionsize = 0x0; + + operation_param4_tmpref_buffer = 0x0; + operation_param4_tmpref_size = 0x0; + operation_param4_memref_parent = 0x0; + operation_param4_memref_size = 0x0; + operation_param4_memref_offset = 0x0; + operation_param4_value_a = 0x0; + operation_param4_value_b = 0x0; + operation_param4_ionref_ionsharefd = 0x0; + operation_param4_ionref_ionsize = 0x0; + + operation_session = 0x0; + operation_cancelflag = 0x0; + + returnorigin = 0x0; + + buffer1_realsize = 0; + buffer1_outsize = buffer1_realsize; + + buffer2_realsize = 0; + buffer2_outsize = buffer2_realsize; + + buffer3_realsize = 0; + buffer3_outsize = buffer3_realsize; + + buffer4_realsize = 0; + buffer4_outsize = buffer4_realsize; + } + else + { + method_call_teec_invokecommand( + workername, + + in_session_sessionid, + in_session_serviceid_timelow, + in_session_serviceid_timemid, + in_session_serviceid_timehiandver, + in_session_serviceid_clockseqandnode, + in_session_serviceid_clockseqandnode_realsize, + in_session_opscnt, + in_session_head_next, + in_session_head_prev, + in_session_context, + + in_commandid, + + in_operation_started, + in_operation_paramtypes, + + in_operation_param1_tmpref_buffer, + in_operation_param1_tmpref_size, + in_operation_param1_memref_parent, + in_operation_param1_memref_parent_flag, + in_operation_param1_memref_size, + in_operation_param1_memref_offset, + in_operation_param1_value_a, + in_operation_param1_value_b, + in_operation_param1_ionref_ionsharefd, + in_operation_param1_ionref_ionsize, + + in_operation_param2_tmpref_buffer, + in_operation_param2_tmpref_size, + in_operation_param2_memref_parent, + in_operation_param2_memref_parent_flag, + in_operation_param2_memref_size, + in_operation_param2_memref_offset, + in_operation_param2_value_a, + in_operation_param2_value_b, + in_operation_param2_ionref_ionsharefd, + in_operation_param2_ionref_ionsize, + + in_operation_param3_tmpref_buffer, + in_operation_param3_tmpref_size, + in_operation_param3_memref_parent, + in_operation_param3_memref_parent_flag, + in_operation_param3_memref_size, + in_operation_param3_memref_offset, + in_operation_param3_value_a, + in_operation_param3_value_b, + in_operation_param3_ionref_ionsharefd, + in_operation_param3_ionref_ionsize, + + in_operation_param4_tmpref_buffer, + in_operation_param4_tmpref_size, + in_operation_param4_memref_parent, + in_operation_param4_memref_parent_flag, + in_operation_param4_memref_size, + in_operation_param4_memref_offset, + in_operation_param4_value_a, + in_operation_param4_value_b, + in_operation_param4_ionref_ionsharefd, + in_operation_param4_ionref_ionsize, + + in_operation_session, + in_operation_cancelflag, + + in_returnorigin, + + in_buffer1, + in_buffer1_realsize, + in_buffer2, + in_buffer2_realsize, + in_buffer3, + in_buffer3_realsize, + in_buffer4, + in_buffer4_realsize, + + + &teecresult, + + &sessionid, + &serviceid_timelow, + &serviceid_timemid, + &serviceid_timehiandver, + serviceid_clockseqandnode, + serviceid_clockseqandnode_realsize, + &serviceid_clockseqandnode_outsize_temp, + + &opscnt, + &head_next, + &head_prev, + &context, + + &started, + ¶mtypes, + + &operation_param1_tmpref_buffer, + &operation_param1_tmpref_size, + &operation_param1_memref_parent, + &operation_param1_memref_parent_flag, + &operation_param1_memref_size, + &operation_param1_memref_offset, + &operation_param1_value_a, + &operation_param1_value_b, + &operation_param1_ionref_ionsharefd, + &operation_param1_ionref_ionsize, + + &operation_param2_tmpref_buffer, + &operation_param2_tmpref_size, + &operation_param2_memref_parent, + &operation_param2_memref_parent_flag, + &operation_param2_memref_size, + &operation_param2_memref_offset, + &operation_param2_value_a, + &operation_param2_value_b, + &operation_param2_ionref_ionsharefd, + &operation_param2_ionref_ionsize, + + &operation_param3_tmpref_buffer, + &operation_param3_tmpref_size, + &operation_param3_memref_parent, + &operation_param3_memref_parent_flag, + &operation_param3_memref_size, + &operation_param3_memref_offset, + &operation_param3_value_a, + &operation_param3_value_b, + &operation_param3_ionref_ionsharefd, + &operation_param3_ionref_ionsize, + + &operation_param4_tmpref_buffer, + &operation_param4_tmpref_size, + &operation_param4_memref_parent, + &operation_param4_memref_parent_flag, + &operation_param4_memref_size, + &operation_param4_memref_offset, + &operation_param4_value_a, + &operation_param4_value_b, + &operation_param4_ionref_ionsharefd, + &operation_param4_ionref_ionsize, + + &operation_session, + &operation_cancelflag, + + &returnorigin_temp, + + buffer1_temp, + buffer1_size, + &buffer1_outsize_temp, + buffer2_temp, + buffer2_size, + &buffer2_outsize_temp, + buffer3_temp, + buffer3_size, + &buffer3_outsize_temp, + buffer4_temp, + buffer4_size, + &buffer4_outsize_temp + ); + + serviceid_clockseqandnode_outsize = + serviceid_clockseqandnode_outsize_temp; + + returnorigin = returnorigin_temp; + + buffer1_outsize = buffer1_outsize_temp; + buffer2_outsize = buffer2_outsize_temp; + buffer3_outsize = buffer3_outsize_temp; + buffer4_outsize = buffer4_outsize_temp; + + buffer1_realsize = buffer1_outsize; + if (buffer1_realsize > 0) + { + buffer1 = + (dbus_uint32_t *)malloc( + buffer1_realsize * sizeof(dbus_uint32_t) + ); + for (int i = 0; i < buffer1_realsize ; i++) { + buffer1[i] = (dbus_uint32_t)buffer1_temp[i]; + } + } + + buffer2_realsize = buffer2_outsize; + if (buffer2_realsize > 0) + { + buffer2 = + (dbus_uint32_t *)malloc( + buffer2_realsize * sizeof(dbus_uint32_t) + ); + for (int i = 0; i < buffer2_realsize ; i++) { + buffer2[i] = (dbus_uint32_t)buffer2_temp[i]; + } + } + + buffer3_realsize = buffer3_outsize; + if (buffer3_realsize > 0) + { + buffer3 = + (dbus_uint32_t *)malloc( + buffer3_realsize * sizeof(dbus_uint32_t) + ); + for (int i = 0; i < buffer3_realsize ; i++) { + buffer3[i] = (dbus_uint32_t)buffer3_temp[i]; + } + } + + buffer4_realsize = buffer4_outsize; + if (buffer4_realsize > 0) + { + buffer4 = + (dbus_uint32_t *)malloc( + buffer4_realsize * sizeof(dbus_uint32_t) + ); + for (int i = 0; i < buffer4_realsize ; i++) { + buffer4[i] = (dbus_uint32_t)buffer4_temp[i]; + } + } + + } // end of the else found == 1 + + if ( buffer1_temp != NULL ) + { + free(buffer1_temp); + } + if ( buffer2_temp != NULL ) + { + free(buffer2_temp); + } + if ( buffer3_temp != NULL ) + { + free(buffer3_temp); + } + if ( buffer4_temp != NULL ) + { + free(buffer4_temp); + } +#endif + /////////////////////////////////////////////////////////////////////////////////////////// + /////////////////////////////////////////////////////////////////////////////////////////// + /////////////////////////////////////////////////////////////////////////////////////////// + + // create a reply from the message + reply = dbus_message_new_method_return(msg); + + + // add the arguments to the reply + dbus_message_iter_init_append(reply, &args); + dbus_message_iter_open_container( + &args, + DBUS_TYPE_STRUCT, + NULL, + &structIter + ); + + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &teecresult + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &sessionid + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &serviceid_timelow + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &serviceid_timemid + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &serviceid_timehiandver + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &serviceid_clockseqandnode_outsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (serviceid_clockseqandnode_outsize > 0 && + serviceid_clockseqandnode != NULL + ) + { + dbus_message_iter_open_container( + &structIter, + DBUS_TYPE_ARRAY, + buf, + &ArrayIter + ); + + bResult = + dbus_message_iter_append_fixed_array( + &ArrayIter, + DBUS_TYPE_UINT32, + &serviceid_clockseqandnode, + serviceid_clockseqandnode_realsize + ); + + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return NULL; + } + + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &opscnt + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &head_next + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &head_prev + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &context + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &started + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + ¶mtypes + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param1_tmpref_buffer + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param1_tmpref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param1_memref_parent + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param1_memref_parent_flag + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param1_memref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param1_memref_offset + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param1_value_a + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param1_value_b + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &operation_param1_ionref_ionsharefd + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param1_ionref_ionsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param2_tmpref_buffer + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param2_tmpref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param2_memref_parent + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param2_memref_parent_flag + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param2_memref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param2_memref_offset + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param2_value_a + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param2_value_b + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &operation_param2_ionref_ionsharefd + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param2_ionref_ionsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param3_tmpref_buffer + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param3_tmpref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param3_memref_parent + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param3_memref_parent_flag + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param3_memref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param3_memref_offset + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param3_value_a + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param3_value_b + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &operation_param3_ionref_ionsharefd + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param3_ionref_ionsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param4_tmpref_buffer + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param4_tmpref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_param4_memref_parent + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param4_memref_parent_flag + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param4_memref_size + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param4_memref_offset + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param4_value_a + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param4_value_b + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &operation_param4_ionref_ionsharefd + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &operation_param4_ionref_ionsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT64, + &operation_session + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_INT32, + &operation_cancelflag + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &returnorigin + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &buffer1_outsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (buffer1_outsize > 0 && + buffer1 != NULL + ) + { + dbus_message_iter_open_container( + &structIter, + DBUS_TYPE_ARRAY, + buf, + &ArrayIter + ); + + bResult = + dbus_message_iter_append_fixed_array( + &ArrayIter, + DBUS_TYPE_UINT32, + &buffer1, + buffer1_realsize + ); + + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return NULL; + } + + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &buffer2_outsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (buffer2_outsize > 0 && + buffer2 != NULL + ) + { + dbus_message_iter_open_container( + &structIter, + DBUS_TYPE_ARRAY, + buf, + &ArrayIter + ); + + bResult = + dbus_message_iter_append_fixed_array( + &ArrayIter, + DBUS_TYPE_UINT32, + &buffer2, + buffer2_realsize + ); + + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return NULL; + } + + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &buffer3_outsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (buffer3_outsize > 0 && + buffer3 != NULL + ) + { + dbus_message_iter_open_container( + &structIter, + DBUS_TYPE_ARRAY, + buf, + &ArrayIter + ); + + bResult = + dbus_message_iter_append_fixed_array( + &ArrayIter, + DBUS_TYPE_UINT32, + &buffer3, + buffer3_realsize + ); + + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return NULL; + } + + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + } + + bResult = + dbus_message_iter_append_basic( + &structIter, + DBUS_TYPE_UINT32, + &buffer4_outsize + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + if (buffer4_outsize > 0 && + buffer4 != NULL + ) + { + dbus_message_iter_open_container( + &structIter, + DBUS_TYPE_ARRAY, + buf, + &ArrayIter + ); + + bResult = + dbus_message_iter_append_fixed_array( + &ArrayIter, + DBUS_TYPE_UINT32, + &buffer4, + buffer4_realsize + ); + + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + dbus_message_iter_close_container( + &args, + &structIter + ); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return NULL; + } + + dbus_message_iter_close_container( + &structIter, + &ArrayIter + ); + } + + dbus_message_iter_close_container( + &args, + &structIter + ); + + // send the reply && flush the connection + serial = 100; + if (!dbus_connection_send(conn, reply, &serial)) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + free(thdfargs); + return NULL; + } + + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + // dbus_connection_close(conn); + // dbus_connection_unref(conn); + free(thdfargs); + //printf("gpworker %d\n",__LINE__); + + // sleep(2); + + return NULL; +} + + +#ifdef GP_PROXY + void* +session_timeout_process ( + void* thdfargs +) +{ + DBusMsgConn* DBusMCP; + pthread_mutex_t * mutex_workerrec; + wr_t * workerrec; + + DBusMCP = (DBusMsgConn*)thdfargs; + mutex_workerrec = DBusMCP->mutex_workerrec; + workerrec = DBusMCP->workerrec; + + struct timeval tv; + uint64_t u64time; + + char workername[1024]; + memset((char *)workername, 0, 1024); + int iworker; + + dbus_uint32_t in_session_seesionid; + dbus_uint32_t in_session_serviceid_timelow = 0; + dbus_uint32_t in_session_serviceid_timemid = 0; + dbus_uint32_t in_session_serviceid_timehiandver = 0; + dbus_uint32_t in_session_serviceid_clockseqandnode_size = 8; + dbus_uint32_t in_session_serviceid_clockseqandnode[8]; + dbus_uint32_t in_session_opscnt = 0; + dbus_uint64_t in_session_head_next = 0; + dbus_uint64_t in_session_head_prev = 0; + dbus_uint64_t in_session_context; + + dbus_uint32_t seesionid; + dbus_uint32_t serviceid_timelow; + dbus_uint32_t serviceid_timemid; + dbus_uint32_t serviceid_timehiandver; + dbus_uint32_t * serviceid_clockseqandnode; + int serviceid_clockseqandnode_realsize; + dbus_uint32_t opscnt; + dbus_uint64_t head_next; + dbus_uint64_t head_prev; + dbus_uint64_t context; + + sin_t * sinIns; + + while (1) + { + sleep(TIMEDOUT_SESSION); + + pthread_mutex_lock(mutex_workerrec); + for (iworker = 0; iworker < MAX_NUM_WORKER; iworker++) + { + if (workerrec[iworker].busy == 1) + { + sinIns = NULL; + if (workerrec[iworker].first != NULL) + { + sinIns = workerrec[iworker].first; + do + { + gettimeofday(&tv, NULL); + u64time = (long unsigned int)(tv.tv_sec - + sinIns->session_createtime.tv_sec + ); + sin_t * sinTemp = NULL; + + if (u64time > TIMEDOUT_SESSION) + { + sprintf(workername, "%s%d", "gpworker", iworker); + + in_session_seesionid = sinIns->session_id; + in_session_context = workerrec[iworker].context_addr; + + for (int iind = 0; iind < 8; iind++) + { + in_session_serviceid_clockseqandnode[iind] = 0; + } + + pthread_mutex_unlock(mutex_workerrec); + + uint32_t serviceid_clockseqandnode_outsize_temp; + serviceid_clockseqandnode_realsize = 8; + serviceid_clockseqandnode = + (dbus_uint32_t *)malloc( + serviceid_clockseqandnode_realsize * sizeof(dbus_uint32_t) + ); + + printf("\nMethod call teec closesession. (Called by Proxy for timeout process) \n"); + method_call_teec_closesession( + workername, + + in_session_seesionid, + in_session_serviceid_timelow, + in_session_serviceid_timemid, + in_session_serviceid_timehiandver, + in_session_serviceid_clockseqandnode, + in_session_serviceid_clockseqandnode_size, + in_session_opscnt, + in_session_head_next, + in_session_head_prev, + in_session_context, + + &seesionid, + &serviceid_timelow, + &serviceid_timemid, + &serviceid_timehiandver, + serviceid_clockseqandnode, + serviceid_clockseqandnode_realsize, + &serviceid_clockseqandnode_outsize_temp, + &opscnt, + &head_next, + &head_prev, + &context + ); + + if (serviceid_clockseqandnode != NULL) { + free(serviceid_clockseqandnode); + } + + pthread_mutex_lock(mutex_workerrec); + + sinTemp = sinIns->prev; + if (sinTemp != NULL) + { + sinTemp->next = sinIns->next; + } + sinTemp = sinIns->next; + if (sinTemp != NULL) + { + sinTemp->prev = sinIns->prev; + } + if (workerrec[iworker].last == sinIns) + { + workerrec[iworker].last = sinIns->prev; + } + if (workerrec[iworker].first == sinIns) + { + workerrec[iworker].first = sinIns->next; + } + + // free(sinIns); + sinTemp = sinIns; + workerrec[iworker].sessionid_count = + workerrec[iworker].sessionid_count - 1; + + } // end of if timedout + sinIns = sinIns->next; + if (sinTemp != NULL) + { + free(sinTemp); + } + }while (sinIns != NULL); + + + } // end of the first not null + } // end of the busy = 1 + } // end of the for iworker + pthread_mutex_unlock(mutex_workerrec); + + } // end of while 1 + + + free(thdfargs); + return NULL; +} + + +void* +context_timeout_process ( + void* thdfargs +) +{ + DBusMsgConn* DBusMCP; + pthread_mutex_t * mutex_workerrec; + pthread_cond_t * cond_notbusy; + wr_t * workerrec; + + DBusMCP = (DBusMsgConn*)thdfargs; + mutex_workerrec = DBusMCP->mutex_workerrec; + cond_notbusy = DBusMCP->cond_notbusy; + workerrec = DBusMCP->workerrec; + + + + struct timeval tv; + uint64_t u64time; + + char workername[1024]; + memset((char *)workername, 0, 1024); + int iworker; + + dbus_int32_t in_fd; + unsigned char * in_ta_path = NULL; + dbus_int32_t in_ta_path_size = 0; + dbus_uint64_t in_session_list_next = 0; + dbus_uint64_t in_session_list_prev = 0; + dbus_uint64_t in_shrd_mem_list_next = 0; + dbus_uint64_t in_shrd_mem_list_prev = 0; + dbus_uint64_t in_share_buffer_buffer = 0; + dbus_int64_t in_share_buffer_buffer_barrier = 0; + dbus_uint64_t in_context_addr; + + dbus_int32_t fd; + unsigned char * ta_path; + dbus_int32_t ta_path_size; + dbus_uint64_t session_list_next; + dbus_uint64_t session_list_prev; + dbus_uint64_t shrd_mem_list_next; + dbus_uint64_t shrd_mem_list_prev; + dbus_uint64_t share_buffer_buffer; + dbus_int64_t share_buffer_buffer_barrier; + uint32_t context_tapath_outsize; + + while(1) + { + sleep(TIMEDOUT_CONTEXT); + + pthread_mutex_lock(mutex_workerrec); + for (iworker = 0; iworker < MAX_NUM_WORKER; iworker++) + { + if (workerrec[iworker].busy == 1) + { + sprintf(workername, "%s%d", "gpworker", iworker); + gettimeofday(&tv, NULL); + u64time = (long unsigned int)(tv.tv_sec - + workerrec[iworker].context_createtime.tv_sec + ); + if (u64time > TIMEDOUT_CONTEXT + && + workerrec[iworker].sessionid_count == 0 + ) + { + in_fd = workerrec[iworker].context_fd; + in_context_addr = workerrec[iworker].context_addr; + ta_path = (unsigned char *)malloc(1024 * sizeof(char)); + ta_path_size = 1024; + memset((char *)ta_path, 0, 1024); + + pthread_mutex_unlock(mutex_workerrec); + + printf("\nMethod call teec fincont. (Called by Proxy for timeout process) \n"); + method_call_teec_fincont( + workername, + + in_fd, + in_ta_path, + in_ta_path_size, + in_session_list_next, + in_session_list_prev, + in_shrd_mem_list_next, + in_shrd_mem_list_prev, + in_share_buffer_buffer, + in_share_buffer_buffer_barrier, + in_context_addr, + + &fd, + ta_path, + ta_path_size, + &session_list_next, + &session_list_prev, + &shrd_mem_list_next, + &shrd_mem_list_prev, + &share_buffer_buffer, + &share_buffer_buffer_barrier, + + &context_tapath_outsize + ); + + if (ta_path != NULL) + { + free(ta_path); + } + + pthread_mutex_lock(mutex_workerrec); + + workerrec[iworker].busy = 0; + pthread_cond_signal(cond_notbusy); + workerrec[iworker].context_fd = 0; + workerrec[iworker].context_addr = 0xffffffff; + workerrec[iworker].sessionid_count = 0; + sin_t * sinIns; + sin_t * sinInsPrev; + sinIns = workerrec[iworker].last; + if (sinIns != NULL) + { + for ( ; ; ) + { + sinInsPrev = sinIns->prev; + free(sinIns); + sinIns = sinInsPrev; + if (sinIns == NULL) + { + break; + } + } + } + + } // end of the if timeed out + } // end of the if busy = 1 + } // end of the for iworker + pthread_mutex_unlock(mutex_workerrec); + + } // end of while 1 + + free(thdfargs); + return NULL; +} +#endif + + +void * +reply_to_method_call_destroy_threadpool( + DBusMessage *msg, + DBusConnection *conn, + threadpool_t *pool +#ifdef GP_WORKER + , + pthread_mutex_t *mutex_tcl, + pthread_mutex_t *mutex_tsl +#endif + +#ifdef GP_PROXY + , + pthread_mutex_t * mutex_workerrec, + pthread_cond_t * cond_notbusy +#endif +) +{ + DBusMessage *reply; + DBusMessageIter args; + // char* param = ""; + char *param = NULL; + dbus_bool_t bResult; + dbus_uint32_t retcode; + dbus_uint32_t serial = 0; + + // read the arguments + if (!dbus_message_iter_init(msg, &args)) + fprintf(stderr, "Message has no arguments!\n"); + else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) + fprintf(stderr, "Argument is not string!\n"); + else + dbus_message_iter_get_basic(&args, ¶m); + + printf("\n"); + printf("Received mechod call Destroy: \n"); + printf(" param = %s \n", param); + printf("\n"); + + // create a reply from the message + reply = dbus_message_new_method_return(msg); + + retcode = 0x00; + + // add the arguments to the reply + dbus_message_iter_init_append(reply, &args); + bResult = + dbus_message_iter_append_basic( + &args, + DBUS_TYPE_UINT32, + &retcode + ); + if (!bResult) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return NULL; + } + + serial = 100; + if (!dbus_connection_send(conn, reply, &serial)) + { + fprintf(stderr, "Out Of Memory!\n"); + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + return NULL; + } + + dbus_message_unref(reply); + dbus_connection_flush(conn); + dbus_message_unref(msg); + // dbus_connection_close(conn); + // dbus_connection_unref(conn); + + + threadpool_destroy(pool); + +#ifdef GP_WORKER + pthread_mutex_destroy(mutex_tcl); + pthread_mutex_destroy(mutex_tsl); +#endif + +#ifdef GP_PROXY + pthread_mutex_destroy(mutex_workerrec); + pthread_cond_destroy(cond_notbusy); +#endif + + printf("\n"); + printf("This process exits. \n"); + printf("\n"); + + exit(1); + + return NULL; +} + +#endif -- Gitee