void client::run_client_send() { HANDLE Semaphores[2]; Semaphores[0] = Semaphore_client_send; Semaphores[1] = Semaphore_client_send_exit; while (1) { ReleaseSemaphore(Semaphore_server_send, 1, NULL); int index = WaitForMultipleObjects(2, Semaphores, FALSE, INFINITE) - WAIT_OBJECT_0; if (index == 1) break; if (getch_noblock() != -1) { DWORD number_of_bytes_written; print_server(); cin.clear(); getline(cin, message_to_send); ReleaseSemaphore(Semaphore_server_start_print, 1, NULL); int number_of_blocks = message_to_send.size() / size_of_buff + 1; int size = message_to_send.size(); WriteFile(hPipe, &number_of_blocks, sizeof(number_of_blocks), &number_of_bytes_written, (LPOVERLAPPED)NULL); WriteFile(hPipe, &size, sizeof(size), &number_of_bytes_written, (LPOVERLAPPED)NULL); for (int i = 0; i < number_of_blocks; i++) { message_to_send.copy(buff, size_of_buff, i * size_of_buff); if (!WriteFile(hPipe, buff, size_of_buff, &number_of_bytes_written, (LPOVERLAPPED)NULL)) { cout << "Write Error" << endl; } } WaitForSingleObject(Semaphore_server_end_print, INFINITE); } Sleep(1); } }
static void on_properties_changed(GDBusProxy *proxy, GVariant *changed, const char *const *invalidated, gpointer user_data) { struct app *app = user_data; printf("%015.3f --- Properties Changed ---\n", g_timer_elapsed(app->timer, NULL)); if (g_variant_n_children(changed) > 0) { GVariantIter *itr; const char *prop; GVariant *value; printf("Changed Properties:"); g_variant_get(changed, "a{sv}", &itr); while (g_variant_iter_loop(itr, "{&sv}", &prop, &value)) { char *str; str = g_variant_print(value, TRUE); printf(" %s=%s", prop, str); g_free(str); } g_variant_iter_free(itr); printf("\n"); } if (invalidated[0] != NULL) { const char * const *itr; printf("Invalidated Properties:"); for (itr = invalidated; *itr != NULL; itr++) printf(" %s", *itr); printf("\n"); } print_server(proxy); }
static void do_status(struct app *app) { print_server(app->proxy); g_main_loop_quit(app->loop); app->ret = EXIT_SUCCESS; }
static void do_monitor(struct app *app) { app->timer = g_timer_new(); g_timer_start(app->timer); print_server(app->proxy); g_signal_connect(app->proxy, "g-properties-changed", G_CALLBACK(on_properties_changed), app); g_signal_connect(app->proxy, "notify::g-name-owner", G_CALLBACK(on_name_owner_notify), app); }
static gboolean do_delayed_print_server(gpointer data) { GDBusProxy *proxy = data; char **props; char *nameowner; nameowner = g_dbus_proxy_get_name_owner(proxy); if (!nameowner) { print_server(proxy); return FALSE; } g_free(nameowner); props = g_dbus_proxy_get_cached_property_names(proxy); if (!props) { g_timeout_add(1000, do_delayed_print_server, proxy); return FALSE; } g_strfreev(props); print_server(data); return FALSE; }
void server::server_print() { HANDLE Semaphores[3]; Semaphore_server[0] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "SEMAPHORE_SERVER_START_PRINT"); Semaphore_server[1] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "SEMAPHORE_SERVER_END_PRINT"); Semaphore_server[2] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "SEMAPHORE_SERVER_PRINT_EXIT"); Semaphore_server[3] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "SEMAPHORE_SERVER_SEND"); Semaphore_server[4] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "SEMAPHORE_SERVER_SEND_EXIT"); Semaphores[0] = Semaphore_server[0]; //SEMAPHORE_SERVER_START_PRINT Semaphores[1] = Semaphore_server[1]; //SEMAPHORE_SERVER_END_PRINT Semaphores[2] = Semaphore_server[2]; //SEMAPHORE_SERVER_PRINT_EXIT while (1) { flag = TRUE; DWORD numberber_of_bytes_read; print_message.clear(); int index = WaitForMultipleObjects(3, Semaphores, FALSE, INFINITE) - WAIT_OBJECT_0; if (index == 2) break; int numberber_of_blocks; int size; if (!ReadFile(hNamedPipe, &numberber_of_blocks, sizeof(numberber_of_blocks), &numberber_of_bytes_read, NULL)) break; if (!ReadFile(hNamedPipe, &size, sizeof(size), &numberber_of_bytes_read, NULL)) break; for (int i = 0; i < numberber_of_blocks; i++) { flag = ReadFile(hNamedPipe, buffer, size_of_buffer, &numberber_of_bytes_read, NULL); if (!flag) break; print_message.append(buffer, size_of_buffer); } if (!flag) break; print_message.resize(size); print_server(); for (int i = 0; i < size; i++) { cout << print_message[i]; Sleep(SLEEP_TIME); } cout << endl; ReleaseSemaphore(Semaphore_server[1], 1, NULL); //SEMAPHORE_SERVER_END_PRINT } }
/* for debugging only */ void print_request(jsonrpc_request_t* req) { if(!req) { INFO("request is (null)\n"); return; } INFO("------request------\n"); INFO("| id: %d\n", req->id); if(req->type == RPC_NOTIFICATION) { INFO("| type: notification\n"); } else if(req->type == RPC_REQUEST) { INFO("| type: request\n"); } else { INFO("| type: unknown (%d)\n", (int)req->type); } if(!(req->server)) { INFO("| server: (null)\n"); } else { print_server(req->server); } if(!(req->cmd)) { INFO("| cmd: (null)\n"); } else { INFO("| cmd->route: %.*s\n", STR(req->cmd->route)); } INFO("| payload: %s\n", json_dumps(req->payload, 0)); INFO("| retry: %d\n", req->retry); INFO("| ntries: %d\n", req->ntries); INFO("| timeout: %d\n", req->timeout); INFO("\t-------------------\n"); }
static void write_function_stubs(type_t *iface, unsigned int *proc_offset) { const func_t *func; const var_t *var; const var_t* explicit_handle_var; if (!iface->funcs) return; LIST_FOR_EACH_ENTRY( func, iface->funcs, const func_t, entry ) { const var_t *def = func->def; int has_full_pointer = is_full_pointer_function(func); /* check for a defined binding handle */ explicit_handle_var = get_explicit_handle_var(func); fprintf(server, "void __RPC_STUB\n"); fprintf(server, "%s_", iface->name); write_name(server, def); fprintf(server, "(\n"); indent++; print_server("PRPC_MESSAGE _pRpcMessage)\n"); indent--; /* write the functions body */ fprintf(server, "{\n"); indent++; /* Declare arguments */ declare_stub_args(server, indent, func); print_server("MIDL_STUB_MESSAGE _StubMsg;\n"); print_server("RPC_STATUS _Status;\n"); fprintf(server, "\n"); print_server("((void)(_Status));\n"); print_server("NdrServerInitializeNew(\n"); indent++; print_server("_pRpcMessage,\n"); print_server("&_StubMsg,\n"); print_server("&%s_StubDesc);\n", iface->name); indent--; fprintf(server, "\n"); write_parameters_init(server, indent, func); if (explicit_handle_var) { print_server("%s = _pRpcMessage->Handle;\n", explicit_handle_var->name); fprintf(server, "\n"); } print_server("RpcTryFinally\n"); print_server("{\n"); indent++; print_server("RpcTryExcept\n"); print_server("{\n"); indent++; if (has_full_pointer) write_full_pointer_init(server, indent, func, TRUE); if (func->args) { print_server("if ((_pRpcMessage->DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)\n"); indent++; print_server("NdrConvert(\n"); indent++; print_server("(PMIDL_STUB_MESSAGE)&_StubMsg,\n"); print_server("(PFORMAT_STRING)&__MIDL_ProcFormatString.Format[%u]);\n", *proc_offset); indent -= 2; fprintf(server, "\n"); /* unmarshall arguments */ write_remoting_arguments(server, indent, func, PASS_IN, PHASE_UNMARSHAL); } print_server("if (_StubMsg.Buffer > _StubMsg.BufferEnd)\n"); print_server("{\n"); indent++; print_server("RpcRaiseException(RPC_X_BAD_STUB_DATA);\n"); indent--; print_server("}\n"); indent--; print_server("}\n"); print_server("RpcExcept(RPC_BAD_STUB_DATA_EXCEPTION_FILTER)\n"); print_server("{\n"); indent++; print_server("RpcRaiseException(RPC_X_BAD_STUB_DATA);\n"); indent--; print_server("}\n"); print_server("RpcEndExcept\n"); fprintf(server, "\n"); /* Assign 'out' arguments */ assign_stub_out_args(server, indent, func); /* Call the real server function */ if (!is_void(get_func_return_type(func))) print_server("_RetVal = "); else print_server(""); write_prefix_name(server, prefix_server, def); if (func->args) { int first_arg = 1; fprintf(server, "(\n"); indent++; LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry ) { if (first_arg) first_arg = 0; else fprintf(server, ",\n"); if (is_context_handle(var->type)) { /* if the context_handle attribute appears in the chain of types * without pointers being followed, then the context handle must * be direct, otherwise it is a pointer */ int is_ch_ptr = is_aliaschain_attr(var->type, ATTR_CONTEXTHANDLE) ? FALSE : TRUE; print_server("("); write_type_decl_left(server, var->type); fprintf(server, ")%sNDRSContextValue(%s)", is_ch_ptr ? "" : "*", var->name); } else { print_server(""); if (var->type->declarray) fprintf(server, "*"); write_name(server, var); } } fprintf(server, ");\n"); indent--; } else {
int main(int argc, char **argv) { int port = 4000; if (argc >= 2) port = atoi(argv[1]); struct sockaddr_in sin; sin.sin_family = AF_INET; sin.sin_addr.s_addr = INADDR_ANY; sin.sin_port = htons(port); int srvfd = socket(AF_INET, SOCK_STREAM, 0); if (srvfd < 0) err(1, "socket"); int on = 1; if (setsockopt(srvfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on))) err(1, "setsockopt SO_REUSEADDR"); if (bind(srvfd, &sin, sizeof(sin))) { /* bind 4000 failed; try a random port */ sin.sin_port = 0; if (bind(srvfd, &sin, sizeof(sin))) err(1, "bind"); } if (listen(srvfd, 5)) err(1, "listen"); print_server(srvfd); signal(SIGCHLD, SIG_IGN); signal(SIGPIPE, SIG_IGN); for (;;) { struct sockaddr_in client_addr; unsigned int addrlen = sizeof(client_addr); int cfd = accept(srvfd, (struct sockaddr *) &client_addr, &addrlen); if (cfd < 0) { perror("accept"); continue; } int pid = use_fork ? fork() : 0; if (pid < 0) { perror("fork"); close(cfd); continue; } if (pid == 0) { /* Child process. */ if (use_fork) close(srvfd); process_client(cfd); if (use_fork) exit(0); } if (pid > 0) { /* Parent process. */ close(cfd); } } }
static void write_function_stub(const type_t *iface, const var_t *func, unsigned int proc_offset) { const var_t *var; unsigned char explicit_fc, implicit_fc; int has_full_pointer = is_full_pointer_function(func); const var_t *handle_var = get_func_handle_var( iface, func, &explicit_fc, &implicit_fc ); if (is_interpreted_func( iface, func )) return; print_server("struct __frame_%s_%s\n{\n", iface->name, get_name(func)); indent++; print_server("__DECL_EXCEPTION_FRAME\n"); print_server("MIDL_STUB_MESSAGE _StubMsg;\n"); /* Declare arguments */ declare_stub_args(server, indent, func); indent--; print_server("};\n\n"); print_server("static void __finally_%s_%s(", iface->name, get_name(func)); fprintf(server," struct __frame_%s_%s *__frame )\n{\n", iface->name, get_name(func)); indent++; write_remoting_arguments(server, indent, func, "__frame->", PASS_OUT, PHASE_FREE); if (!is_void(type_function_get_rettype(func->type))) write_remoting_arguments(server, indent, func, "__frame->", PASS_RETURN, PHASE_FREE); if (has_full_pointer) write_full_pointer_free(server, indent, func); indent--; print_server("}\n\n"); print_server("void __RPC_STUB %s_%s( PRPC_MESSAGE _pRpcMessage )\n", iface->name, get_name(func)); /* write the functions body */ fprintf(server, "{\n"); indent++; print_server("struct __frame_%s_%s __f, * const __frame = &__f;\n", iface->name, get_name(func)); if (has_out_arg_or_return(func)) print_server("RPC_STATUS _Status;\n"); fprintf(server, "\n"); print_server("NdrServerInitializeNew(\n"); indent++; print_server("_pRpcMessage,\n"); print_server("&__frame->_StubMsg,\n"); print_server("&%s_StubDesc);\n", iface->name); indent--; fprintf(server, "\n"); print_server( "RpcExceptionInit( __server_filter, __finally_%s_%s );\n", iface->name, get_name(func)); write_parameters_init(server, indent, func, "__frame->"); if (explicit_fc == RPC_FC_BIND_PRIMITIVE) { print_server("__frame->%s = _pRpcMessage->Handle;\n", handle_var->name); fprintf(server, "\n"); } print_server("RpcTryFinally\n"); print_server("{\n"); indent++; print_server("RpcTryExcept\n"); print_server("{\n"); indent++; if (has_full_pointer) write_full_pointer_init(server, indent, func, TRUE); if (type_get_function_args(func->type)) { print_server("if ((_pRpcMessage->DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)\n"); indent++; print_server("NdrConvert(&__frame->_StubMsg, (PFORMAT_STRING)&__MIDL_ProcFormatString.Format[%u]);\n", proc_offset); indent--; fprintf(server, "\n"); /* unmarshall arguments */ write_remoting_arguments(server, indent, func, "__frame->", PASS_IN, PHASE_UNMARSHAL); } print_server("if (__frame->_StubMsg.Buffer > __frame->_StubMsg.BufferEnd)\n"); print_server("{\n"); indent++; print_server("RpcRaiseException(RPC_X_BAD_STUB_DATA);\n"); indent--; print_server("}\n"); indent--; print_server("}\n"); print_server("RpcExcept(RPC_BAD_STUB_DATA_EXCEPTION_FILTER)\n"); print_server("{\n"); indent++; print_server("RpcRaiseException(RPC_X_BAD_STUB_DATA);\n"); indent--; print_server("}\n"); print_server("RpcEndExcept\n"); fprintf(server, "\n"); /* Assign 'out' arguments */ assign_stub_out_args(server, indent, func, "__frame->"); /* Call the real server function */ print_server("%s%s%s", is_void(type_function_get_rettype(func->type)) ? "" : "__frame->_RetVal = ", prefix_server, get_name(func)); if (type_get_function_args(func->type)) { int first_arg = 1; fprintf(server, "(\n"); indent++; LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry ) { if (first_arg) first_arg = 0; else fprintf(server, ",\n"); if (is_context_handle(var->type)) { /* if the context_handle attribute appears in the chain of types * without pointers being followed, then the context handle must * be direct, otherwise it is a pointer */ const char *ch_ptr = is_aliaschain_attr(var->type, ATTR_CONTEXTHANDLE) ? "*" : ""; print_server("("); write_type_decl_left(server, var->type); fprintf(server, ")%sNDRSContextValue(__frame->%s)", ch_ptr, var->name); } else { print_server("%s__frame->%s", is_array(var->type) && !type_array_is_decl_as_ptr(var->type) ? "*" : "", var->name); } } fprintf(server, ");\n"); indent--; }