static Eina_Bool _ecore_con_local_win32_server_peek_client_handler(void *data, Ecore_Win32_Handler *wh) { Ecore_Con_Client *cl; #if 0 char *msg; #endif cl = (Ecore_Con_Client *)data; if (!ResetEvent(cl->host_server->event_peek)) return ECORE_CALLBACK_RENEW; #if 0 msg = evil_last_error_get(); if (msg) { ecore_con_event_server_error(cl->host_server, msg); free(msg); } #endif if (!cl->host_server->delete_me) ecore_con_event_server_del(cl->host_server); cl->host_server->dead = EINA_TRUE; return ECORE_CALLBACK_CANCEL; ecore_main_win32_handler_del(wh); return ECORE_CALLBACK_DONE; }
static Eina_Bool _ecore_con_local_win32_server_peek_client_handler(void *data, Ecore_Win32_Handler *wh) { Ecore_Con_Client *obj = data; Ecore_Con_Client_Data *cl = eo_data_scope_get(obj, ECORE_CON_CLIENT_CLASS); Ecore_Con_Server_Data *host_svr = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS); #if 0 char *msg; #endif if (!ResetEvent(host_svr->event_peek)) return ECORE_CALLBACK_RENEW; #if 0 msg = evil_last_error_get(); if (msg) { ecore_con_event_server_error(host_svr, msg); free(msg); } #endif _ecore_con_server_kill(cl->host_server); return ECORE_CALLBACK_CANCEL; ecore_main_win32_handler_del(wh); return ECORE_CALLBACK_DONE; }
static Eina_Bool _ecore_con_local_win32_server_read_client_handler(void *data, Ecore_Win32_Handler *wh) { Ecore_Con_Client *cl; void *buf; DWORD n; Eina_Bool broken_pipe = EINA_FALSE; cl = (Ecore_Con_Client *)data; if (!ResetEvent(cl->host_server->event_read)) return ECORE_CALLBACK_RENEW; buf = malloc(cl->host_server->nbr_bytes); if (!buf) return ECORE_CALLBACK_RENEW; if (ReadFile(cl->host_server->pipe, buf, cl->host_server->nbr_bytes, &n, NULL)) { if (!cl->delete_me) ecore_con_event_client_data(cl, buf, cl->host_server->nbr_bytes, EINA_FALSE); cl->host_server->want_write = 1; } else { if (GetLastError() == ERROR_BROKEN_PIPE) broken_pipe = EINA_TRUE; } if (broken_pipe) { #if 0 char *msg; msg = evil_last_error_get(); if (msg) { ecore_con_event_client_error(cl, msg); free(msg); } #endif if (!cl->delete_me) ecore_con_event_client_del(cl); cl->dead = EINA_TRUE; return ECORE_CALLBACK_CANCEL; } if (cl->host_server->want_write) ecore_con_local_win32_client_flush(cl); ecore_main_win32_handler_del(wh); return ECORE_CALLBACK_DONE; }
static Eina_Bool _ecore_con_local_win32_server_read_client_handler(void *data, Ecore_Win32_Handler *wh) { Ecore_Con_Client *obj = data; Ecore_Con_Client_Data *cl = eo_data_scope_get(obj, ECORE_CON_CLIENT_CLASS); void *buf; DWORD n; Eina_Bool broken_pipe = EINA_FALSE; Ecore_Con_Server_Data *host_svr = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS); if (!ResetEvent(host_svr->event_read)) return ECORE_CALLBACK_RENEW; buf = malloc(host_svr->nbr_bytes); if (!buf) return ECORE_CALLBACK_RENEW; if (ReadFile(host_svr->pipe, buf, host_svr->nbr_bytes, &n, NULL)) { if (!cl->delete_me) ecore_con_event_client_data(obj, buf, host_svr->nbr_bytes, EINA_FALSE); host_svr->want_write = 1; } else { if (GetLastError() == ERROR_BROKEN_PIPE) broken_pipe = EINA_TRUE; } if (broken_pipe) { #if 0 char *msg; msg = evil_last_error_get(); if (msg) { ecore_con_event_client_error(cl, msg); free(msg); } #endif _ecore_con_client_kill(obj); return ECORE_CALLBACK_CANCEL; } if (host_svr->want_write) ecore_con_local_win32_client_flush(obj); ecore_main_win32_handler_del(wh); return ECORE_CALLBACK_DONE; }
static Eina_Bool _ecore_con_local_win32_client_read_server_handler(void *data, Ecore_Win32_Handler *wh) { Ecore_Con_Server *obj = data; Efl_Network_Server_Data *svr = efl_data_scope_get(obj, EFL_NETWORK_SERVER_CLASS); void *buf; DWORD n; Eina_Bool broken_pipe = EINA_FALSE; if (!ResetEvent(svr->event_read)) return ECORE_CALLBACK_RENEW; buf = malloc(svr->nbr_bytes); if (!buf) return ECORE_CALLBACK_RENEW; if (ReadFile(svr->pipe, buf, svr->nbr_bytes, &n, NULL)) { if (!svr->delete_me) ecore_con_event_server_data(obj, buf, svr->nbr_bytes, EINA_FALSE); svr->want_write = 1; } else { if (GetLastError() == ERROR_BROKEN_PIPE) broken_pipe = EINA_TRUE; } if (broken_pipe) { #if 0 ecore_con_event_server_error(svr, evil_last_error_get()); #endif _ecore_con_server_kill(obj); return ECORE_CALLBACK_CANCEL; } if (svr->want_write) ecore_con_local_win32_server_flush(obj); ecore_main_win32_handler_del(wh); return ECORE_CALLBACK_DONE; }
static Eina_Bool _ecore_con_local_win32_client_peek_server_handler(void *data, Ecore_Win32_Handler *wh) { Ecore_Con_Server *obj = data; Efl_Network_Server_Data *svr = efl_data_scope_get(obj, EFL_NETWORK_SERVER_CLASS); #if 0 char *msg; #endif if (!ResetEvent(svr->event_peek)) return ECORE_CALLBACK_RENEW; #if 0 ecore_con_event_server_error(svr, evil_last_error_get()); #endif _ecore_con_server_kill(obj); return ECORE_CALLBACK_CANCEL; ecore_main_win32_handler_del(wh); return ECORE_CALLBACK_DONE; }
Eina_Bool ecore_con_local_connect(Ecore_Con_Server *obj, Eina_Bool (*cb_done)(void *data, Ecore_Fd_Handler *fd_handler)) { #warning "I am pretty sure cb_done should be used." Efl_Network_Server_Data *svr = efl_data_scope_get(obj, EFL_NETWORK_SERVER_CLASS); char *buf = NULL; Ecore_Win32_Handler *handler_read; Ecore_Win32_Handler *handler_peek; if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_ABSTRACT) { WRN("Your system does not support abstract sockets!"); return EINA_FALSE; } if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_USER) buf = ecore_con_local_path_new(EINA_FALSE, svr->name, svr->port); else if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_SYSTEM) buf = ecore_con_local_path_new(EINA_TRUE, svr->name, svr->port); EINA_SAFETY_ON_NULL_RETURN_VAL(buf, EINA_FALSE); while (1) { svr->pipe = CreateFile(buf, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); if (svr->pipe != INVALID_HANDLE_VALUE) break; /* if pipe not busy, we exit */ if (GetLastError() != ERROR_PIPE_BUSY) { DBG("Connection to a server failed"); free(buf); return EINA_FALSE; } /* pipe busy, so we wait for it */ if (!WaitNamedPipe(buf, NMPWAIT_WAIT_FOREVER)) { DBG("Can not wait for a server"); goto close_pipe; } } svr->path = buf; buf = NULL; svr->event_read = CreateEvent(NULL, TRUE, FALSE, NULL); if (!svr->event_read) { ERR("Can not create event read"); goto free_path; } handler_read = ecore_main_win32_handler_add(svr->event_read, _ecore_con_local_win32_client_read_server_handler, obj); if (!handler_read) { ERR("Can not create handler read"); goto close_event_read; } svr->event_peek = CreateEvent(NULL, TRUE, FALSE, NULL); if (!svr->event_peek) { ERR("Can not create event peek"); goto del_handler_read; } handler_peek = ecore_main_win32_handler_add(svr->event_peek, _ecore_con_local_win32_client_peek_server_handler, obj); if (!handler_peek) { ERR("Can not create handler peek"); goto close_event_peek; } svr->thread_read = (HANDLE)_beginthreadex(NULL, 0, _ecore_con_local_win32_client_read_server_thread, obj, CREATE_SUSPENDED, NULL); if (!svr->thread_read) { ERR("Can not launch thread"); goto del_handler_peek; } if (!svr->delete_me) ecore_con_event_server_add(obj); ResumeThread(svr->thread_read); free(buf); return EINA_TRUE; del_handler_peek: ecore_main_win32_handler_del(handler_peek); close_event_peek: CloseHandle(svr->event_peek); del_handler_read: ecore_main_win32_handler_del(handler_read); close_event_read: CloseHandle(svr->event_read); free_path: free(svr->path); svr->path = NULL; close_pipe: CloseHandle(svr->pipe); free(buf); return EINA_FALSE; }
Eina_Bool ecore_con_local_listen(Ecore_Con_Server *obj) { Efl_Network_Server_Data *svr = efl_data_scope_get(obj, EFL_NETWORK_SERVER_CLASS); HANDLE thread_listening; Ecore_Win32_Handler *handler; if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_ABSTRACT) { ERR("Your system does not support abstract sockets!"); return EINA_FALSE; } if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_USER) svr->path = ecore_con_local_path_new(EINA_FALSE, svr->name, svr->port); else if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_SYSTEM) svr->path = ecore_con_local_path_new(EINA_TRUE, svr->name, svr->port); if (!svr->path) { ERR("Allocation failed"); return EINA_FALSE; } /* * synchronuous * block mode * wait mode */ svr->pipe = CreateNamedPipe(svr->path, PIPE_ACCESS_DUPLEX, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, PIPE_UNLIMITED_INSTANCES, BUFSIZE, BUFSIZE, 5000, NULL); if (svr->pipe == INVALID_HANDLE_VALUE) { DBG("Creation of the named pipe '%s' failed", svr->path); goto free_path; } /* * We use ConnectNamedPipe() to wait for a client to connect. * As the function is blocking, to let the main loop continuing * its iterations, we call ConnectNamedPipe() in a thread */ thread_listening = (HANDLE)_beginthreadex(NULL, 0, _ecore_con_local_win32_listening, obj, CREATE_SUSPENDED, NULL); if (!thread_listening) { ERR("Creation of the listening thread failed"); goto close_pipe; } handler = ecore_main_win32_handler_add(thread_listening, _ecore_con_local_win32_client_add, obj); if (!handler) { ERR("Creation of the client add handler failed"); goto del_handler; } svr->read_stopped = EINA_TRUE; ResumeThread(thread_listening); return EINA_TRUE; del_handler: ecore_main_win32_handler_del(handler); close_pipe: CloseHandle(svr->pipe); free_path: free(svr->path); svr->path = NULL; return EINA_FALSE; }
static Eina_Bool _ecore_con_local_win32_client_add(void *data, Ecore_Win32_Handler *wh) { Ecore_Con_Server *obj = data; Efl_Network_Server_Data *svr = efl_data_scope_get(obj, EFL_NETWORK_SERVER_CLASS); Ecore_Win32_Handler *handler_read; Ecore_Win32_Handler *handler_peek; if (!svr->pipe) return ECORE_CALLBACK_CANCEL; if (svr->delete_me) return ECORE_CALLBACK_CANCEL; if ((svr->client_limit >= 0) && (!svr->reject_excess_clients) && (svr->client_count >= (unsigned int)svr->client_limit)) return ECORE_CALLBACK_CANCEL; Ecore_Con_Client *cl_obj = efl_add(EFL_NETWORK_CLIENT_CLASS, efl_main_loop_get()); Efl_Network_Client_Data *cl = efl_data_scope_get(obj, EFL_NETWORK_CLIENT_CLASS); if (!cl) { ERR("allocation failed"); return ECORE_CALLBACK_CANCEL; } cl->host_server = obj; svr->event_read = CreateEvent(NULL, TRUE, FALSE, NULL); if (!svr->event_read) { ERR("Can not create event read"); goto free_cl; } handler_read = ecore_main_win32_handler_add(svr->event_read, _ecore_con_local_win32_server_read_client_handler, obj); if (!handler_read) { ERR("Can not create handler read"); goto close_event_read; } svr->event_peek = CreateEvent(NULL, TRUE, FALSE, NULL); if (!svr->event_peek) { ERR("Can not create event peek"); goto del_handler_read; } handler_peek = ecore_main_win32_handler_add(svr->event_peek, _ecore_con_local_win32_server_peek_client_handler, obj); if (!handler_peek) { ERR("Can not create handler peek"); goto close_event_peek; } svr->read_stopped = EINA_TRUE; svr->thread_read = (HANDLE)_beginthreadex(NULL, 0, _ecore_con_local_win32_server_read_client_thread, cl, CREATE_SUSPENDED, NULL); if (!svr->thread_read) { ERR("Can not launch thread"); goto del_handler_peek; } svr->clients = eina_list_append(svr->clients, obj); svr->client_count++; if (!cl->delete_me) ecore_con_event_client_add(obj); ecore_main_win32_handler_del(wh); ResumeThread(svr->thread_read); return ECORE_CALLBACK_DONE; del_handler_peek: ecore_main_win32_handler_del(handler_peek); close_event_peek: CloseHandle(svr->event_peek); del_handler_read: ecore_main_win32_handler_del(handler_read); close_event_read: CloseHandle(svr->event_read); free_cl: efl_del(cl_obj); return ECORE_CALLBACK_CANCEL; }
Eina_Bool ecore_con_local_connect(Ecore_Con_Server *svr, Eina_Bool (*cb_done)(void *data, Ecore_Fd_Handler *fd_handler)) { char buf[256]; Ecore_Win32_Handler *handler_read; Ecore_Win32_Handler *handler_peek; if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_ABSTRACT) { ERR("Your system does not support abstract sockets!"); return EINA_FALSE; } if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_USER) snprintf(buf, sizeof(buf), "\\\\.\\pipe\\%s", svr->name); else if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_SYSTEM) { const char *computername; computername = getenv("COMPUTERNAME"); snprintf(buf, sizeof(buf), "\\\\%s\\pipe\\%s", computername, svr->name); } while (1) { svr->pipe = CreateFile(buf, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); if (svr->pipe != INVALID_HANDLE_VALUE) break; /* if pipe not busy, we exit */ if (GetLastError() != ERROR_PIPE_BUSY) { ERR("Connection to a server failed"); return EINA_FALSE; } /* pipe busy, so we wait for it */ if (!WaitNamedPipe(buf, NMPWAIT_WAIT_FOREVER)) { ERR("Can not wait for a server"); goto close_pipe; } } svr->path = strdup(buf); if (!svr->path) { ERR("Allocation failed"); goto close_pipe; } svr->event_read = CreateEvent(NULL, TRUE, FALSE, NULL); if (!svr->event_read) { ERR("Can not create event read"); goto free_path; } handler_read = ecore_main_win32_handler_add(svr->event_read, _ecore_con_local_win32_client_read_server_handler, svr); if (!handler_read) { ERR("Can not create handler read"); goto close_event_read; } svr->event_peek = CreateEvent(NULL, TRUE, FALSE, NULL); if (!svr->event_peek) { ERR("Can not create event peek"); goto del_handler_read; } handler_peek = ecore_main_win32_handler_add(svr->event_peek, _ecore_con_local_win32_client_peek_server_handler, svr); if (!handler_peek) { ERR("Can not create handler peek"); goto close_event_peek; } svr->thread_read = (HANDLE)_beginthreadex(NULL, 0, _ecore_con_local_win32_client_read_server_thread, svr, CREATE_SUSPENDED, NULL); if (!svr->thread_read) { ERR("Can not launch thread"); goto del_handler_peek; } if (!svr->delete_me) ecore_con_event_server_add(svr); ResumeThread(svr->thread_read); return EINA_TRUE; del_handler_peek: ecore_main_win32_handler_del(handler_peek); close_event_peek: CloseHandle(svr->event_peek); del_handler_read: ecore_main_win32_handler_del(handler_read); close_event_read: CloseHandle(svr->event_read); free_path: free(svr->path); svr->path = NULL; close_pipe: CloseHandle(svr->pipe); return EINA_FALSE; }
Eina_Bool ecore_con_local_listen(Ecore_Con_Server *svr) { char buf[256]; HANDLE thread_listening; Ecore_Win32_Handler *handler; if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_ABSTRACT) { ERR("Your system does not support abstract sockets!"); return EINA_FALSE; } if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_USER) snprintf(buf, sizeof(buf), "\\\\.\\pipe\\%s", svr->name); else if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_SYSTEM) { const char *computername; computername = getenv("CoMPUTERNAME"); snprintf(buf, sizeof(buf), "\\\\%s\\pipe\\%s", computername, svr->name); } svr->path = strdup(buf); if (!svr->path) { ERR("Allocation failed"); return EINA_FALSE; } /* * synchronuous * block mode * wait mode */ svr->pipe = CreateNamedPipe(svr->path, PIPE_ACCESS_DUPLEX, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, PIPE_UNLIMITED_INSTANCES, BUFSIZE, BUFSIZE, 5000, NULL); if (svr->pipe == INVALID_HANDLE_VALUE) { ERR("Creation of the named pipe failed"); goto free_path; } /* * We use ConnectNamedPipe() to wait for a client to connect. * As the function is blocking, to let the main loop continuing * its iterations, we call ConnectNamedPipe() in a thread */ thread_listening = (HANDLE)_beginthreadex(NULL, 0, _ecore_con_local_win32_listening, svr, CREATE_SUSPENDED, NULL); if (!thread_listening) { ERR("Creation of the listening thread failed"); goto close_pipe; } handler = ecore_main_win32_handler_add(thread_listening, _ecore_con_local_win32_client_add, svr); if (!handler) { ERR("Creation of the client add handler failed"); goto del_handler; } svr->read_stopped = EINA_TRUE; ResumeThread(thread_listening); return EINA_TRUE; del_handler: ecore_main_win32_handler_del(handler); close_pipe: CloseHandle(svr->pipe); free_path: free(svr->path); svr->path = NULL; return EINA_FALSE; }
static Eina_Bool _ecore_con_local_win32_client_add(void *data, Ecore_Win32_Handler *wh) { Ecore_Con_Client *cl = NULL; Ecore_Con_Server *svr; Ecore_Win32_Handler *handler_read; Ecore_Win32_Handler *handler_peek; svr = (Ecore_Con_Server *)data; if (!svr->pipe) return ECORE_CALLBACK_CANCEL; if (svr->dead) return ECORE_CALLBACK_CANCEL; if (svr->delete_me) return ECORE_CALLBACK_CANCEL; if ((svr->client_limit >= 0) && (!svr->reject_excess_clients) && (svr->client_count >= (unsigned int)svr->client_limit)) return ECORE_CALLBACK_CANCEL; cl = calloc(1, sizeof(Ecore_Con_Client)); if (!cl) { ERR("allocation failed"); return ECORE_CALLBACK_CANCEL; } cl->host_server = svr; ECORE_MAGIC_SET(cl, ECORE_MAGIC_CON_CLIENT); cl->host_server->event_read = CreateEvent(NULL, TRUE, FALSE, NULL); if (!cl->host_server->event_read) { ERR("Can not create event read"); goto free_cl; } handler_read = ecore_main_win32_handler_add(cl->host_server->event_read, _ecore_con_local_win32_server_read_client_handler, cl); if (!handler_read) { ERR("Can not create handler read"); goto close_event_read; } cl->host_server->event_peek = CreateEvent(NULL, TRUE, FALSE, NULL); if (!cl->host_server->event_peek) { ERR("Can not create event peek"); goto del_handler_read; } handler_peek = ecore_main_win32_handler_add(cl->host_server->event_peek, _ecore_con_local_win32_server_peek_client_handler, cl); if (!handler_peek) { ERR("Can not create handler peek"); goto close_event_peek; } cl->host_server->read_stopped = EINA_TRUE; cl->host_server->thread_read = (HANDLE)_beginthreadex(NULL, 0, _ecore_con_local_win32_server_read_client_thread, cl, CREATE_SUSPENDED, NULL); if (!cl->host_server->thread_read) { ERR("Can not launch thread"); goto del_handler_peek; } svr->clients = eina_list_append(svr->clients, cl); svr->client_count++; if (!cl->delete_me) ecore_con_event_client_add(cl); ecore_main_win32_handler_del(wh); ResumeThread(cl->host_server->thread_read); return ECORE_CALLBACK_DONE; del_handler_peek: ecore_main_win32_handler_del(handler_peek); close_event_peek: CloseHandle(cl->host_server->event_peek); del_handler_read: ecore_main_win32_handler_del(handler_read); close_event_read: CloseHandle(cl->host_server->event_read); free_cl: free(cl); return ECORE_CALLBACK_CANCEL; }
EAPI Ecore_Exe * ecore_exe_pipe_run(const char *exe_cmd, Ecore_Exe_Flags flags, const void *data) { STARTUPINFO si; PROCESS_INFORMATION pi; Ecore_Exe_Event_Add *e; Ecore_Exe *exe; char *ret = NULL; exe = calloc(1, sizeof(Ecore_Exe)); if (!exe) return NULL; if ((flags & ECORE_EXE_PIPE_AUTO) && (!(flags & ECORE_EXE_PIPE_ERROR)) && (!(flags & ECORE_EXE_PIPE_READ))) /* We need something to auto pipe. */ flags |= ECORE_EXE_PIPE_READ | ECORE_EXE_PIPE_ERROR; exe->flags = flags; if (exe->flags & ECORE_EXE_PIPE_READ) if (!_ecore_exe_win32_pipes_set(exe)) goto free_exe; if (exe->flags & ECORE_EXE_PIPE_WRITE) if (!_ecore_exe_win32_pipes_set(exe)) goto close_pipes; if (exe->flags & ECORE_EXE_PIPE_ERROR) if (!_ecore_exe_win32_pipes_set(exe)) goto close_pipes; if ((exe->flags & ECORE_EXE_USE_SH) || ((ret = strrstr(exe_cmd, ".bat")) && (ret[4] == '\0'))) { char buf[PATH_MAX]; snprintf(buf, PATH_MAX, "cmd.exe /c %s", exe_cmd); exe->cmd = strdup(buf); } else exe->cmd = strdup(exe_cmd); if (!exe->cmd) goto close_pipes; ZeroMemory(&pi, sizeof(PROCESS_INFORMATION)); ZeroMemory(&si, sizeof(STARTUPINFO)); si.cb = sizeof(STARTUPINFO); si.hStdOutput = exe->pipe_read.child_pipe_x; si.hStdInput = exe->pipe_write.child_pipe; si.hStdError = exe->pipe_error.child_pipe_x; si.dwFlags |= STARTF_USESTDHANDLES; /* FIXME: gerer la priorite */ if (!CreateProcess(NULL, exe->cmd, NULL, NULL, EINA_TRUE, run_pri | CREATE_SUSPENDED, NULL, NULL, &si, &pi)) goto free_exe_cmd; /* be sure that the child process is running */ /* FIXME: This does not work if the child is an EFL-based app */ /* if (WaitForInputIdle(pi.hProcess, INFINITE) == WAIT_FAILED) */ /* goto free_exe_cmd; */ ECORE_MAGIC_SET(exe, ECORE_MAGIC_EXE); exe->process = pi.hProcess; exe->process_thread = pi.hThread; exe->process_id = pi.dwProcessId; exe->thread_id = pi.dwThreadId; exe->data = (void *)data; if (!(exe->process2 = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_SUSPEND_RESUME | PROCESS_TERMINATE | SYNCHRONIZE, EINA_FALSE, pi.dwProcessId))) goto close_thread; exe->h_close = ecore_main_win32_handler_add(exe->process2, _ecore_exe_close_cb, exe); if (!exe->h_close) goto close_process2; if (ResumeThread(exe->process_thread) == ((DWORD)-1)) goto close_process2; exes = (Ecore_Exe *)eina_inlist_append(EINA_INLIST_GET(exes), EINA_INLIST_GET(exe)); e = (Ecore_Exe_Event_Add *)calloc(1, sizeof(Ecore_Exe_Event_Add)); if (!e) goto delete_h_close; e->exe = exe; ecore_event_add(ECORE_EXE_EVENT_ADD, e, _ecore_exe_event_add_free, NULL); return exe; delete_h_close: ecore_main_win32_handler_del(exe->h_close); close_process2: CloseHandle(exe->process2); close_thread: CloseHandle(exe->process_thread); CloseHandle(exe->process); free_exe_cmd: free(exe->cmd); close_pipes: _ecore_exe_win32_pipes_close(exe); free_exe: free(exe); return NULL; }
static Eina_Error _efl_net_socket_windows_operation_done(Efl_Net_Socket_Windows_Operation *op, DWORD win32err, DWORD used_size) { Efl_Net_Socket_Windows_Data *pd; Eina_Error err = 0; if (eina_log_domain_level_check(_ecore_con_log_dom, EINA_LOG_LEVEL_DBG)) { char *msg = _efl_net_windows_error_msg_get(win32err); DBG("op=%p (socket=%p) success_cb=%p failure_cb=%p data=%p error=%s used_size=%lu", op, op->o, op->success_cb, op->failure_cb, op->data, msg, used_size); free(msg); } op->deleting = EINA_TRUE; efl_ref(op->o); pd = efl_data_scope_get(op->o, EFL_NET_SOCKET_WINDOWS_CLASS); if (pd) pd->pending_ops = eina_list_remove(pd->pending_ops, op); if (win32err) err = op->failure_cb((void *)op->data, op->o, win32err); else op->success_cb((void *)op->data, op->o, used_size); if (op->event_handler) { if (WaitForSingleObject(pd->handle, 0) != WAIT_OBJECT_0) { DWORD used_size = 0; if (GetOverlappedResult(pd->handle, &op->base, &used_size, FALSE)) { DBG("op=%p (socket=%p) success_cb=%p failure_cb=%p data=%p GetOverlappedResult(%p, %p, &size=%lu, FALSE)", op, op->o, op->success_cb, op->failure_cb, op->data, pd->handle, &op->base, used_size); } else { win32err = GetLastError(); if (eina_log_domain_level_check(_ecore_con_log_dom, EINA_LOG_LEVEL_DBG)) { char *msg = _efl_net_windows_error_msg_get(win32err); DBG("op=%p (socket=%p) success_cb=%p failure_cb=%p data=%p GetOverlappedResult(%p, %p, &size=%lu, TRUE)=%s", op, op->o, op->success_cb, op->failure_cb, op->data, pd->handle, &op->base, used_size, msg); free(msg); } if (win32err == ERROR_IO_INCOMPLETE) { DBG("op=%p (socket=%p) success_cb=%p failure_cb=%p data=%p: still pending I/O...", op, op->o, op->success_cb, op->failure_cb, op->data); efl_unref(op->o); op->o = NULL; return 0; } } } ecore_main_win32_handler_del(op->event_handler); } #ifndef ERROR_HANDLES_CLOSED #define ERROR_HANDLES_CLOSED 676 #endif if ((win32err == ERROR_HANDLES_CLOSED) && !efl_io_closer_closed_get(op->o)) efl_io_closer_close(op->o); efl_unref(op->o); CloseHandle(op->base.hEvent); free(op); return err; }