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--;
}
