DWORD WINAPI WriteThreadProc(LPVOID lpParameter)
{
HANDLE hFile = HANDLE(lpParameter);
do
{
WriteBuffer* write_buffer = NULL;
bool exit = false;
EnterCriticalSection(&g_write_queue_cs);
if (g_write_queue.size() > 0)
{
write_buffer = g_write_queue.front();
g_write_queue.pop();
g_total_bytes_written += write_buffer->useful_data_size_;
}
else if (g_done)
{
exit = true;
}
SetEvent(g_write_queue_accepts_more_data_event);
LeaveCriticalSection(&g_write_queue_cs);
if (write_buffer)
{
/* DWORD bytes_written = 0;
::WriteFile(hFile, write_buffer->ptr_, write_buffer->useful_data_size_,
&bytes_written, NULL); */
delete write_buffer;
}
else if (exit) {
break;
} else {
// Wait for new(s).
WaitForSingleObject(g_write_queue_has_more_data_event, INFINITE);
}
} while (true);
return 1;
}
pnm
pnm_load(char *path)
{
FILE *input = L_r_open(path);
pnm self = NULL;
HANDLE(any, self = L_load(input));
fclose(input);
if (EXCEPTION_RAISED(any))
{
if (self != NULL)
memory_free(self);
if (EXCEPTION_RAISED(get_int))
RAISE(error, "Truncated pnm file");
if (EXCEPTION_RAISED(any))
RAISE_AGAIN();
}
return self;
}
static void
on_timer_callback(uv_timer_t *handle)
{
PyGILState_STATE gstate = PyGILState_Ensure();
Timer *self;
PyObject *result;
ASSERT(handle);
self = PYUV_CONTAINER_OF(handle, Timer, timer_h);
/* Object could go out of scope in the callback, increase refcount to avoid it */
Py_INCREF(self);
result = PyObject_CallFunctionObjArgs(self->callback, self, NULL);
if (result == NULL) {
handle_uncaught_exception(HANDLE(self)->loop);
}
Py_XDECREF(result);
Py_DECREF(self);
PyGILState_Release(gstate);
}
static void
on_pipe_read2(uv_pipe_t* handle, int nread, uv_buf_t buf, uv_handle_type pending)
{
PyGILState_STATE gstate = PyGILState_Ensure();
uv_err_t err;
Stream *self;
PyObject *result, *data, *py_errorno, *py_pending;
ASSERT(handle);
self = (Stream *)handle->data;
ASSERT(self);
/* Object could go out of scope in the callback, increase refcount to avoid it */
Py_INCREF(self);
py_pending = PyInt_FromLong((long)pending);
if (nread >= 0) {
data = PyBytes_FromStringAndSize(buf.base, nread);
py_errorno = Py_None;
Py_INCREF(Py_None);
} else {
data = Py_None;
Py_INCREF(Py_None);
err = uv_last_error(UV_HANDLE_LOOP(self));
py_errorno = PyInt_FromLong((long)err.code);
}
result = PyObject_CallFunctionObjArgs(self->on_read_cb, self, data, py_pending, py_errorno, NULL);
if (result == NULL) {
handle_uncaught_exception(HANDLE(self)->loop);
}
Py_XDECREF(result);
Py_DECREF(data);
Py_DECREF(py_pending);
Py_DECREF(py_errorno);
Py_DECREF(self);
PyGILState_Release(gstate);
}
bool SockPool::InitalWriteQueue(HANDLE WriteQueue, PM &pWriteQueue)
{
pWriteQueue = (PM)MapViewOfFile(WriteQueue, FILE_MAP_WRITE, 0, 0, sizeof(Manager));///<映射写队列控制块到本地
if (pWriteQueue == NULL)
return PrintLog(_T("写控制块映射失败"), false);
pWriteQueue->hid = 0; ///<初始化写控制块参数
pWriteQueue->cid = 0;
pWriteQueue->writer = _getpid();
pWriteQueue->Cur = NULL;
HANDLE EmptyNode = CreateFileMapping(HANDLE(0xFFFFFFFF), NULL, PAGE_READWRITE, 0, sizeof(Node), NULL);///<创建一个空节点
PN pNode = (PN)MapViewOfFile(EmptyNode, FILE_MAP_WRITE, 0, 0, sizeof(Node));///<映射节点到本地
memset(pNode, 0, sizeof(Node));
UnmapViewOfFile(pNode);
DuplicateHandle(SH, EmptyNode, SH, &pWriteQueue->Tail, NULL, true, DUPLICATE_SAME_ACCESS); ///<空节点加入链表
DuplicateHandle(SH, EmptyNode, SH, &pWriteQueue->Head, NULL, true, DUPLICATE_SAME_ACCESS);
CloseHandle(EmptyNode);
if (!(pWriteQueue->Tail || pWriteQueue->Head))
return PrintLog(_T("控制管理块初始化失败"), false);
return true;
}
x4s_buf x4_ike_select_prime(uint16 v)
{
x4s_buf r = { 0 };
#define HANDLE(bits) \
case x4c_ike_a1g_modp_##bits : \
x4_buf_attach(&r,x4v_ike_modp##bits,sizeof(x4v_ike_modp##bits)); \
break;
switch (v)
{
HANDLE(768);
HANDLE(1024);
HANDLE(1536);
HANDLE(2048);
HANDLE(3072);
HANDLE(4096);
HANDLE(6144);
HANDLE(8192);
}
return r;
#undef HANDLE
}
void
iq_add_handlers(void)
{
xmpp_conn_t * const conn = connection_get_conn();
xmpp_ctx_t * const ctx = connection_get_ctx();
HANDLE(NULL, STANZA_TYPE_ERROR, _error_handler);
HANDLE(XMPP_NS_DISCO_INFO, STANZA_TYPE_GET, _disco_info_get_handler);
HANDLE(XMPP_NS_DISCO_INFO, STANZA_TYPE_RESULT, _disco_info_result_handler);
HANDLE(XMPP_NS_DISCO_ITEMS, STANZA_TYPE_GET, _disco_items_get_handler);
HANDLE(XMPP_NS_DISCO_ITEMS, STANZA_TYPE_RESULT, _disco_items_result_handler);
HANDLE(STANZA_NS_VERSION, STANZA_TYPE_GET, _version_get_handler);
HANDLE(STANZA_NS_VERSION, STANZA_TYPE_RESULT, _version_result_handler);
HANDLE(STANZA_NS_PING, STANZA_TYPE_GET, _ping_get_handler);
if (prefs_get_autoping() != 0) {
int millis = prefs_get_autoping() * 1000;
xmpp_timed_handler_add(conn, _ping_timed_handler, millis, ctx);
}
}
void CFile::open(const STRING &fileName, CONST UINT mode)
{
if (m_hFile != HFILE_ERROR)
{
CloseHandle(HANDLE(m_hFile));
}
m_filename = fileName;
DWORD access = GENERIC_READ;
if (mode & OF_WRITE) access |= GENERIC_WRITE;
DWORD creation = (mode & OF_CREATE) ? CREATE_ALWAYS : OPEN_EXISTING;
m_hFile = (HFILE)CreateFile(resolve(fileName).c_str(),
access,
FILE_SHARE_READ,
NULL,
creation,
FILE_ATTRIBUTE_NORMAL,
NULL);
memset(&m_ptr, 0, sizeof(m_ptr));
}
/**
* @author ACM2012
* @param [in] pNode新创建的节点句柄,SockMark套接字唯一标示符
* @note 函数的主要功能是将类中缓存的接收到的数据打包到新创建的节点
*/
bool SockPool::SockDataToNode(PN pNode, unsigned int SockMark)///<将数据打包成节点形式
{
bool tmpflag = true;
transstruct *psockstruct = SockMark2SockStruct[SockMark];
memcpy(pNode->dstip, psockstruct->dstip, 20);///<填充字段
memcpy(pNode->srcip, psockstruct->srcip, 20);
pNode->dstport = psockstruct->dstport;
pNode->srcport = psockstruct->srcport;
pNode->DataLen = psockstruct->datalength;
pNode->FuncID = psockstruct->function;
CString myid;
myid.Format(_T("%d"), pNode->FuncID);
//AfxMessageBox(myid);
if (pNode->FuncID == SOCKSEND || pNode->FuncID == SOCKSENDTO)
pNode->Data = CreateFileMapping(HANDLE(0xFFFFFFFF), NULL, PAGE_READWRITE, 0, pNode->DataLen, NULL);
if (pNode->FuncID == SOCKCLOSE)
tmpflag = false;
void *pData = (void *)MapViewOfFile(pNode->Data, FILE_MAP_WRITE, 0, 0, pNode->DataLen);
if (psockstruct->data!=NULL)
memcpy(pData, psockstruct->data, pNode->DataLen);///<拷贝数据
UnmapViewOfFile(pData);
return tmpflag;
}
void csort(int *array, int size)
{
/* int tmp[RANGE + 1] = {0}; */
pthread_t *workers[WORKER_THREADS];
args_t *args[WORKER_THREADS];
int chunk_size = size / WORKER_THREADS;
int end = 0;
int i;
/* initialize the tmp array */
for(i = 0; i < RANGE + 1; i++){
sem_init(&tmp[i], 0, 0);
}
/* partition the work */
for(i = 0; i < WORKER_THREADS; i ++){
end = i == WORKER_THREADS - 1 ? size : (i + 1) * chunk_size;
args[i] = make_args(&array, i * chunk_size, end);
workers[i] = malloc(sizeof(pthread_t));
HANDLE(pthread_create(workers[i], NULL, populate_tmp_p, args[i]));
}
/* wait for everything to finish */
for(i = 0; i < WORKER_THREADS; i++){
pthread_join(*workers[i], NULL);
}
/* writeback, sequentially */
unroll_tmp(&array, RANGE);
/* free everything */
// for(i = 0; i < WORKER_THREADS; i++){
// free_args(args[i]);
/* pthread_destroy(workers[i]); */
// }
}
DWORD WINAPI WriteThreadProc(LPVOID lpParameter)
{
HANDLE hFile = HANDLE(lpParameter);
do
{
WriteBuffer* write_buffer = NULL;
bool exit = false;
EnterCriticalSection(&g_write_queue_cs);
if (g_write_queue.size() > 0)
{
write_buffer = g_write_queue.front();
g_write_queue.pop();
}
else if (g_done)
{
exit = true;
}
LeaveCriticalSection(&g_write_queue_cs);
if (write_buffer)
{
DWORD bytes_written = 0;
::WriteFile(hFile, write_buffer->ptr_, write_buffer->useful_data_size_,
&bytes_written, NULL);
delete write_buffer;
}
else if (exit) {
break;
} else {
::Sleep(0);
}
} while (true);
return 1;
}
static void
on_pipe_client_connection(uv_connect_t *req, int status)
{
PyGILState_STATE gstate = PyGILState_Ensure();
Pipe *self;
PyObject *callback, *result, *py_errorno;
ASSERT(req);
self = (Pipe *)req->handle->data;
callback = (PyObject *)req->data;
ASSERT(self);
if (status != 0) {
uv_err_t err = uv_last_error(UV_HANDLE_LOOP(self));
py_errorno = PyInt_FromLong(err.code);
} else {
py_errorno = Py_None;
Py_INCREF(Py_None);
}
result = PyObject_CallFunctionObjArgs(callback, self, py_errorno, NULL);
if (result == NULL) {
handle_uncaught_exception(HANDLE(self)->loop);
}
Py_XDECREF(result);
Py_DECREF(py_errorno);
Py_DECREF(callback);
PyMem_Free(req);
/* Refcount was increased in the caller function */
Py_DECREF(self);
PyGILState_Release(gstate);
}
static void
on_check_callback(uv_check_t *handle, int status)
{
PyGILState_STATE gstate = PyGILState_Ensure();
Check *self;
PyObject *result;
ASSERT(handle);
ASSERT(status == 0);
self = (Check *)handle->data;
ASSERT(self);
/* Object could go out of scope in the callback, increase refcount to avoid it */
Py_INCREF(self);
result = PyObject_CallFunctionObjArgs(self->callback, self, NULL);
if (result == NULL) {
handle_uncaught_exception(HANDLE(self)->loop);
}
Py_XDECREF(result);
Py_DECREF(self);
PyGILState_Release(gstate);
}
static int
UDP_tp_init(UDP *self, PyObject *args, PyObject *kwargs)
{
int r;
Loop *loop;
UNUSED_ARG(kwargs);
RAISE_IF_HANDLE_INITIALIZED(self, -1);
if (!PyArg_ParseTuple(args, "O!:__init__", &LoopType, &loop)) {
return -1;
}
r = uv_udp_init(loop->uv_loop, (uv_udp_t *)UV_HANDLE(self));
if (r != 0) {
RAISE_UV_EXCEPTION(loop->uv_loop, PyExc_UDPError);
return -1;
}
initialize_handle(HANDLE(self), loop);
return 0;
}
static int
Timer_tp_init(Timer *self, PyObject *args, PyObject *kwargs)
{
int err;
Loop *loop;
UNUSED_ARG(kwargs);
RAISE_IF_HANDLE_INITIALIZED(self, -1);
if (!PyArg_ParseTuple(args, "O!:__init__", &LoopType, &loop)) {
return -1;
}
err = uv_timer_init(loop->uv_loop, &self->timer_h);
if (err < 0) {
RAISE_UV_EXCEPTION(err, PyExc_TimerError);
return -1;
}
initialize_handle(HANDLE(self), loop);
return 0;
}
static toff_t
tiff_seek (thandle_t handle, toff_t offset, int whence)
{
Handle *h = HANDLE (handle);
GSeekType seek_type;
seek_type = G_SEEK_SET;
switch (whence) {
case SEEK_SET:
seek_type = G_SEEK_SET;
break;
case SEEK_CUR:
seek_type = G_SEEK_CUR;
break;
case SEEK_END:
seek_type = G_SEEK_END;
break;
}
if (! g_seekable_seek (G_SEEKABLE (h->istream), offset, seek_type, h->cancellable, NULL))
return -1;
return g_seekable_tell (G_SEEKABLE (h->istream));
}
static void
dump_thread(void *arg)
{
HANDLE dbghelp;
BOOL (WINAPI *pSymInitialize)(HANDLE, const char *, BOOL);
BOOL (WINAPI *pSymCleanup)(HANDLE);
BOOL (WINAPI *pStackWalk64)(DWORD, HANDLE, HANDLE, STACKFRAME64 *, void *, PREAD_PROCESS_MEMORY_ROUTINE64, PFUNCTION_TABLE_ACCESS_ROUTINE64, PGET_MODULE_BASE_ROUTINE64, PTRANSLATE_ADDRESS_ROUTINE64);
DWORD64 (WINAPI *pSymGetModuleBase64)(HANDLE, DWORD64);
BOOL (WINAPI *pSymFromAddr)(HANDLE, DWORD64, DWORD64 *, SYMBOL_INFO *);
BOOL (WINAPI *pSymGetLineFromAddr64)(HANDLE, DWORD64, DWORD *, IMAGEHLP_LINE64 *);
HANDLE (WINAPI *pOpenThread)(DWORD, BOOL, DWORD);
DWORD tid = *(DWORD *)arg;
HANDLE ph;
HANDLE th;
dbghelp = LoadLibrary("dbghelp.dll");
if (!dbghelp) return;
pSymInitialize = (BOOL (WINAPI *)(HANDLE, const char *, BOOL))GetProcAddress(dbghelp, "SymInitialize");
pSymCleanup = (BOOL (WINAPI *)(HANDLE))GetProcAddress(dbghelp, "SymCleanup");
pStackWalk64 = (BOOL (WINAPI *)(DWORD, HANDLE, HANDLE, STACKFRAME64 *, void *, PREAD_PROCESS_MEMORY_ROUTINE64, PFUNCTION_TABLE_ACCESS_ROUTINE64, PGET_MODULE_BASE_ROUTINE64, PTRANSLATE_ADDRESS_ROUTINE64))GetProcAddress(dbghelp, "StackWalk64");
pSymGetModuleBase64 = (DWORD64 (WINAPI *)(HANDLE, DWORD64))GetProcAddress(dbghelp, "SymGetModuleBase64");
pSymFromAddr = (BOOL (WINAPI *)(HANDLE, DWORD64, DWORD64 *, SYMBOL_INFO *))GetProcAddress(dbghelp, "SymFromAddr");
pSymGetLineFromAddr64 = (BOOL (WINAPI *)(HANDLE, DWORD64, DWORD *, IMAGEHLP_LINE64 *))GetProcAddress(dbghelp, "SymGetLineFromAddr64");
pOpenThread = (HANDLE (WINAPI *)(DWORD, BOOL, DWORD))GetProcAddress(GetModuleHandle("kernel32.dll"), "OpenThread");
if (pSymInitialize && pSymCleanup && pStackWalk64 && pSymGetModuleBase64 &&
pSymFromAddr && pSymGetLineFromAddr64 && pOpenThread) {
SymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS | SYMOPT_DEBUG | SYMOPT_LOAD_LINES);
ph = GetCurrentProcess();
pSymInitialize(ph, NULL, TRUE);
th = pOpenThread(THREAD_SUSPEND_RESUME|THREAD_GET_CONTEXT, FALSE, tid);
if (th) {
if (SuspendThread(th) != (DWORD)-1) {
CONTEXT context;
memset(&context, 0, sizeof(context));
context.ContextFlags = CONTEXT_FULL;
if (GetThreadContext(th, &context)) {
char libpath[MAX_PATH];
char buf[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
SYMBOL_INFO *info = (SYMBOL_INFO *)buf;
DWORD mac;
STACKFRAME64 frame;
memset(&frame, 0, sizeof(frame));
#if defined(_M_AMD64) || defined(__x86_64__)
mac = IMAGE_FILE_MACHINE_AMD64;
frame.AddrPC.Mode = AddrModeFlat;
frame.AddrPC.Offset = context.Rip;
frame.AddrFrame.Mode = AddrModeFlat;
frame.AddrFrame.Offset = context.Rbp;
frame.AddrStack.Mode = AddrModeFlat;
frame.AddrStack.Offset = context.Rsp;
#elif defined(_M_IA64) || defined(__ia64__)
mac = IMAGE_FILE_MACHINE_IA64;
frame.AddrPC.Mode = AddrModeFlat;
frame.AddrPC.Offset = context.StIIP;
frame.AddrBStore.Mode = AddrModeFlat;
frame.AddrBStore.Offset = context.RsBSP;
frame.AddrStack.Mode = AddrModeFlat;
frame.AddrStack.Offset = context.IntSp;
#else /* i386 */
mac = IMAGE_FILE_MACHINE_I386;
frame.AddrPC.Mode = AddrModeFlat;
frame.AddrPC.Offset = context.Eip;
frame.AddrFrame.Mode = AddrModeFlat;
frame.AddrFrame.Offset = context.Ebp;
frame.AddrStack.Mode = AddrModeFlat;
frame.AddrStack.Offset = context.Esp;
#endif
while (pStackWalk64(mac, ph, th, &frame, &context, NULL,
NULL, NULL, NULL)) {
DWORD64 addr = frame.AddrPC.Offset;
IMAGEHLP_LINE64 line;
DWORD64 displacement;
DWORD tmp;
if (addr == frame.AddrReturn.Offset || addr == 0 ||
frame.AddrReturn.Offset == 0)
break;
memset(buf, 0, sizeof(buf));
info->SizeOfStruct = sizeof(SYMBOL_INFO);
info->MaxNameLen = MAX_SYM_NAME;
if (pSymFromAddr(ph, addr, &displacement, info)) {
if (GetModuleFileName((HANDLE)(uintptr_t)pSymGetModuleBase64(ph, addr), libpath, sizeof(libpath)))
fprintf(stderr, "%s", libpath);
fprintf(stderr, "(%s+0x%I64x)",
info->Name, displacement);
}
fprintf(stderr, " [0x%p]", (void *)(VALUE)addr);
memset(&line, 0, sizeof(line));
line.SizeOfStruct = sizeof(line);
if (pSymGetLineFromAddr64(ph, addr, &tmp, &line))
fprintf(stderr, " %s:%lu", line.FileName, line.LineNumber);
fprintf(stderr, "\n");
}
}
ResumeThread(th);
}
CloseHandle(th);
}
pSymCleanup(ph);
}
FreeLibrary(dbghelp);
}
BOOL COXFileWatcher::AddWatch(LPCTSTR pszPath, BOOL bWatchSubtree, DWORD dwWatchFilter)
{
#if defined (_WINDLL)
#if defined (_AFXDLL)
AFX_MANAGE_STATE(AfxGetAppModuleState());
#else
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
#endif
ASSERT(pszPath != NULL);
// Clear error flag
m_hrError = ERROR_SUCCESS;
COXWatchedDir* pwdNewEntry;
// Make the class a Thread-Safe Class
CSingleLock lockObj(&m_crArrayWatchedDirGuard);
VERIFY(lockObj.Lock());
// Fisrt check if we are not watching for the same path
for(int i=0; i<m_arWatchedDirs.GetSize(); i++)
{
if((m_arWatchedDirs[i])->m_sPath == pszPath)
{
// ... OK. The path is already here
COXWatchedDir* pwdPresentEntry = m_arWatchedDirs[i];
if(bWatchSubtree == pwdPresentEntry->m_bWatchSubTree &&
dwWatchFilter == pwdPresentEntry->m_dwWatchFilter)
{
// No modifications
return TRUE;
}
pwdNewEntry = new COXWatchedDir(
pszPath, // directory to be watched
bWatchSubtree|pwdPresentEntry->m_bWatchSubTree, // flag for monitoring directory or directory tree
dwWatchFilter|pwdPresentEntry->m_dwWatchFilter, // filter conditions to watch for
IsExtendedInfoSupported()); // flag for extended info
// Create new handle
if(!pwdNewEntry->FindFirstHandle(m_hrError))
{
goto error;
}
// Prepares the handles for the watcher thread
m_pNewHandles = m_pHandles;
VERIFY(m_mxThreadCanContinue.Lock());
// Informs the watcher thread that it can change the handles
// and waits for the watcher thread to stop
VERIFY(m_mxThreadShouldStop.Unlock());
// wait until the watcher thread stops
VERIFY(m_mxThreadStopped.Lock());
// Update the entry for the given path
m_arWatchedDirs.SetAt(i, pwdNewEntry);
// Close old entry. This will close the old handle
delete pwdPresentEntry;
// Replace the old handle with the new one and start the
// thread again
m_pHandles[i+1]=pwdNewEntry->m_hEvent;
VERIFY(m_mxThreadStopped.Unlock());
VERIFY(m_mxThreadShouldStop.Lock());
// notify watcher thread that it can go on executing
VERIFY(m_mxThreadCanContinue.Unlock());
return TRUE;
}
}
pwdNewEntry = new COXWatchedDir(pszPath, // directory to be watched
bWatchSubtree, // flag for monitoring directory or directory tree
dwWatchFilter, // filter conditions to watch for
IsExtendedInfoSupported());// flag for extended info
if(pwdNewEntry->FindFirstHandle(m_hrError))
{
// Handles are m_nNumHandles, so we must allocate (m_nNumHandles+2) : one for the StartStopEvent
// and one for the new entry
m_pNewHandles= new HANDLE[m_nNumHandles + 2];
// Informs the watcher thread that it can change the handles
if(m_bThreadIsRunning)
{
VERIFY(m_mxThreadCanContinue.Lock());
// notify watcher thread that it should stop
VERIFY(m_mxThreadShouldStop.Unlock());
// wait until it stops
DWORD dwResult=::WaitForSingleObject(m_mxThreadStopped.m_hObject, 0xFFFFFFFF);
ASSERT(dwResult==NULL);
//VERIFY(m_mxThreadStopped.Lock());
}
// update the array of directories
m_arWatchedDirs.Add(pwdNewEntry);
if(0 < m_nNumHandles)
{
memcpy(m_pNewHandles,m_pHandles,(m_nNumHandles+1)*sizeof(HANDLE));
}
else
{
m_pNewHandles[0]=HANDLE(m_mxThreadShouldStop);
}
m_pNewHandles[m_nNumHandles+1] = pwdNewEntry->m_hEvent;
// ... m_pHandles may be NULL
delete [] m_pHandles;
m_pHandles = m_pNewHandles;
m_nNumHandles++;
// Starts the watcher thread
if(m_bThreadIsRunning)
{
VERIFY(m_mxThreadStopped.Unlock());
VERIFY(m_mxThreadShouldStop.Lock());
// Unlocks the watcher thread
VERIFY(m_mxThreadCanContinue.Unlock());
return TRUE;
}
else
{
// ... m_pWatcherThread may already be NULL
delete m_pWatcherThread;
VERIFY(m_eventStartThread.ResetEvent());
m_pWatcherThread=AfxBeginThread(FileWatchThreadFunction,this);
if(m_pWatcherThread!=NULL)
{
m_pWatcherThread->m_bAutoDelete = FALSE;
::WaitForSingleObject(m_eventStartThread,INFINITE);
return TRUE;
}
}
}
error:
delete pwdNewEntry;
CONDITIONAL_TRACE_RESULT("COXFileWatcher::AddWatch", m_hrError)
return FALSE;
}
/*****************************************************************************
* Thread: main loop
*****************************************************************************/
static void *Thread( void *p_data )
{
MSG message;
intf_thread_t *p_intf = p_data;
intf_sys_t *p_sys = p_intf->p_sys;
/* Window which receives Hotkeys */
vlc_mutex_lock( &p_sys->lock );
p_sys->hotkeyWindow =
(void*)CreateWindow( _T("STATIC"), /* name of window class */
_T("VLC ghk ") _T(VERSION), /* window title bar text */
0, /* window style */
0, /* default X coordinate */
0, /* default Y coordinate */
0, /* window width */
0, /* window height */
NULL, /* no parent window */
NULL, /* no menu in this window */
GetModuleHandle(NULL), /* handle of this program instance */
NULL ); /* sent to WM_CREATE */
if( p_sys->hotkeyWindow == NULL )
{
p_sys->hotkeyWindow = INVALID_HANDLE_VALUE;
vlc_cond_signal( &p_sys->wait );
vlc_mutex_unlock( &p_sys->lock );
return NULL;
}
vlc_cond_signal( &p_sys->wait );
vlc_mutex_unlock( &p_sys->lock );
SetWindowLongPtr( p_sys->hotkeyWindow, GWLP_WNDPROC,
(LONG_PTR)WMHOTKEYPROC );
SetWindowLongPtr( p_sys->hotkeyWindow, GWLP_USERDATA,
(LONG_PTR)p_intf );
/* Registering of Hotkeys */
for( const struct hotkey *p_hotkey = p_intf->obj.libvlc->p_hotkeys;
p_hotkey->psz_action != NULL;
p_hotkey++ )
{
char varname[12 + strlen( p_hotkey->psz_action )];
sprintf( varname, "global-key-%s", p_hotkey->psz_action );
char *key = var_InheritString( p_intf, varname );
if( key == NULL )
continue;
UINT i_key = vlc_str2keycode( key );
free( key );
if( i_key == KEY_UNSET )
continue;
UINT i_keyMod = 0;
if( i_key & KEY_MODIFIER_SHIFT ) i_keyMod |= MOD_SHIFT;
if( i_key & KEY_MODIFIER_ALT ) i_keyMod |= MOD_ALT;
if( i_key & KEY_MODIFIER_CTRL ) i_keyMod |= MOD_CONTROL;
#define HANDLE( key ) case KEY_##key: i_vk = VK_##key; break
#define HANDLE2( key, key2 ) case KEY_##key: i_vk = VK_##key2; break
#define KEY_SPACE ' '
#ifndef VK_VOLUME_DOWN
#define VK_VOLUME_DOWN 0xAE
#define VK_VOLUME_UP 0xAF
#endif
#ifndef VK_MEDIA_NEXT_TRACK
#define VK_MEDIA_NEXT_TRACK 0xB0
#define VK_MEDIA_PREV_TRACK 0xB1
#define VK_MEDIA_STOP 0xB2
#define VK_MEDIA_PLAY_PAUSE 0xB3
#endif
#ifndef VK_PAGEUP
#define VK_PAGEUP 0x21
#define VK_PAGEDOWN 0x22
#endif
UINT i_vk = 0;
switch( i_key & ~KEY_MODIFIER )
{
HANDLE( LEFT );
HANDLE( RIGHT );
HANDLE( UP );
HANDLE( DOWN );
HANDLE( SPACE );
HANDLE2( ESC, ESCAPE );
HANDLE2( ENTER, RETURN );
HANDLE( F1 );
HANDLE( F2 );
HANDLE( F3 );
HANDLE( F4 );
HANDLE( F5 );
HANDLE( F6 );
HANDLE( F7 );
HANDLE( F8 );
HANDLE( F9 );
HANDLE( F10 );
HANDLE( F11 );
HANDLE( F12 );
HANDLE( PAGEUP );
HANDLE( PAGEDOWN );
HANDLE( HOME );
HANDLE( END );
HANDLE( INSERT );
HANDLE( DELETE );
HANDLE( VOLUME_DOWN );
HANDLE( VOLUME_UP );
HANDLE( MEDIA_PLAY_PAUSE );
HANDLE( MEDIA_STOP );
HANDLE( MEDIA_PREV_TRACK );
HANDLE( MEDIA_NEXT_TRACK );
default:
i_vk = toupper( (uint8_t)(i_key & ~KEY_MODIFIER) );
break;
}
if( !i_vk ) continue;
#undef HANDLE
#undef HANDLE2
ATOM atom = GlobalAddAtomA( p_hotkey->psz_action );
if( !atom ) continue;
if( !RegisterHotKey( p_sys->hotkeyWindow, atom, i_keyMod, i_vk ) )
GlobalDeleteAtom( atom );
}
/* Main message loop */
while( GetMessage( &message, NULL, 0, 0 ) )
DispatchMessage( &message );
/* Unregistering of Hotkeys */
for( const struct hotkey *p_hotkey = p_intf->obj.libvlc->p_hotkeys;
p_hotkey->psz_action != NULL;
p_hotkey++ )
{
ATOM atom = GlobalFindAtomA( p_hotkey->psz_action );
if( !atom ) continue;
if( UnregisterHotKey( p_sys->hotkeyWindow, atom ) )
GlobalDeleteAtom( atom );
}
/* close window */
vlc_mutex_lock( &p_sys->lock );
DestroyWindow( p_sys->hotkeyWindow );
p_sys->hotkeyWindow = NULL;
vlc_mutex_unlock( &p_sys->lock );
return NULL;
}
static LRESULT WINAPI handle(HWND win, UINT msg, WPARAM w, LPARAM l) {
LRESULT r;
switch (msg) {
#define HANDLE(x) case WM_##x: r = HANDLE_WM_##x(win, w, l, on##x); break
HANDLE(MOUSEMOVE);
HANDLE(SIZE);
HANDLE(CLOSE);
HANDLE(KEYDOWN);
HANDLE(SYSKEYDOWN);
HANDLE(SYSKEYUP);
HANDLE(CHAR);
HANDLE(KEYUP);
HANDLE(LBUTTONDOWN);
HANDLE(RBUTTONDOWN);
HANDLE(MBUTTONDOWN);
HANDLE(LBUTTONUP);
HANDLE(RBUTTONUP);
HANDLE(MBUTTONUP);
HANDLE(MOUSEWHEEL);
HANDLE(SETCURSOR);
HANDLE(PAINT);
#undef HANDLE
default: r = 0;
}
if (!r)
r = DefWindowProcW(win, msg, w, l);
return r;
}
//---------------------------------------------------------------------------
// KillProcessTreeWinHelper
//
// This is a recursive helper function that terminates all the processes
// started by the specified process and them terminates the process itself
//
// Parameters:
// dwProcessId - identifier of the process to terminate
//
// Returns:
// Win32 error code.
//
static
BOOL
WINAPI
KillProcessTreeWinHelper
(
IN DWORD dwProcessId
)
{
HINSTANCE hKernel;
HANDLE (WINAPI * _CreateToolhelp32Snapshot)(DWORD, DWORD);
BOOL (WINAPI * _Process32First)(HANDLE, PROCESSENTRY32 *);
BOOL (WINAPI * _Process32Next)(HANDLE, PROCESSENTRY32 *);
// get handle to KERNEL32.DLL
hKernel = GetModuleHandle(_T("kernel32.dll"));
// _ASSERTE(hKernel != NULL);
// locate necessary functions in KERNEL32.DLL
*(FARPROC *)&_CreateToolhelp32Snapshot =
GetProcAddress(hKernel, "CreateToolhelp32Snapshot");
*(FARPROC *)&_Process32First =
GetProcAddress(hKernel, "Process32First");
*(FARPROC *)&_Process32Next =
GetProcAddress(hKernel, "Process32Next");
if (_CreateToolhelp32Snapshot == NULL ||
_Process32First == NULL ||
_Process32Next == NULL)
return ERROR_PROC_NOT_FOUND;
HANDLE hSnapshot;
PROCESSENTRY32 Entry;
// create a snapshot
hSnapshot = _CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hSnapshot == INVALID_HANDLE_VALUE)
return GetLastError();
Entry.dwSize = sizeof(Entry);
if (!_Process32First(hSnapshot, &Entry))
{
DWORD dwError = GetLastError();
CloseHandle(hSnapshot);
return dwError;
}
// kill all children first
do
{
if (Entry.th32ParentProcessID == dwProcessId)
KillProcessTreeWinHelper(Entry.th32ProcessID);
Entry.dwSize = sizeof(Entry);
}
while (_Process32Next(hSnapshot, &Entry));
CloseHandle(hSnapshot);
// kill the process itself
if (!KillProcess(dwProcessId))
return GetLastError();
return ERROR_SUCCESS;
}
BOOL CMemCommProcess::Open(UINT32 dwSize, BOOL bLock, string &strName)
{
dwSize = (dwSize + MEMCOMM_ALIGN_BYTE_NUM -1) / MEMCOMM_ALIGN_BYTE_NUM * MEMCOMM_ALIGN_BYTE_NUM + MEMCOMM_ALIGN_BYTE_NUM;
dwSize = sizeof(StruMemCookie) + dwSize;
#ifdef _WIN32
m_pMemHandle = CreateFileMapping(HANDLE(-1), NULL, PAGE_READWRITE, 0, dwSize, (LPCWSTR)strName.c_str());
if (m_pMemHandle == NULL)
return FALSE;
if (GetLastError() != ERROR_ALREADY_EXISTS)//不存在
{
CloseHandle(m_pMemHandle);
m_pMemHandle = NULL;
return FALSE;
}
//映射共享内存
m_pHead = MapViewOfFile(m_pMemHandle, FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, dwSize);//创建视
CloseHandle(m_pMemHandle);
if (m_pHead == NULL)
{
return FALSE;
}
#endif
#ifdef _LINUX
//获取已经存在共享内存ID
m_iShareMemID = shmget((key_t)(*(int *)strName.c_str()),0,0);
if(m_iShareMemID == -1)//表明是重新创建的
{
m_pHead = NULL;
Free();
return FALSE;
}
//获取共享内存地址
m_pHead = shmat(m_iShareMemID, (void *)0, 0);
if (m_pHead == (void *) -1)
{
m_pHead = NULL;
Free();
return FALSE;
}
#endif
m_pStruCookie = (StruMemCookie *)m_pHead;
//创建锁
if (m_pStruCookie->uiLock == 1)
{
if (m_pCGSProcessMutex == NULL)
{
m_pCGSProcessMutex = new CGSProcessMutex(m_pStruCookie->chMutexName);
if (m_pCGSProcessMutex == NULL)
{
Free();
return FALSE;
}
}
}
return TRUE;
}
const char* cmuk::getFrameString(int i) {
#define HANDLE(arg) case arg: return #arg
switch (i) {
HANDLE(FRAME_GROUND);
HANDLE(FRAME_TRUNK);
HANDLE(FRAME_FL_HIP_RX);
HANDLE(FRAME_FL_HIP_RY);
HANDLE(FRAME_FL_KNEE_RY);
HANDLE(FRAME_FL_FOOT);
HANDLE(FRAME_FR_HIP_RX);
HANDLE(FRAME_FR_HIP_RY);
HANDLE(FRAME_FR_KNEE_RY);
HANDLE(FRAME_FR_FOOT);
HANDLE(FRAME_HL_HIP_RX);
HANDLE(FRAME_HL_HIP_RY);
HANDLE(FRAME_HL_KNEE_RY);
HANDLE(FRAME_HL_FOOT);
HANDLE(FRAME_HR_HIP_RX);
HANDLE(FRAME_HR_HIP_RY);
HANDLE(FRAME_HR_KNEE_RY);
HANDLE(FRAME_HR_FOOT);
default: break;
}
return "*** INVALID FRAME ***";
#undef HANDLE
}
const char* cmuk::getErrorString(int status) {
#define HANDLE(arg) case arg: return #arg
switch (status) {
HANDLE(CMUK_OKAY);
HANDLE(CMUK_BAD_LEG_INDEX);
HANDLE(CMUK_BAD_JOINT_OFFSET);
HANDLE(CMUK_ANGLE_OUT_OF_RANGE);
HANDLE(CMUK_SINGULAR_MATRIX);
HANDLE(CMUK_INSUFFICIENT_ARGUMENTS);
HANDLE(CMUK_CANNOT_REACH_IK_KNEE_BENT_FORWARD);
HANDLE(CMUK_CANNOT_REACH_IK_KNEE_BENT_REARWARD);
HANDLE(CMUK_CANNOT_REACH_IK_KNEE_BENT_EITHER);
HANDLE(CMUK_BAD_QUATERNION_VECTOR);
HANDLE(CMUK_BAD_FRAME_INDEX);
default: break;
}
return "*** INVALID STATUS ***";
#undef HANDLE
}
/*
==============
Trace_GetHopCount
Performs a synchronous hopcount on the specified server
==============
*/
int Trace_GetHopCount( char *pServer, int nMaxHops )
{
#ifdef _WIN32
HMODULE hICMP; // Handle to ICMP .dll
HANDLE hIP; // Handle to icmp session
DWORD *dwIPAddr; // remote IP Address as a DWORD
struct hostent *pHostEnt; // Name of remote host
trace_options_t traceOptions; // Input options
int c; // Hop counter
// Prototypes
HANDLE ( WINAPI *pfnICMPCreateFile ) ( VOID );
BOOL ( WINAPI *pfnICMPCloseFile ) ( HANDLE );
DWORD (WINAPI *pfnICMPSendEcho) ( HANDLE, DWORD, LPVOID, WORD, LPVOID, LPVOID, DWORD, DWORD );
hICMP = ::LoadLibrary( "ICMP.DLL" );
pfnICMPCreateFile = ( HANDLE ( WINAPI *)(VOID ) )::GetProcAddress( hICMP,"IcmpCreateFile");
pfnICMPCloseFile = ( BOOL ( WINAPI *) ( HANDLE ) )::GetProcAddress( hICMP,"IcmpCloseHandle");
pfnICMPSendEcho = ( DWORD ( WINAPI * ) ( HANDLE, DWORD, LPVOID, WORD, LPVOID, LPVOID, DWORD,DWORD ) )::GetProcAddress( hICMP,"IcmpSendEcho" );
if ( !pfnICMPCreateFile ||
!pfnICMPCloseFile ||
!pfnICMPSendEcho )
{
return -1;
}
hIP = pfnICMPCreateFile();
if ( !hIP )
{
return -1;
}
// DNS lookup on remote host
pHostEnt = gethostbyname( pServer );
if ( !pHostEnt )
{
return -1;
}
// Take first IP address returned
dwIPAddr = ( DWORD * )( *pHostEnt->h_addr_list );
// Fixme: If not tracing, can use a "binary search" method to do the trace route
for ( c = 1; c <= nMaxHops ; c++)
{
// Set TTL correctly
traceOptions.ucTTL = (unsigned char)c;
// Clear out return structure
memset( &traceReturn, 0, sizeof( traceReturn ) );
// Send echo request, 2000 milliseconds maximum waiting time
pfnICMPSendEcho ( hIP, *dwIPAddr, 0, 0, &traceOptions, &traceReturn, sizeof(traceReturn), 2000 );
// Found requrested remote address, c contains the correct hopcount
if ( traceReturn.dwAddress == *dwIPAddr )
break;
}
/*
// This is how you do a raw ping
npings = 1;
pfnICMPSendEcho( hIP, *dwIPAddr, 0, 0, NULL, &E, sizeof( E ), 2000 );
*ping = (double)E.RoundTripTime / 1000.0;
*/
// Clean up file and dll handles
pfnICMPCloseFile( hIP );
::FreeLibrary( hICMP );
// Failure?
if ( c > nMaxHops )
{
return -1;
}
return c;
#else
return -1;
#endif
}
CMenu* CCementBD::SetModulesExtern()
{
if(gListModuleExternal.GetCount() == 0) return 0;
//---------------------------------------------------
//Формируем меню внешних модулей
CCementDoc* pDoc = (CCementDoc*)GetDocument();
HINSTANCE hInst = AfxGetResourceHandle();
pDoc->m_DefaultMenu =
::LoadMenu(AfxGetResourceHandle(), MAKEINTRESOURCE(IDR_KRSCEMENTTYPE));
if (pDoc->m_DefaultMenu == NULL)
return 0;
CMenu* menu = CMenu::FromHandle(pDoc->GetDefaultMenu());
if(menu)
{
int iPos;
CMenu* pPopup = NULL;
for(iPos = 0; iPos < (int)menu->GetMenuItemCount(); iPos++)
{
if(menu->GetSubMenu(iPos)->GetMenuItemID(0) == ID_NASTROIKA_MODULES)
{
pPopup = menu->GetSubMenu(iPos);
int ii = (int)pPopup->GetMenuItemCount();
break;
}
}
if(pPopup == NULL) return 0;
CMenu *submenu = menu->GetSubMenu(iPos);
if(submenu == NULL) return 0;
int ii = (int)submenu->GetMenuItemCount();
int cx = ::GetSystemMetrics(SM_CXMENUCHECK);
int cy = ::GetSystemMetrics(SM_CYMENUCHECK);
if(pPopup != NULL && gListModuleExternal.GetCount() > 0)
{
pPopup->AppendMenu(MF_SEPARATOR, 0, LPCTSTR(0));
for(int i = 0; i < gListModuleExternal.GetCount(); i++)
{
HICON hIconLarge, hIcon;
// ExtractIconEx(gListModuleExternal.GetName2(i), 0, &hIconLarge, &hIcon, 1);
CString Name2 = gListModuleExternal.GetName2txe(i);
if(Name2.GetLength() == 0) continue;
ExtractIconEx(Name2, 0, &hIconLarge, &hIcon, 1);
//HICON hIcon = ExtractIcon(pApp->m_hInstance, gListModuleExternal.GetName2(i), 0);
if(hIcon != NULL)
{
ICONINFO iconinfo;
GetIconInfo(hIcon, &iconinfo);
HANDLE hLoad = CopyImage(HANDLE(iconinfo.hbmColor), IMAGE_BITMAP, cx+1, cy+1, LR_COPYFROMRESOURCE);
CBitmap *pBmp = CBitmap::FromHandle(HBITMAP(hLoad));
CString str;
str.Format(" %d", i);
str += ". " + gListModuleExternal.GetName(i);
BOOL flg = pPopup->AppendMenu(MF_STRING | MF_ENABLED, ID_MENU_MODULE_EXTERNAL + i, str);
pPopup->SetMenuItemBitmaps(i+2, MF_BYPOSITION, pBmp, pBmp);
//BOOL res = menu->SetMenuItemBitmaps(2, MF_BYPOSITION, pBmp, pBmp);
//int zzz = 0;
}
}
}
CMDIFrameWnd* frame = ((CMDIChildWnd *) GetParent())->GetMDIFrame();
frame->MDISetMenu(menu, NULL);
frame->DrawMenuBar();
}
//-------------------------------------------------------------------------
return menu;
}
/*! destroy a hardware thread by its handle */
void destroyThread(thread_t tid) {
TerminateThread(HANDLE(tid),0);
CloseHandle(HANDLE(tid));
}
static PyObject *
Process_func_spawn(Process *self, PyObject *args, PyObject *kwargs)
{
int err, flags, len, stdio_count;
unsigned int uid, gid;
char *cwd, *cwd2, *file, *file2, *arg_str, *tmp_str, *key_str, *value_str;
char **ptr, **process_args, **process_env;
Py_ssize_t i, n, pos;
PyObject *key, *value, *item, *tmp, *callback, *arguments, *env, *stdio, *ret;
uv_process_options_t options;
uv_stdio_container_t *stdio_container;
static char *kwlist[] = {"file", "exit_callback", "args", "env", "cwd", "uid", "gid", "flags", "stdio", NULL};
cwd = NULL;
ptr = process_args = process_env = NULL;
tmp = arguments = env = stdio = NULL;
stdio_container = NULL;
flags = uid = gid = stdio_count = 0;
RAISE_IF_SPAWNED(self, NULL);
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|OOO!sIIiO:__init__", kwlist, &file, &callback, &arguments, &PyDict_Type, &env, &cwd, &uid, &gid, &flags, &stdio)) {
return NULL;
}
if (callback != Py_None && !PyCallable_Check(callback)) {
PyErr_SetString(PyExc_TypeError, "a callable is required");
return NULL;
}
if (arguments && !PySequence_Check(arguments)) {
PyErr_SetString(PyExc_TypeError, "only iterable objects are supported for 'args'");
return NULL;
}
if (stdio && !PySequence_Check(stdio)) {
PyErr_SetString(PyExc_TypeError, "only iterable objects are supported for 'stdio'");
return NULL;
}
memset(&options, 0, sizeof(uv_process_options_t));
options.uid = uid;
options.gid = gid;
options.flags = flags;
options.exit_cb = on_process_exit;
file2 = PyMem_Malloc(strlen(file) + 1);
if (!file2) {
PyErr_NoMemory();
ret = NULL;
goto cleanup;
}
strcpy(file2, file);
options.file = file2;
if (arguments) {
n = PySequence_Length(arguments);
process_args = PyMem_Malloc(sizeof *process_args * (n + 2));
if (!process_args) {
PyErr_NoMemory();
PyMem_Free(file2);
ret = NULL;
goto cleanup;
}
process_args[0] = file2;
i = 0;
while (i < n) {
item = PySequence_GetItem(arguments, i);
if (!item || !PyArg_Parse(item, "s;args contains a non-string value", &arg_str)) {
Py_XDECREF(item);
ret = NULL;
goto cleanup;
}
tmp_str = PyMem_Malloc(strlen(arg_str) + 1);
if (!tmp_str) {
Py_DECREF(item);
ret = NULL;
goto cleanup;
}
strcpy(tmp_str, arg_str);
process_args[i+1] = tmp_str;
Py_DECREF(item);
i++;
}
process_args[i+1] = NULL;
} else {
process_args = PyMem_Malloc(sizeof *process_args * 2);
if (!process_args) {
PyErr_NoMemory();
PyMem_Free(file2);
ret = NULL;
goto cleanup;
}
process_args[0] = file2;
process_args[1] = NULL;
}
options.args = process_args;
if (cwd) {
cwd2 = PyMem_Malloc(strlen(cwd) + 1);
if (!cwd2) {
PyErr_NoMemory();
ret = NULL;
goto cleanup;
}
strcpy(cwd2, cwd);
options.cwd = cwd2;
}
if (env) {
n = PyDict_Size(env);
if (n > 0) {
process_env = PyMem_Malloc(sizeof *process_env * (n + 1));
if (!process_env) {
PyErr_NoMemory();
ret = NULL;
goto cleanup;
}
i = 0;
pos = 0;
while (PyDict_Next(env, &pos, &key, &value)) {
if (!PyArg_Parse(key, "s;env contains a non-string key", &key_str) || !PyArg_Parse(value, "s;env contains a non-string value", &value_str)) {
ret = NULL;
goto cleanup;
}
len = strlen(key_str) + strlen(value_str) + 2;
tmp_str = PyMem_Malloc(len);
if (!tmp_str) {
PyErr_NoMemory();
ret = NULL;
goto cleanup;
}
PyOS_snprintf(tmp_str, len, "%s=%s", key_str, value_str);
process_env[i] = tmp_str;
i++;
}
process_env[i] = NULL;
}
}
options.env = process_env;
if (stdio) {
n = PySequence_Length(stdio);
stdio_container = PyMem_Malloc(sizeof *stdio_container * n);
if (!stdio_container) {
PyErr_NoMemory();
ret = NULL;
goto cleanup;
}
item = NULL;
for (i = 0;i < n; i++) {
item = PySequence_GetItem(stdio, i);
if (!item || !PyObject_TypeCheck(item, &StdIOType)) {
Py_XDECREF(item);
PyErr_SetString(PyExc_TypeError, "a StdIO instance is required");
ret = NULL;
goto cleanup;
}
stdio_count++;
stdio_container[i].flags = ((StdIO *)item)->flags;
if (((StdIO *)item)->flags & (UV_CREATE_PIPE | UV_INHERIT_STREAM)) {
stdio_container[i].data.stream = (uv_stream_t *)(UV_HANDLE(((StdIO *)item)->stream));
} else if (((StdIO *)item)->flags & UV_INHERIT_FD) {
stdio_container[i].data.fd = ((StdIO *)item)->fd;
}
Py_DECREF(item);
}
}
options.stdio = stdio_container;
options.stdio_count = stdio_count;
err = uv_spawn(UV_HANDLE_LOOP(self), &self->process_h, &options);
if (err < 0) {
RAISE_UV_EXCEPTION(err, PyExc_ProcessError);
ret = NULL;
goto cleanup;
}
tmp = (PyObject *)self->on_exit_cb;
Py_INCREF(callback);
self->on_exit_cb = callback;
Py_XDECREF(tmp);
tmp = self->stdio;
Py_XINCREF(stdio);
self->stdio = stdio;
Py_XDECREF(tmp);
HANDLE(self)->initialized = True;
self->spawned = True;
ret = Py_None;
/* Increase refcount so that object is not removed before the exit callback is called */
Py_INCREF(self);
cleanup:
if (options.args) {
for (ptr = options.args; *ptr != NULL; ptr++) {
PyMem_Free(*ptr);
}
}
if (options.env) {
for (ptr = options.env; *ptr != NULL; ptr++) {
PyMem_Free(*ptr);
}
}
PyMem_Free(options.args);
PyMem_Free(options.cwd);
PyMem_Free(options.env);
PyMem_Free(options.stdio);
Py_XINCREF(ret);
return ret;
}
static void
Process_tp_dealloc(Process *self)
{
HANDLE(self)->initialized = self->spawned;
HandleType.tp_dealloc((PyObject *)self);
}
/*! waits until the given thread has terminated */
void join(thread_t tid) {
WaitForSingleObject(HANDLE(tid), INFINITE);
CloseHandle(HANDLE(tid));
}
