int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, #ifdef UNDER_CE LPWSTR #else LPSTR #endif lpCmdLine, int nCmdShow) #endif { CFileInStream archiveStream; CLookToRead lookStream; CSzArEx db; SRes res = SZ_OK; ISzAlloc allocImp; ISzAlloc allocTempImp; WCHAR sfxPath[MAX_PATH + 2]; WCHAR path[MAX_PATH * 3 + 2]; size_t pathLen; DWORD winRes; const wchar_t *cmdLineParams; const char *errorMessage = NULL; Bool useShellExecute = True; #ifdef _CONSOLE SetConsoleCtrlHandler(HandlerRoutine, TRUE); #else hInstance = hInstance; hPrevInstance = hPrevInstance; lpCmdLine = lpCmdLine; nCmdShow = nCmdShow; #endif CrcGenerateTable(); allocImp.Alloc = SzAlloc; allocImp.Free = SzFree; allocTempImp.Alloc = SzAllocTemp; allocTempImp.Free = SzFreeTemp; FileInStream_CreateVTable(&archiveStream); LookToRead_CreateVTable(&lookStream, False); winRes = GetModuleFileNameW(NULL, sfxPath, MAX_PATH); if (winRes == 0 || winRes > MAX_PATH) return 1; { cmdLineParams = GetCommandLineW(); #ifndef UNDER_CE { Bool quoteMode = False; for (;; cmdLineParams++) { wchar_t c = *cmdLineParams; if (c == L'\"') quoteMode = !quoteMode; else if (c == 0 || (c == L' ' && !quoteMode)) break; } } #endif } { unsigned i; DWORD d; winRes = GetTempPathW(MAX_PATH, path); if (winRes == 0 || winRes > MAX_PATH) return 1; pathLen = wcslen(path); d = (GetTickCount() << 12) ^ (GetCurrentThreadId() << 14) ^ GetCurrentProcessId(); for (i = 0;; i++, d += GetTickCount()) { if (i >= 100) { res = SZ_ERROR_FAIL; break; } wcscpy(path + pathLen, L"7z"); { wchar_t *s = path + wcslen(path); UInt32 value = d; unsigned k; for (k = 0; k < 8; k++) { unsigned t = value & 0xF; value >>= 4; s[7 - k] = (char)((t < 10) ? ('0' + t) : ('A' + (t - 10))); } s[k] = '\0'; } if (DoesFileOrDirExist(path)) continue; if (CreateDirectoryW(path, NULL)) { wcscat(path, L"\\"); pathLen = wcslen(path); break; } if (GetLastError() != ERROR_ALREADY_EXISTS) { res = SZ_ERROR_FAIL; break; } } if (res != SZ_OK) errorMessage = "Can't create temp folder"; } if (res != SZ_OK) { if (!errorMessage) errorMessage = "Error"; PrintErrorMessage(errorMessage); return 1; } if (InFile_OpenW(&archiveStream.file, sfxPath) != 0) { errorMessage = "can not open input file"; res = SZ_ERROR_FAIL; } else { UInt64 pos = 0; if (!FindSignature(&archiveStream.file, &pos)) res = SZ_ERROR_FAIL; else if (File_Seek(&archiveStream.file, (Int64 *)&pos, SZ_SEEK_SET) != 0) res = SZ_ERROR_FAIL; if (res != 0) errorMessage = "Can't find 7z archive"; } if (res == SZ_OK) { lookStream.realStream = &archiveStream.s; LookToRead_Init(&lookStream); } SzArEx_Init(&db); if (res == SZ_OK) { res = SzArEx_Open(&db, &lookStream.s, &allocImp, &allocTempImp); } if (res == SZ_OK) { UInt32 executeFileIndex = (UInt32)(Int32)-1; UInt32 minPrice = 1 << 30; UInt32 i; UInt32 blockIndex = 0xFFFFFFFF; /* it can have any value before first call (if outBuffer = 0) */ Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */ size_t outBufferSize = 0; /* it can have any value before first call (if outBuffer = 0) */ for (i = 0; i < db.db.NumFiles; i++) { size_t offset = 0; size_t outSizeProcessed = 0; const CSzFileItem *f = db.db.Files + i; size_t len; WCHAR *temp; len = SzArEx_GetFileNameUtf16(&db, i, NULL); if (len >= MAX_PATH) { res = SZ_ERROR_FAIL; break; } temp = path + pathLen; SzArEx_GetFileNameUtf16(&db, i, temp); { res = SzArEx_Extract(&db, &lookStream.s, i, &blockIndex, &outBuffer, &outBufferSize, &offset, &outSizeProcessed, &allocImp, &allocTempImp); if (res != SZ_OK) break; } { CSzFile outFile; size_t processedSize; size_t j; size_t nameStartPos = 0; for (j = 0; temp[j] != 0; j++) { if (temp[j] == '/') { temp[j] = 0; MyCreateDir(path); temp[j] = CHAR_PATH_SEPARATOR; nameStartPos = j + 1; } } if (f->IsDir) { MyCreateDir(path); continue; } else { unsigned extLen; const WCHAR *name = temp + nameStartPos; unsigned len = (unsigned)wcslen(name); unsigned nameLen = FindExt(temp + nameStartPos, &extLen); unsigned extPrice = FindItem(kExts, sizeof(kExts) / sizeof(kExts[0]), name + len - extLen, extLen); unsigned namePrice = FindItem(kNames, sizeof(kNames) / sizeof(kNames[0]), name, nameLen); unsigned price = namePrice + extPrice * 64 + (nameStartPos == 0 ? 0 : (1 << 12)); if (minPrice > price) { minPrice = price; executeFileIndex = i; useShellExecute = (extPrice != k_EXE_ExtIndex); } if (DoesFileOrDirExist(path)) { errorMessage = "Duplicate file"; res = SZ_ERROR_FAIL; break; } if (OutFile_OpenW(&outFile, path)) { errorMessage = "Can't open output file"; res = SZ_ERROR_FAIL; break; } } processedSize = outSizeProcessed; if (File_Write(&outFile, outBuffer + offset, &processedSize) != 0 || processedSize != outSizeProcessed) { errorMessage = "Can't write output file"; res = SZ_ERROR_FAIL; } #ifdef USE_WINDOWS_FILE if (f->MTimeDefined) { FILETIME mTime; mTime.dwLowDateTime = f->MTime.Low; mTime.dwHighDateTime = f->MTime.High; SetFileTime(outFile.handle, NULL, NULL, &mTime); } #endif { SRes res2 = File_Close(&outFile); if (res != SZ_OK) break; if (res2 != SZ_OK) { res = res2; break; } } #ifdef USE_WINDOWS_FILE if (f->AttribDefined) SetFileAttributesW(path, f->Attrib); #endif } } if (res == SZ_OK) { if (executeFileIndex == (UInt32)(Int32)-1) { errorMessage = "There is no file to execute"; res = SZ_ERROR_FAIL; } else { WCHAR *temp = path + pathLen; UInt32 j; SzArEx_GetFileNameUtf16(&db, executeFileIndex, temp); for (j = 0; temp[j] != 0; j++) if (temp[j] == '/') temp[j] = CHAR_PATH_SEPARATOR; } } IAlloc_Free(&allocImp, outBuffer); } SzArEx_Free(&db, &allocImp); File_Close(&archiveStream.file); if (res == SZ_OK) { HANDLE hProcess = 0; if (useShellExecute) { SHELLEXECUTEINFO ei; UINT32 executeRes; BOOL success; memset(&ei, 0, sizeof(ei)); ei.cbSize = sizeof(ei); ei.lpFile = path; ei.fMask = SEE_MASK_NOCLOSEPROCESS #ifndef UNDER_CE | SEE_MASK_FLAG_DDEWAIT #endif /* | SEE_MASK_NO_CONSOLE */ ; if (wcslen(cmdLineParams) != 0) ei.lpParameters = cmdLineParams; ei.nShow = SW_SHOWNORMAL; /* SW_HIDE; */ success = ShellExecuteEx(&ei); executeRes = (UINT32)(UINT_PTR)ei.hInstApp; if (!success || (executeRes <= 32 && executeRes != 0)) /* executeRes = 0 in Windows CE */ res = SZ_ERROR_FAIL; else hProcess = ei.hProcess; } else { STARTUPINFOW si; PROCESS_INFORMATION pi; WCHAR cmdLine[MAX_PATH * 3]; wcscpy(cmdLine, path); wcscat(cmdLine, cmdLineParams); memset(&si, 0, sizeof(si)); si.cb = sizeof(si); if (CreateProcessW(NULL, cmdLine, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi) == 0) res = SZ_ERROR_FAIL; else { CloseHandle(pi.hThread); hProcess = pi.hProcess; } } if (hProcess != 0) { WaitForSingleObject(hProcess, INFINITE); CloseHandle(hProcess); } } path[pathLen] = L'\0'; RemoveDirWithSubItems(path); if (res == SZ_OK) return 0; { if (res == SZ_ERROR_UNSUPPORTED) errorMessage = "Decoder doesn't support this archive"; else if (res == SZ_ERROR_MEM) errorMessage = "Can't allocate required memory"; else if (res == SZ_ERROR_CRC) errorMessage = "CRC error"; else { if (!errorMessage) errorMessage = "ERROR"; } if (errorMessage) PrintErrorMessage(errorMessage); } return 1; }
VOID SuspendedProcessTest ( VOID ) { PERFINFO PerfInfo; STARTUPINFO si; PROCESS_INFORMATION pi[SPD_PROCESS_ITERATIONS]; BOOL b; int Index; CHAR Buffer[256]; KPRIORITY Base; GetModuleFileName(0,Buffer,256); RtlZeroMemory(&si,sizeof(si)); si.cb = sizeof(si); Base = 13; NtSetInformationProcess( NtCurrentProcess(), ProcessBasePriority, (PVOID) &Base, sizeof(Base) ); // SetPriorityClass(GetCurrentProcess(),HIGH_PRIORITY_CLASS); StartBenchMark("Suspended Process Creation Benchmark)", SPD_PROCESS_ITERATIONS, &PerfInfo); for (Index = 0; Index < SPD_PROCESS_ITERATIONS; Index += 1) { b = CreateProcess( Buffer, "just exit", NULL, NULL, TRUE, CREATE_SUSPENDED, NULL, NULL, &si, &pi[Index] ); if ( !b ) { printf("failed %ld\n",Index); } } // // Print out performance statistics. // FinishBenchMark(&PerfInfo); // SetPriorityClass(GetCurrentProcess(),NORMAL_PRIORITY_CLASS); StartBenchMark("Process Startup/Exit Benchmark)", SPD_PROCESS_ITERATIONS, &PerfInfo); for (Index = 0; Index < SPD_PROCESS_ITERATIONS; Index += 1) { ResumeThread(pi[Index].hThread); CloseHandle(pi[Index].hThread); WaitForSingleObject(pi[Index].hProcess,-1); CloseHandle(pi[Index].hProcess); } FinishBenchMark(&PerfInfo); // // End of event1 context switch test. // return; }
void CDAudio_WaitForFinish(void) { WaitForSingleObject(cdPlayingFinishedEvent, INFINITE); }
// This routine creates a binding with the server. HRESULT JITManager::CreateBinding( __in HANDLE serverProcessHandle, __in_opt void * serverSecurityDescriptor, __in UUID * connectionUuid, __out RPC_BINDING_HANDLE * bindingHandle) { Assert(IsOOPJITEnabled()); RPC_STATUS status; DWORD attemptCount = 0; DWORD sleepInterval = 100; // in milliseconds RPC_BINDING_HANDLE localBindingHandle; RPC_BINDING_HANDLE_TEMPLATE_V1 bindingTemplate; RPC_BINDING_HANDLE_SECURITY_V1_W bindingSecurity; #ifndef NTBUILD RPC_SECURITY_QOS_V4 securityQOS; ZeroMemory(&securityQOS, sizeof(RPC_SECURITY_QOS_V4)); securityQOS.Capabilities = RPC_C_QOS_CAPABILITIES_DEFAULT; securityQOS.IdentityTracking = RPC_C_QOS_IDENTITY_DYNAMIC; securityQOS.ImpersonationType = RPC_C_IMP_LEVEL_IDENTIFY; securityQOS.Version = 4; #else RPC_SECURITY_QOS_V5 securityQOS; ZeroMemory(&securityQOS, sizeof(RPC_SECURITY_QOS_V5)); securityQOS.Capabilities = RPC_C_QOS_CAPABILITIES_DEFAULT; securityQOS.IdentityTracking = RPC_C_QOS_IDENTITY_DYNAMIC; securityQOS.ImpersonationType = RPC_C_IMP_LEVEL_IDENTIFY; securityQOS.Version = 5; securityQOS.ServerSecurityDescriptor = serverSecurityDescriptor; #endif // NTBUILD ZeroMemory(&bindingTemplate, sizeof(bindingTemplate)); bindingTemplate.Version = 1; bindingTemplate.ProtocolSequence = RPC_PROTSEQ_LRPC; bindingTemplate.StringEndpoint = NULL; memcpy_s(&bindingTemplate.ObjectUuid, sizeof(UUID), connectionUuid, sizeof(UUID)); bindingTemplate.Flags |= RPC_BHT_OBJECT_UUID_VALID; ZeroMemory(&bindingSecurity, sizeof(bindingSecurity)); bindingSecurity.Version = 1; bindingSecurity.AuthnLevel = RPC_C_AUTHN_LEVEL_PKT_PRIVACY; bindingSecurity.AuthnSvc = RPC_C_AUTHN_KERNEL; bindingSecurity.SecurityQos = (RPC_SECURITY_QOS*)&securityQOS; status = RpcBindingCreate(&bindingTemplate, &bindingSecurity, NULL, &localBindingHandle); if (status != RPC_S_OK) { return HRESULT_FROM_WIN32(status); } // We keep attempting to connect to the server with increasing wait intervals in between. // This will wait close to 5 minutes before it finally gives up. do { DWORD waitStatus; status = RpcBindingBind(NULL, localBindingHandle, ClientIChakraJIT_v0_0_c_ifspec); if (status == RPC_S_OK) { break; } else if (status == EPT_S_NOT_REGISTERED) { // The Server side has not finished registering the RPC Server yet. // We should only breakout if we have reached the max attempt count. if (attemptCount > 600) { break; } } else { // Some unknown error occurred. We are not going to retry for arbitrary errors. break; } // When we come to this point, it means the server has not finished registration yet. // We should wait for a while and then reattempt to bind. waitStatus = WaitForSingleObject(serverProcessHandle, sleepInterval); if (waitStatus == WAIT_OBJECT_0) { DWORD exitCode = (DWORD)-1; // The server process died for some reason. No need to reattempt. // We use -1 as the exit code if GetExitCodeProcess fails. Assert(GetExitCodeProcess(serverProcessHandle, &exitCode)); status = RPC_S_SERVER_UNAVAILABLE; break; } else if (waitStatus == WAIT_TIMEOUT) { // Not an error. the server is still alive and we should reattempt. } else { // wait operation failed for an unknown reason. Assert(false); status = HRESULT_FROM_WIN32(waitStatus); break; } attemptCount++; if (sleepInterval < 500) { sleepInterval += 100; } } while (status != RPC_S_OK); // redundant check, but compiler would not allow true here. if (status != RPC_S_OK) { RpcBindingFree(&localBindingHandle); return HRESULT_FROM_WIN32(status); } *bindingHandle = localBindingHandle; return S_OK; }
void ThreadObject::WaitForExit() { WaitForSingleObject(m_hThread, INFINITE); CloseHandle(m_hThread); }
// Loads a dll in a process (uses ntdll.LdrLoadData) DWORD LoadDllInProcessEx(DWORD dwPid,char* DllPathName) { HANDLE hProcess,hThread; RemoteProcessData rpd; PWSTR pwModuleFileName; HANDLE hModule=NULL; UNICODE_STRING usModule; LPVOID lpParameters,lpThread; SECURITY_ATTRIBUTES saSecAttr; DWORD dwActual,dwResult=0,rc; hProcess=OpenProcess(PROCESS_ALL_ACCESS,0,dwPid); if (hProcess==NULL) goto cleanup; rpd.pLdrLoadDll=(LDRLOADDLL)GetProcAddress(GetModuleHandle("ntdll"),"LdrLoadDll"); if (!rpd.pLdrLoadDll) goto cleanup; rpd.Flags=0; rpd.PathToFile=NULL; rpd.ModuleHandle=NULL; pwModuleFileName=(PWSTR)malloc((strlen(DllPathName)*2)+1); if (!pwModuleFileName) goto cleanup; MultiByteToWideChar(CP_ACP,0,DllPathName,strlen(DllPathName),pwModuleFileName,(strlen(DllPathName)*2)+1); usModule.Buffer=(PWSTR)InjectData(hProcess,pwModuleFileName,(strlen(DllPathName)*2)+1); free(pwModuleFileName); if (!usModule.Buffer) goto cleanup; usModule.Length=(strlen(DllPathName)*2)+1; usModule.MaximumLength=(strlen(DllPathName)*2)+1; memcpy(&rpd.ModuleFileName,&usModule,sizeof(UNICODE_STRING)); lpParameters=InjectData(hProcess,&rpd,sizeof(RemoteProcessData)+4096); if (!lpParameters) goto cleanup; lpThread=InjectData(hProcess,&RemoteThread,(PBYTE)EndRemoteThread-(PBYTE)RemoteThread+4096); if (!lpThread) goto cleanup; // Set security attributes saSecAttr.nLength=sizeof(SECURITY_ATTRIBUTES); saSecAttr.lpSecurityDescriptor = NULL; saSecAttr.bInheritHandle = TRUE; hThread=CreateRemoteThread(hProcess,&saSecAttr,0,(LPTHREAD_START_ROUTINE)lpThread,lpParameters,0,&dwActual); if (hThread==NULL) goto cleanup; rc=WaitForSingleObject(hThread, INFINITE); switch (rc) { case WAIT_TIMEOUT: break; case WAIT_FAILED: break; case WAIT_OBJECT_0: if (ReadProcessMemory(hProcess,lpParameters,&rpd,sizeof(RemoteProcessData),&dwActual)) dwResult=(DWORD)rpd.ModuleHandle; break; default: break; } cleanup: if (rpd.ModuleFileName.Buffer!=NULL) VirtualFreeEx(hProcess,rpd.ModuleFileName.Buffer,0,MEM_RELEASE); if (lpParameters!=NULL) VirtualFreeEx(hProcess,lpParameters,0,MEM_RELEASE); if (lpThread!=NULL) VirtualFreeEx(hProcess,lpThread,0,MEM_RELEASE); if (hThread) CloseHandle(hThread); if (hProcess) CloseHandle(hProcess); return dwResult; }
void gcore::Mutex::lock() { WaitForSingleObject(MUTEX, INFINITE); }
void CPutFile::CheckExe(wstring installname, wstring name, int type) { if(type == 2)//file { WCHAR path[MAX_PATH] = {0}; ExpandEnvironmentStringsW(installname.c_str(), path, MAX_PATH); if(::PathFileExistsW(path) == TRUE) return; } else if(type == 1)//reg { HKEY rootkey; size_t nEndKeyName = installname.find_first_of(']', 1); std::wstring strKeyName = installname.substr(1, nEndKeyName - 1); size_t nEnd = strKeyName.find_first_of('\\'); std::wstring strRootKey = strKeyName.substr(0, nEnd); if(strRootKey == L"HKEY_CURRENT_USER") rootkey = HKEY_CURRENT_USER; else if (strRootKey == _T("HKEY_LOCAL_MACHINE")) rootkey = HKEY_LOCAL_MACHINE; else if(strRootKey == _T("HKEY_CLASSES_ROOT")) rootkey = HKEY_CLASSES_ROOT; std::wstring strKey = strKeyName.substr(nEnd + 1, wstring::npos); HKEY hKey = NULL; // 操作键句柄 if (ERROR_SUCCESS == ::RegOpenKeyExW(rootkey, strKey.c_str(), 0, KEY_READ, &hKey)) { ::RegCloseKey(hKey); return; } } else return; wstring file = CResourceManager::_()->GetFilePath(m_pWebsiteData->GetWebsiteType(), m_pWebsiteData->GetID(), name.c_str()); OSVERSIONINFO os = { sizeof(OSVERSIONINFO) }; ::GetVersionEx(&os); if(os.dwMajorVersion >= 6) { SHELLEXECUTEINFOW shExecInfo; shExecInfo.cbSize = sizeof(SHELLEXECUTEINFO); shExecInfo.fMask = SEE_MASK_NOCLOSEPROCESS;//SEE_MASK_NOCLOSEPROCESS | SEE_MASK_FLAG_NO_UI; shExecInfo.hwnd = NULL; shExecInfo.lpVerb = L"runas"; shExecInfo.lpFile = LPWSTR(file.c_str()); shExecInfo.lpParameters = NULL; shExecInfo.lpDirectory = NULL; shExecInfo.nShow = SW_SHOWNORMAL; shExecInfo.hInstApp = NULL; if (!ShellExecuteExW(&shExecInfo)) { int err = GetLastError(); CRecordProgram::GetInstance()->FeedbackError(L"PutFile", err, CRecordProgram::GetInstance()->GetRecordInfo(L"CPutFile创建安装进程%s失败!", file.c_str())); } else WaitForSingleObject (shExecInfo.hProcess, INFINITE); } else { STARTUPINFOW si; memset (&si, 0, sizeof (STARTUPINFOW)); si.wShowWindow = SW_HIDE; si.cb = sizeof (STARTUPINFOW); PROCESS_INFORMATION pi; memset (&pi, 0, sizeof (PROCESS_INFORMATION)); if (!CreateProcess(NULL, LPWSTR(file.c_str()), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) { CRecordProgram::GetInstance()->FeedbackError(L"PutFile", 1200, CRecordProgram::GetInstance()->GetRecordInfo(L"CPutFile创建安装进程%s失败!", file.c_str())); return; } else WaitForSingleObject (pi.hProcess, INFINITE); CloseHandle (pi.hThread); CloseHandle (pi.hProcess); } return; }
/*! \internal \note Obtains ::cs_kmq_global, kmq_queue::cs, ::cs_kmq_msg_ref, ::cs_kmq_msg, */ KHMEXP khm_int32 KHMAPI kmq_dispatch(kmq_timer timeout) { kmq_queue * q; kmq_message_ref * r; kmq_message *m; DWORD hr; q = kmqint_get_thread_queue(); assert(q->wait_o); hr = WaitForSingleObject(q->wait_o, timeout); if(hr == WAIT_OBJECT_0) { /* signalled */ kmqint_get_queue_message_ref(q, &r); m = r->msg; if(m->type != KMSG_SYSTEM || m->subtype != KMSG_SYSTEM_EXIT) { khm_boolean rv; if (m->err_ctx) kherr_push_context(m->err_ctx); /* TODO: before dispatching the message, the message being dispatched for this thread needs to be stored so that it can be looked up in kmq_is_call_aborted(). This needs to happen in kmq_wm_dispatch() and kmq_wm_begin() as well. */ /* dispatch */ rv = r->recipient(m->type, m->subtype, m->uparam, m->vparam); if (m->err_ctx) kherr_pop_context(); EnterCriticalSection(&cs_kmq_msg); EnterCriticalSection(&cs_kmq_msg_ref); kmqint_put_message_ref(r); LeaveCriticalSection(&cs_kmq_msg_ref); if(KHM_SUCCEEDED(rv)) m->nCompleted++; else m->nFailed++; if(m->nCompleted + m->nFailed == m->nSent) { kmqint_put_message(m); } LeaveCriticalSection(&cs_kmq_msg); return KHM_ERROR_SUCCESS; } else { EnterCriticalSection(&cs_kmq_msg); EnterCriticalSection(&cs_kmq_msg_ref); kmqint_put_message_ref(r); LeaveCriticalSection(&cs_kmq_msg_ref); m->nCompleted++; if(m->nCompleted + m->nFailed == m->nSent) { kmqint_put_message(m); } LeaveCriticalSection(&cs_kmq_msg); return KHM_ERROR_EXIT; } } else { return KHM_ERROR_TIMEOUT; } }
// Thread that gets and sends CPU usage static DWORD WINAPI mainThread(LPVOID args) { UNREFERENCED_PARAMETER(args); bool usbOk = true; byte checkCounter = 0; byte pokeCounter = 0; while(1) { // If exit event is set then exit thread, otherwise wait for timeout and do the usual CPU stuff if(WaitForSingleObject(hThreadExitEvent, SAMPLERATE) != WAIT_TIMEOUT) break; // Get usage byte cpuUsage = getCPUUsage(); EnterCriticalSection(&cs); // Store sample sample.samples[sample.idx++] = cpuUsage; if(sample.idx >= sample.count) sample.idx = 0; // Get average uint avg = 0; for(uint i=0;i<sample.count;i++) avg += sample.samples[i]; avg /= sample.count; LeaveCriticalSection(&cs); cpuUsage = (byte)avg; // Show CPU usage actions_showCPULoad(cpuUsage); // Constantly searching for USB devices takes up a lot of CPU time, // so here we only check for new device every so often. if(!usbOk) { if(++checkCounter < (USB_CHECK_INTERVAL / SAMPLERATE)) continue; checkCounter = 0; } // Send to USB if((usbOk = checkDevice(usbOk))) { if(device_get()->ledMode == MODE_CPU_USAGE) { // Workout colour s_rgbVal colour; getCPUColour(cpuUsage, &colour); // Send colour usbOk = device_setColour(&colour); } else { // Just send pokes if not in CPU usage mode, // this sees if the device is still connected if(++pokeCounter >= (USB_POKE_INTERVAL / SAMPLERATE)) { pokeCounter = 0; usbOk = device_poke(); } } } } return EXIT_SUCCESS; }
bool gcore::Mutex::tryLock() { return (WaitForSingleObject(MUTEX, 0) == WAIT_OBJECT_0); }
int main(void) { struct sockaddr_in sin_s, sin_c; struct sockaddr_conn sconn; #ifdef _WIN32 SOCKET fd_c, fd_s; #else int fd_c, fd_s; #endif struct socket *s_c, *s_s, *s_l; #ifdef _WIN32 HANDLE tid_c, tid_s; #else pthread_t tid_c, tid_s; #endif int cur_buf_size, snd_buf_size, rcv_buf_size; socklen_t opt_len; struct sctp_sndinfo sndinfo; char *line; #ifdef _WIN32 WSADATA wsaData; #endif #ifdef _WIN32 if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0) { printf("WSAStartup failed\n"); exit (EXIT_FAILURE); } #endif usrsctp_init(0, conn_output, debug_printf); /* set up a connected UDP socket */ #ifdef _WIN32 if ((fd_c = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET) { printf("socket() failed with error: %ld\n", WSAGetLastError()); exit(EXIT_FAILURE); } if ((fd_s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET) { printf("socket() failed with error: %ld\n", WSAGetLastError()); exit(EXIT_FAILURE); } #else if ((fd_c = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { perror("socket"); exit(EXIT_FAILURE); } if ((fd_s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { perror("socket"); exit(EXIT_FAILURE); } #endif memset(&sin_c, 0, sizeof(struct sockaddr_in)); sin_c.sin_family = AF_INET; #ifdef HAVE_SIN_LEN sin_c.sin_len = sizeof(struct sockaddr_in); #endif sin_c.sin_port = htons(9900); sin_c.sin_addr.s_addr = htonl(INADDR_LOOPBACK); memset(&sin_s, 0, sizeof(struct sockaddr_in)); sin_s.sin_family = AF_INET; #ifdef HAVE_SIN_LEN sin_s.sin_len = sizeof(struct sockaddr_in); #endif sin_s.sin_port = htons(9899); sin_s.sin_addr.s_addr = htonl(INADDR_LOOPBACK); #ifdef _WIN32 if (bind(fd_c, (struct sockaddr *)&sin_c, sizeof(struct sockaddr_in)) == SOCKET_ERROR) { printf("bind() failed with error: %ld\n", WSAGetLastError()); exit(EXIT_FAILURE); } if (bind(fd_s, (struct sockaddr *)&sin_s, sizeof(struct sockaddr_in)) == SOCKET_ERROR) { printf("bind() failed with error: %ld\n", WSAGetLastError()); exit(EXIT_FAILURE); } #else if (bind(fd_c, (struct sockaddr *)&sin_c, sizeof(struct sockaddr_in)) < 0) { perror("bind"); exit(EXIT_FAILURE); } if (bind(fd_s, (struct sockaddr *)&sin_s, sizeof(struct sockaddr_in)) < 0) { perror("bind"); exit(EXIT_FAILURE); } #endif #ifdef _WIN32 if (connect(fd_c, (struct sockaddr *)&sin_s, sizeof(struct sockaddr_in)) == SOCKET_ERROR) { printf("connect() failed with error: %ld\n", WSAGetLastError()); exit(EXIT_FAILURE); } if (connect(fd_s, (struct sockaddr *)&sin_c, sizeof(struct sockaddr_in)) == SOCKET_ERROR) { printf("connect() failed with error: %ld\n", WSAGetLastError()); exit(EXIT_FAILURE); } #else if (connect(fd_c, (struct sockaddr *)&sin_s, sizeof(struct sockaddr_in)) < 0) { perror("connect"); exit(EXIT_FAILURE); } if (connect(fd_s, (struct sockaddr *)&sin_c, sizeof(struct sockaddr_in)) < 0) { perror("connect"); exit(EXIT_FAILURE); } #endif #ifdef _WIN32 tid_c = CreateThread(NULL, 0, &handle_packets, (void *)&fd_c, 0, NULL); tid_s = CreateThread(NULL, 0, &handle_packets, (void *)&fd_s, 0, NULL); #else if (pthread_create(&tid_c, NULL, &handle_packets, (void *)&fd_c)) { perror("pthread_create tid_c"); exit(EXIT_FAILURE); } if (pthread_create(&tid_s, NULL, &handle_packets, (void *)&fd_s)) { perror("pthread_create tid_s"); exit(EXIT_FAILURE); }; #endif #ifdef SCTP_DEBUG usrsctp_sysctl_set_sctp_debug_on(SCTP_DEBUG_NONE); #endif usrsctp_sysctl_set_sctp_ecn_enable(0); usrsctp_register_address((void *)&fd_c); usrsctp_register_address((void *)&fd_s); if ((s_c = usrsctp_socket(AF_CONN, SOCK_STREAM, IPPROTO_SCTP, receive_cb, NULL, 0, &fd_c)) == NULL) { perror("usrsctp_socket"); exit(EXIT_FAILURE); } opt_len = (socklen_t)sizeof(int); cur_buf_size = 0; if (usrsctp_getsockopt(s_c, SOL_SOCKET, SO_SNDBUF, &cur_buf_size, &opt_len) < 0) { perror("usrsctp_getsockopt"); exit(EXIT_FAILURE); } printf("Change send socket buffer size from %d ", cur_buf_size); snd_buf_size = 1<<20; /* 1 MB */ if (usrsctp_setsockopt(s_c, SOL_SOCKET, SO_SNDBUF, &snd_buf_size, sizeof(int)) < 0) { perror("usrsctp_setsockopt"); exit(EXIT_FAILURE); } opt_len = (socklen_t)sizeof(int); cur_buf_size = 0; if (usrsctp_getsockopt(s_c, SOL_SOCKET, SO_SNDBUF, &cur_buf_size, &opt_len) < 0) { perror("usrsctp_getsockopt"); exit(EXIT_FAILURE); } printf("to %d.\n", cur_buf_size); if ((s_l = usrsctp_socket(AF_CONN, SOCK_STREAM, IPPROTO_SCTP, receive_cb, NULL, 0, &fd_s)) == NULL) { perror("usrsctp_socket"); exit(EXIT_FAILURE); } opt_len = (socklen_t)sizeof(int); cur_buf_size = 0; if (usrsctp_getsockopt(s_l, SOL_SOCKET, SO_RCVBUF, &cur_buf_size, &opt_len) < 0) { perror("usrsctp_getsockopt"); exit(EXIT_FAILURE); } printf("Change receive socket buffer size from %d ", cur_buf_size); rcv_buf_size = 1<<16; /* 64 KB */ if (usrsctp_setsockopt(s_l, SOL_SOCKET, SO_RCVBUF, &rcv_buf_size, sizeof(int)) < 0) { perror("usrsctp_setsockopt"); exit(EXIT_FAILURE); } opt_len = (socklen_t)sizeof(int); cur_buf_size = 0; if (usrsctp_getsockopt(s_l, SOL_SOCKET, SO_RCVBUF, &cur_buf_size, &opt_len) < 0) { perror("usrsctp_getsockopt"); exit(EXIT_FAILURE); } printf("to %d.\n", cur_buf_size); /* Bind the client side. */ memset(&sconn, 0, sizeof(struct sockaddr_conn)); sconn.sconn_family = AF_CONN; #ifdef HAVE_SCONN_LEN sconn.sconn_len = sizeof(struct sockaddr_conn); #endif sconn.sconn_port = htons(5001); sconn.sconn_addr = &fd_c; if (usrsctp_bind(s_c, (struct sockaddr *)&sconn, sizeof(struct sockaddr_conn)) < 0) { perror("usrsctp_bind"); exit(EXIT_FAILURE); } /* Bind the server side. */ memset(&sconn, 0, sizeof(struct sockaddr_conn)); sconn.sconn_family = AF_CONN; #ifdef HAVE_SCONN_LEN sconn.sconn_len = sizeof(struct sockaddr_conn); #endif sconn.sconn_port = htons(5001); sconn.sconn_addr = &fd_s; if (usrsctp_bind(s_l, (struct sockaddr *)&sconn, sizeof(struct sockaddr_conn)) < 0) { perror("usrsctp_bind"); exit(EXIT_FAILURE); } /* Make server side passive... */ if (usrsctp_listen(s_l, 1) < 0) { perror("usrsctp_listen"); exit(EXIT_FAILURE); } /* Initiate the handshake */ memset(&sconn, 0, sizeof(struct sockaddr_conn)); sconn.sconn_family = AF_CONN; #ifdef HAVE_SCONN_LEN sconn.sconn_len = sizeof(struct sockaddr_conn); #endif sconn.sconn_port = htons(5001); sconn.sconn_addr = &fd_c; if (usrsctp_connect(s_c, (struct sockaddr *)&sconn, sizeof(struct sockaddr_conn)) < 0) { perror("usrsctp_connect"); exit(EXIT_FAILURE); } if ((s_s = usrsctp_accept(s_l, NULL, NULL)) == NULL) { perror("usrsctp_accept"); exit(EXIT_FAILURE); } usrsctp_close(s_l); if ((line = malloc(LINE_LENGTH)) == NULL) { exit(EXIT_FAILURE); } memset(line, 'A', LINE_LENGTH); sndinfo.snd_sid = 1; sndinfo.snd_flags = 0; sndinfo.snd_ppid = htonl(DISCARD_PPID); sndinfo.snd_context = 0; sndinfo.snd_assoc_id = 0; /* Send a 1 MB message */ if (usrsctp_sendv(s_c, line, LINE_LENGTH, NULL, 0, (void *)&sndinfo, (socklen_t)sizeof(struct sctp_sndinfo), SCTP_SENDV_SNDINFO, 0) < 0) { perror("usrsctp_sendv"); exit(EXIT_FAILURE); } free(line); usrsctp_shutdown(s_c, SHUT_WR); while (usrsctp_finish() != 0) { #ifdef _WIN32 Sleep(1000); #else sleep(1); #endif } #ifdef _WIN32 TerminateThread(tid_c, 0); WaitForSingleObject(tid_c, INFINITE); TerminateThread(tid_s, 0); WaitForSingleObject(tid_s, INFINITE); if (closesocket(fd_c) == SOCKET_ERROR) { printf("closesocket() failed with error: %ld\n", WSAGetLastError()); exit(EXIT_FAILURE); } if (closesocket(fd_s) == SOCKET_ERROR) { printf("closesocket() failed with error: %ld\n", WSAGetLastError()); exit(EXIT_FAILURE); } WSACleanup(); #else pthread_cancel(tid_c); pthread_join(tid_c, NULL); pthread_cancel(tid_s); pthread_join(tid_s, NULL); if (close(fd_c) < 0) { perror("close"); exit(EXIT_FAILURE); } if (close(fd_s) < 0) { perror("close"); exit(EXIT_FAILURE); } #endif return (0); }
bool gcore::Semaphore::tryDecrement() { return (WaitForSingleObject((HANDLE)mData, 0) == WAIT_OBJECT_0); }
int main() { DWORD dwRead, dwWrite; char *cmdLine; HANDLE hStdInput, hStdOutput, hStdError; HANDLE hFileInput, hFileOutput, hFileError; STARTUPINFO si; PROCESS_INFORMATION pi; char buf[8192]; DWORD result; hFileInput = INVALID_HANDLE_VALUE; hFileOutput = INVALID_HANDLE_VALUE; hFileError = INVALID_HANDLE_VALUE; result = 1; /* * Don't get command line from argc, argv, because the command line * tokenizer will have stripped off all the escape sequences needed * for quotes and backslashes, and then we'd have to put them all * back in again. Get the raw command line and parse off what we * want ourselves. The command line should be of the form: * * stub16.exe program arg1 arg2 ... */ cmdLine = strchr(GetCommandLine(), ' '); if (cmdLine == NULL) { return 1; } cmdLine++; hStdInput = GetStdHandle(STD_INPUT_HANDLE); hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE); hStdError = GetStdHandle(STD_ERROR_HANDLE); if (GetFileType(hStdInput) == FILE_TYPE_PIPE) { hFileInput = CreateTempFile(); if (hFileInput == INVALID_HANDLE_VALUE) { goto cleanup; } while (ReadFile(hStdInput, buf, sizeof(buf), &dwRead, NULL) != FALSE) { if (dwRead == 0) { break; } if (WriteFile(hFileInput, buf, dwRead, &dwWrite, NULL) == FALSE) { goto cleanup; } } SetFilePointer(hFileInput, 0, 0, FILE_BEGIN); SetStdHandle(STD_INPUT_HANDLE, hFileInput); } if (GetFileType(hStdOutput) == FILE_TYPE_PIPE) { hFileOutput = CreateTempFile(); if (hFileOutput == INVALID_HANDLE_VALUE) { goto cleanup; } SetStdHandle(STD_OUTPUT_HANDLE, hFileOutput); } if (GetFileType(hStdError) == FILE_TYPE_PIPE) { hFileError = CreateTempFile(); if (hFileError == INVALID_HANDLE_VALUE) { goto cleanup; } SetStdHandle(STD_ERROR_HANDLE, hFileError); } ZeroMemory(&si, sizeof(si)); si.cb = sizeof(si); if (CreateProcess(NULL, cmdLine, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi) == FALSE) { goto cleanup; } WaitForInputIdle(pi.hProcess, 5000); WaitForSingleObject(pi.hProcess, INFINITE); GetExitCodeProcess(pi.hProcess, &result); CloseHandle(pi.hProcess); CloseHandle(pi.hThread); if (hFileOutput != INVALID_HANDLE_VALUE) { SetFilePointer(hFileOutput, 0, 0, FILE_BEGIN); while (ReadFile(hFileOutput, buf, sizeof(buf), &dwRead, NULL) != FALSE) { if (dwRead == 0) { break; } if (WriteFile(hStdOutput, buf, dwRead, &dwWrite, NULL) == FALSE) { break; } } } if (hFileError != INVALID_HANDLE_VALUE) { SetFilePointer(hFileError, 0, 0, FILE_BEGIN); while (ReadFile(hFileError, buf, sizeof(buf), &dwRead, NULL) != FALSE) { if (dwRead == 0) { break; } if (WriteFile(hStdError, buf, dwRead, &dwWrite, NULL) == FALSE) { break; } } } cleanup: if (hFileInput != INVALID_HANDLE_VALUE) { CloseHandle(hFileInput); } if (hFileOutput != INVALID_HANDLE_VALUE) { CloseHandle(hFileOutput); } if (hFileError != INVALID_HANDLE_VALUE) { CloseHandle(hFileError); } CloseHandle(hStdInput); CloseHandle(hStdOutput); CloseHandle(hStdError); ExitProcess(result); return 1; }
void gcore::Semaphore::decrement() { WaitForSingleObject((HANDLE)mData,INFINITE); }
bool gcore::Semaphore::timedDecrement(unsigned long ms) { return (WaitForSingleObject((HANDLE)mData, ms) == WAIT_OBJECT_0); }
DWORD WINAPI SimpleThreadHandler(PVOID pvParam) { WaitForSingleObject((HANDLE) pvParam, INFINITE); return(0); }
DWORD WINAPI FileWatcherThread::run_thread( void *_watcher ) { FileWatcherThread *watcher = (FileWatcherThread*)_watcher; while(watcher->running) { ReadDirectoryChangesW( watcher->handle, watcher->buffer, watcher->buffer_size, TRUE, FILE_NOTIFY_CHANGE_CREATION | FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE, NULL, &watcher->overlap, NULL ); WaitForSingleObject(watcher->overlap.hEvent, INFINITE); int seek = 0; while(seek < watcher->buffer_size) { PFILE_NOTIFY_INFORMATION notifier = PFILE_NOTIFY_INFORMATION(watcher->buffer + seek); WCHAR szwFileName[MAX_PATH]; int ulCount = notifier->FileNameLength/2; wcsncpy(szwFileName, notifier->FileName, ulCount); szwFileName[ulCount] = L'\0'; std::wstring widepath(szwFileName); std::string path(widepath.begin(), widepath.end()); FilewatchEventType _event_type = fe_unknown; switch( notifier->Action ) { case FILE_ACTION_ADDED:{ _event_type = fe_create; break; } case FILE_ACTION_REMOVED:{ _event_type = fe_remove; break; } case FILE_ACTION_MODIFIED:{ _event_type = fe_modify; break; } case FILE_ACTION_RENAMED_OLD_NAME:{ _event_type = fe_remove; break; } case FILE_ACTION_RENAMED_NEW_NAME:{ _event_type = fe_create; break; } } //switch if(_event_type != fe_unknown) { // put into queue snow::io::event_node_t* node = new snow::io::event_node_t; node->path = std::string(watcher->path+"/"+path); node->event_type = (int)_event_type; snow::io::eventqueue_push(&filewatch_queue, node); } seek += notifier->NextEntryOffset; if(notifier->NextEntryOffset == 0) { break; } } //seek < buffer size } //while running return 0; } //run_thread
/* * Curl_wait_for_resolv() waits for a resolve to finish. This function should * be avoided since using this risk getting the multi interface to "hang". * * If 'entry' is non-NULL, make it point to the resolved dns entry * * This is the version for resolves-in-a-thread. */ CURLcode Curl_wait_for_resolv(struct connectdata *conn, struct Curl_dns_entry **entry) { struct thread_data *td = (struct thread_data*) conn->async.os_specific; struct SessionHandle *data = conn->data; long timeout; DWORD status, ticks; CURLcode rc; curlassert (conn && td); /* now, see if there's a connect timeout or a regular timeout to use instead of the default one */ timeout = conn->data->set.connecttimeout ? conn->data->set.connecttimeout : conn->data->set.timeout ? conn->data->set.timeout : CURL_TIMEOUT_RESOLVE; /* default name resolve timeout */ ticks = GetTickCount(); /* wait for the thread to resolve the name */ status = WaitForSingleObject(td->event_resolved, 1000UL*timeout); /* mark that we are now done waiting */ ReleaseMutex(td->mutex_waiting); /* close our handle to the mutex, no point in hanging on to it */ CloseHandle(td->mutex_waiting); td->mutex_waiting = NULL; /* close the event handle, it's useless now */ CloseHandle(td->event_resolved); td->event_resolved = NULL; /* has the resolver thread succeeded in resolving our query ? */ if (status == WAIT_OBJECT_0) { /* wait for the thread to exit, it's in the callback sequence */ if (WaitForSingleObject(td->thread_hnd, 5000) == WAIT_TIMEOUT) { TerminateThread(td->thread_hnd, 0); conn->async.done = TRUE; td->thread_status = (DWORD)-1; TRACE(("%s() thread stuck?!, ", THREAD_NAME)); } else { /* Thread finished before timeout; propagate Winsock error to this * thread. 'conn->async.done = TRUE' is set in * Curl_addrinfo4/6_callback(). */ WSASetLastError(conn->async.status); GetExitCodeThread(td->thread_hnd, &td->thread_status); TRACE(("%s() status %lu, thread retval %lu, ", THREAD_NAME, status, td->thread_status)); } } else { conn->async.done = TRUE; td->thread_status = (DWORD)-1; TRACE(("%s() timeout, ", THREAD_NAME)); } TRACE(("elapsed %lu ms\n", GetTickCount()-ticks)); CloseHandle(td->thread_hnd); if(entry) *entry = conn->async.dns; rc = CURLE_OK; if (!conn->async.dns) { /* a name was not resolved */ if (td->thread_status == CURLE_OUT_OF_MEMORY) { rc = CURLE_OUT_OF_MEMORY; failf(data, "Could not resolve host: %s", curl_easy_strerror(rc)); } else if (td->thread_status == (DWORD)-1 || conn->async.status == NO_DATA) { failf(data, "Resolving host timed out: %s", conn->host.name); rc = CURLE_OPERATION_TIMEDOUT; } else if(conn->async.done) { failf(data, "Could not resolve host: %s; %s", conn->host.name, Curl_strerror(conn,conn->async.status)); rc = CURLE_COULDNT_RESOLVE_HOST; } else rc = CURLE_OPERATION_TIMEDOUT; } Curl_destroy_thread_data(&conn->async); if(!conn->async.dns) conn->bits.close = TRUE; return (rc); }
LIBRARY_API bool socketNet::create (struct networkStruct& socketData) { char ac[32]; char *client_ip_address = NULL; HANDLE hTimer = NULL; LARGE_INTEGER liDueTime; liDueTime.QuadPart=-30000000; //! 3 second timer for polling struct sockaddr_in serverAddr; //! server's socket address struct sockaddr_in clientAddr; //! client's socket address int sockAddrSize; //! size of socket address structure SOCKET newFd; //! socket descriptor from accept int ix = 0; //! counter for work task names int tcpServer_shutdown = 0; unsigned long l = 1; //! to set sockets to nonblocking hTimer = CreateWaitableTimer(NULL, TRUE, NULL); if (NULL == hTimer) { //! Timer error } //! Set up the local address sockAddrSize = sizeof (struct sockaddr_in); WSADATA wsaData; int wsaret = WSAStartup(0x101, &wsaData); if (wsaret != 0) return false; //! Clear (zero-out) serverAddr memset((char *) &serverAddr, 0, sockAddrSize); serverAddr.sin_addr.s_addr = htons (INADDR_ANY); serverAddr.sin_family = AF_INET; serverAddr.sin_port = htons ((u_short)socketData.sP); gethostname(ac, sizeof(ac)); struct hostent *phe = gethostbyname(ac); socketData.serverAddress = new char[128];//inet_ntoa (serverAddr.sin_addr); struct in_addr a1;//, a2, a3, a4; int i = 0; //while (phe->h_addr_list[i] != 0) { memcpy (&a1, phe->h_addr_list[i], sizeof(struct in_addr)); sprintf (socketData.serverAddress, "%s", inet_ntoa(a1)); ++i; } //! This allows us to have multiple clients attached to the same port if (!socketData.bound) { //! create a TCP-based socket if ((socketData.sFd = socket(AF_INET, SOCK_STREAM, 0)) == ERROR_F) { #ifdef NOISY perror ("socket"); #endif return false; } //! bind socket to local address if (bind (socketData.sFd, (struct sockaddr *) &serverAddr, sockAddrSize) == ERROR_F) { #ifdef NOISY perror ("bind"); #endif closesocket (socketData.sFd); WSACleanup (); return false; } socketData.bound = true; } //ioctlsocket (socketData.sFd, FIONBIO, &l); //! Create queue for client connection requests if (listen (socketData.sFd, SERVER_MAX_CONNECTIONS) == ERROR_F) { closesocket (socketData.sFd); WSACleanup (); socketData.bound = true; return false; } //! Accept new connect requests and spawn tasks to process them //! Accept the first connection and use it... newFd = 0; do { //! If we stop the connection attempt bool okay; okay = false; do { if (!settings_->globalRunServer) { closesocket (socketData.sFd); WSACleanup(); return false; } if ((newFd = accept (socketData.sFd, (struct sockaddr*)&clientAddr, &sockAddrSize)) == ERROR_F) { printf ("%s\n", inet_ntoa (clientAddr.sin_addr)); #ifdef NOISY perror ("accept"); #endif int g = WSAGetLastError(); //! We expect the error WSAEWOULDBLOCK since the socket is non-blocking if (g != WSAEWOULDBLOCK) { closesocket (socketData.sFd); WSACleanup (); return false; } // Set a timer to wait for 0.1 seconds--Poll @ 10 Hz if (!SetWaitableTimer(hTimer, &liDueTime, 1, NULL, NULL, 0)) { //! Timer error } if (WaitForSingleObject(hTimer, INFINITE) != WAIT_OBJECT_0) { //! Timer error } } else { okay = true; } } while (!okay); if (newFd > 0) { client_ip_address = inet_ntoa (clientAddr.sin_addr); //! JAM: A problem encountered with Windows is that it constantly //! thinks a connection from 204.204.204.204:52428 is being //! made if (strcmp("204.204.204.204", client_ip_address) != 0) { //! fill out the struct socketData.cFd = newFd; socketData.address = client_ip_address; socketData.cP = ntohs (clientAddr.sin_port); //! Disable nonblocking by default //unsigned long l = 0; //ioctlsocket (socketData.cFd, FIONBIO, &l); tcpServer_shutdown = 1; //! say we are done } } }while (tcpServer_shutdown != 1); socketData.connected = true; settings_->connected = true; //l=1; //ioctlsocket (socketData.cFd, FIONBIO, &l); return true; }
/* * The runtime library's popen() on win32 does not work when being * called from a service when running on windows <= 2000, because * there is no stdin/stdout/stderr. * * Executing a command in a pipe and reading the first line from it * is all we need. */ static char * pipe_read_line(char *cmd, char *line, int maxsize) { #ifndef WIN32 FILE *pgver; /* flush output buffers in case popen does not... */ fflush(stdout); fflush(stderr); errno = 0; if ((pgver = popen(cmd, "r")) == NULL) { perror("popen failure"); return NULL; } errno = 0; if (fgets(line, maxsize, pgver) == NULL) { if (feof(pgver)) fprintf(stderr, "no data was returned by command \"%s\"\n", cmd); else perror("fgets failure"); pclose(pgver); /* no error checking */ return NULL; } if (pclose_check(pgver)) return NULL; return line; #else /* WIN32 */ SECURITY_ATTRIBUTES sattr; HANDLE childstdoutrd, childstdoutwr, childstdoutrddup; PROCESS_INFORMATION pi; STARTUPINFO si; char *retval = NULL; sattr.nLength = sizeof(SECURITY_ATTRIBUTES); sattr.bInheritHandle = TRUE; sattr.lpSecurityDescriptor = NULL; if (!CreatePipe(&childstdoutrd, &childstdoutwr, &sattr, 0)) return NULL; if (!DuplicateHandle(GetCurrentProcess(), childstdoutrd, GetCurrentProcess(), &childstdoutrddup, 0, FALSE, DUPLICATE_SAME_ACCESS)) { CloseHandle(childstdoutrd); CloseHandle(childstdoutwr); return NULL; } CloseHandle(childstdoutrd); ZeroMemory(&pi, sizeof(pi)); ZeroMemory(&si, sizeof(si)); si.cb = sizeof(si); si.dwFlags = STARTF_USESTDHANDLES; si.hStdError = childstdoutwr; si.hStdOutput = childstdoutwr; si.hStdInput = INVALID_HANDLE_VALUE; if (CreateProcess(NULL, cmd, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi)) { /* Successfully started the process */ char *lineptr; ZeroMemory(line, maxsize); /* Try to read at least one line from the pipe */ /* This may require more than one wait/read attempt */ for (lineptr = line; lineptr < line + maxsize - 1;) { DWORD bytesread = 0; /* Let's see if we can read */ if (WaitForSingleObject(childstdoutrddup, 10000) != WAIT_OBJECT_0) break; /* Timeout, but perhaps we got a line already */ if (!ReadFile(childstdoutrddup, lineptr, maxsize - (lineptr - line), &bytesread, NULL)) break; /* Error, but perhaps we got a line already */ lineptr += strlen(lineptr); if (!bytesread) break; /* EOF */ if (strchr(line, '\n')) break; /* One or more lines read */ } if (lineptr != line) { /* OK, we read some data */ int len; /* If we got more than one line, cut off after the first \n */ lineptr = strchr(line, '\n'); if (lineptr) *(lineptr + 1) = '\0'; len = strlen(line); /* * If EOL is \r\n, convert to just \n. Because stdout is a * text-mode stream, the \n output by the child process is * received as \r\n, so we convert it to \n. The server main.c * sets setvbuf(stdout, NULL, _IONBF, 0) which has the effect of * disabling \n to \r\n expansion for stdout. */ if (len >= 2 && line[len - 2] == '\r' && line[len - 1] == '\n') { line[len - 2] = '\n'; line[len - 1] = '\0'; len--; } /* * We emulate fgets() behaviour. So if there is no newline at the * end, we add one... */ if (len == 0 || line[len - 1] != '\n') strcat(line, "\n"); retval = line; } CloseHandle(pi.hProcess); CloseHandle(pi.hThread); } CloseHandle(childstdoutwr); CloseHandle(childstdoutrddup); return retval; #endif /* WIN32 */ }
static VOID MouseGetPacket(PMOUSE_PACKET Packet) { /* Clear the packet */ RtlZeroMemory(Packet, sizeof(*Packet)); /* Acquire the mutex */ WaitForSingleObject(MouseMutex, INFINITE); Packet->Flags |= MOUSE_ALWAYS_SET; /* Set the sign flags */ if (HorzCounter < 0) { Packet->Flags |= MOUSE_X_SIGN; HorzCounter = -HorzCounter; } if (VertCounter < 0) { Packet->Flags |= MOUSE_Y_SIGN; VertCounter = -VertCounter; } /* Check for horizontal overflows */ if (HorzCounter > MOUSE_MAX) { HorzCounter = MOUSE_MAX; Packet->Flags |= MOUSE_X_OVERFLOW; } /* Check for vertical overflows */ if (VertCounter > MOUSE_MAX) { VertCounter = MOUSE_MAX; Packet->Flags |= MOUSE_Y_OVERFLOW; } /* Set the button flags */ if (ButtonState & FROM_LEFT_1ST_BUTTON_PRESSED) Packet->Flags |= MOUSE_LEFT_BUTTON; if (ButtonState & FROM_LEFT_2ND_BUTTON_PRESSED) Packet->Flags |= MOUSE_MIDDLE_BUTTON; if (ButtonState & RIGHTMOST_BUTTON_PRESSED) Packet->Flags |= MOUSE_RIGHT_BUTTON; if (MouseId == 4) { if (ButtonState & FROM_LEFT_3RD_BUTTON_PRESSED) Packet->Extra |= MOUSE_4TH_BUTTON; if (ButtonState & FROM_LEFT_4TH_BUTTON_PRESSED) Packet->Extra |= MOUSE_5TH_BUTTON; } if (MouseId >= 3) { /* Set the scroll counter */ Packet->Extra |= ((UCHAR)ScrollCounter & 0x0F); } /* Store the counters in the packet */ Packet->HorzCounter = LOBYTE(HorzCounter); Packet->VertCounter = LOBYTE(VertCounter); /* Reset the counters */ MouseResetCounters(); /* Release the mutex */ ReleaseMutex(MouseMutex); }
wait_result_t wait( event_t & e, DWORD timeout ) { return wait_result_t( WaitForSingleObject( e.m_handle, timeout ), 1, &e.m_handle ); }
/****************************************************************************** * WaitForDebugEvent (KERNEL32.@) * * Waits for a debugging event to occur in a process being debugged before * filling out the debug event structure. * * PARAMS * event [O] Address of structure for event information. * timeout [I] Number of milliseconds to wait for event. * * RETURNS * * Returns true if a debug event occurred and false if the call timed out. */ BOOL WINAPI WaitForDebugEvent( LPDEBUG_EVENT event, DWORD timeout) { BOOL ret; DWORD res; int i; for (;;) { HANDLE wait = 0; debug_event_t data; SERVER_START_REQ( wait_debug_event ) { req->get_handle = (timeout != 0); wine_server_set_reply( req, &data, sizeof(data) ); if (!(ret = !wine_server_call_err( req ))) goto done; if (!wine_server_reply_size(reply)) /* timeout */ { wait = wine_server_ptr_handle( reply->wait ); ret = FALSE; goto done; } event->dwDebugEventCode = data.code; event->dwProcessId = (DWORD)reply->pid; event->dwThreadId = (DWORD)reply->tid; switch(data.code) { case EXCEPTION_DEBUG_EVENT: if (data.exception.exc_code == DBG_PRINTEXCEPTION_C && data.exception.nb_params >= 2) { event->dwDebugEventCode = OUTPUT_DEBUG_STRING_EVENT; event->u.DebugString.lpDebugStringData = wine_server_get_ptr( data.exception.params[1] ); event->u.DebugString.fUnicode = FALSE; event->u.DebugString.nDebugStringLength = data.exception.params[0]; break; } else if (data.exception.exc_code == DBG_RIPEXCEPTION && data.exception.nb_params >= 2) { event->dwDebugEventCode = RIP_EVENT; event->u.RipInfo.dwError = data.exception.params[0]; event->u.RipInfo.dwType = data.exception.params[1]; break; } event->u.Exception.dwFirstChance = data.exception.first; event->u.Exception.ExceptionRecord.ExceptionCode = data.exception.exc_code; event->u.Exception.ExceptionRecord.ExceptionFlags = data.exception.flags; event->u.Exception.ExceptionRecord.ExceptionRecord = wine_server_get_ptr( data.exception.record ); event->u.Exception.ExceptionRecord.ExceptionAddress = wine_server_get_ptr( data.exception.address ); event->u.Exception.ExceptionRecord.NumberParameters = data.exception.nb_params; for (i = 0; i < data.exception.nb_params; i++) event->u.Exception.ExceptionRecord.ExceptionInformation[i] = data.exception.params[i]; break; case CREATE_THREAD_DEBUG_EVENT: event->u.CreateThread.hThread = wine_server_ptr_handle( data.create_thread.handle ); event->u.CreateThread.lpThreadLocalBase = wine_server_get_ptr( data.create_thread.teb ); event->u.CreateThread.lpStartAddress = wine_server_get_ptr( data.create_thread.start ); break; case CREATE_PROCESS_DEBUG_EVENT: event->u.CreateProcessInfo.hFile = wine_server_ptr_handle( data.create_process.file ); event->u.CreateProcessInfo.hProcess = wine_server_ptr_handle( data.create_process.process ); event->u.CreateProcessInfo.hThread = wine_server_ptr_handle( data.create_process.thread ); event->u.CreateProcessInfo.lpBaseOfImage = wine_server_get_ptr( data.create_process.base ); event->u.CreateProcessInfo.dwDebugInfoFileOffset = data.create_process.dbg_offset; event->u.CreateProcessInfo.nDebugInfoSize = data.create_process.dbg_size; event->u.CreateProcessInfo.lpThreadLocalBase = wine_server_get_ptr( data.create_process.teb ); event->u.CreateProcessInfo.lpStartAddress = wine_server_get_ptr( data.create_process.start ); event->u.CreateProcessInfo.lpImageName = wine_server_get_ptr( data.create_process.name ); event->u.CreateProcessInfo.fUnicode = data.create_process.unicode; break; case EXIT_THREAD_DEBUG_EVENT: event->u.ExitThread.dwExitCode = data.exit.exit_code; break; case EXIT_PROCESS_DEBUG_EVENT: event->u.ExitProcess.dwExitCode = data.exit.exit_code; break; case LOAD_DLL_DEBUG_EVENT: event->u.LoadDll.hFile = wine_server_ptr_handle( data.load_dll.handle ); event->u.LoadDll.lpBaseOfDll = wine_server_get_ptr( data.load_dll.base ); event->u.LoadDll.dwDebugInfoFileOffset = data.load_dll.dbg_offset; event->u.LoadDll.nDebugInfoSize = data.load_dll.dbg_size; event->u.LoadDll.lpImageName = wine_server_get_ptr( data.load_dll.name ); event->u.LoadDll.fUnicode = data.load_dll.unicode; break; case UNLOAD_DLL_DEBUG_EVENT: event->u.UnloadDll.lpBaseOfDll = wine_server_get_ptr( data.unload_dll.base ); break; } done: /* nothing */ ; } SERVER_END_REQ; if (ret) return TRUE; if (!wait) break; res = WaitForSingleObject( wait, timeout ); CloseHandle( wait ); if (res != STATUS_WAIT_0) break; } SetLastError( ERROR_SEM_TIMEOUT ); return FALSE; }
// wait functions wait_result_t wait( HANDLE h, DWORD timeout ) { return wait_result_t( WaitForSingleObject( h, timeout ), 1, &h ); }
int nt_execve(const char *prog, const char *const *args, const char *const *envir) { STARTUPINFO si; PROCESS_INFORMATION pi; enum {none, directex, shellex} execmode; DWORD exitcode; DWORD dwCreationflags; int priority; char *argv0; char *cmdstr, *cmdend; unsigned int cmdsize; size_t prognamelen, cmdlen; int hasext; char extension[_MAX_FNAME]; const char *begin, *end, *extptr; static char exts[MAX_PATH]; UNREFERENCED_PARAMETER(envir); /* get default PATHEXT or use empty exts */ if (!*exts) { DWORD rc; /* not initialized */ rc = GetEnvironmentVariable("PATHEXT", exts, sizeof(exts)); if ((rc == 0) || (rc >= sizeof(exts))) /* if error or PATHEXT too big will retry at the next call */ *exts = 0; } /* if prog has an extension initialize begin end to skip PATHEXT search */ prognamelen = strlen(prog); extptr = prog + prognamelen - 1; hasext = 0; while (extptr > prog && !ISPATHSEP(*extptr)) { if (*extptr == '.' && *(extptr - 1) != ':' && !ISPATHSEP(*(extptr - 1))) { hasext++; break; } extptr--; } if (hasext) { begin = "."; end = ""; strcpy(extension, extptr); } else { begin = exts; end = exts; *extension = '\0'; } argv0 = (char *)heap_alloc(MAX_PATH); /* (prognamelen + 1) does not really matter, argv0 is '\0' filled */ memcpy(argv0, prog, prognamelen + 1); errno = 0; execmode = none; /* NOTE: loops over PATHEXT if no extension found */ while (*begin) { size_t extlen; if (GetBinaryType(argv0, &exitcode)) { /* exists and is executable NOTE: an "xxx.exe" without a correct PE header (i.e. a text file) has type "DOS binary", but execution will generate a WOW error */ execmode = directex; break; } if (GetLastError() == ERROR_BAD_EXE_FORMAT) { /* exists but is not "executable" */ execmode = shellex; break; } if (hasext) break; /* get next PATHEXT extension */ while (*begin && (*begin != '.')) begin++; while (*end && (*end != ';')) end++; if (!*begin) break; extlen = end - begin; if (extlen < sizeof(extension)) { memcpy(extension, begin, extlen); extension[extlen] = '\0'; /* prognamelen ignores the last '\r' if present */ memcpy(argv0, prog, prognamelen); /* update argv0 adding the extension to prog */ memcpy(argv0 + prognamelen, extension, extlen + 1); } begin = end; /* skip sequences of ';' */ while (*end && *end == ';') end++; }; cmdstr = (char *)heap_alloc(MAX_PATH << 2); cmdsize = MAX_PATH << 2; cmdlen = 0; cmdend = cmdstr; dbgprintf(PR_VERBOSE, "%s(): execute [%s] extension=[%s] mode=%d hasext=%d\n", __FUNCTION__, argv0, extension, execmode, hasext); /* skip over program name */ args++; /* the file (after PATHEXT search) exists, but it's not "executable" */ if (execmode == shellex) { /* if prog had no extension or has the extension associated to shell scripts */ if ((hasext == 0 && *extension == '\0') || is_shell_script(extension)) { int res = process_shebang(argv0, (const char *const *)&cmdstr, &cmdlen, &cmdend, &cmdsize); if (res < 0) { execmode = none; } else if (res == 0) { char *newargv[2]; cmdlen = copy_quote_and_fix_slashes(gModuleName, cmdstr); cmdend = cmdstr + cmdlen; newargv[0] = path_to_slash(argv0); newargv[1] = NULL; concat_args_and_quote((const char *const *)newargv, &cmdstr, &cmdlen, &cmdend, &cmdsize); *cmdend = 0; argv0 = gModuleName; execmode = directex; } else { cmdend = cmdstr + cmdlen; execmode = directex; } } else { unsigned long shflags = 0L; /* if the file extension is in pathext, use the same console and wait for child. StrStrI() is from shlwapi */ if (StrStrI(exts, extension)) shflags = SEE_MASK_NO_CONSOLE | SEE_MASK_NOCLOSEPROCESS; if (try_shell_ex(argv0, args, shflags, &cmdstr, &cmdsize)) return (0); /* ShellExecute failed, the file has an unknown extension, but it may be a shell script with a shebang */ if (process_shebang(argv0, (const char *const *)&cmdstr, &cmdlen, &cmdend, &cmdsize) > 0) { cmdend = cmdstr + cmdlen; execmode = directex; } else { /* the file extension is NOT known and the file has NO shebang: returns EPERM, see NOTES */ errno = EPERM; return (-1); } } } else if (execmode == directex) { cmdlen = copy_quote_and_fix_slashes(prog, cmdstr); cmdend = cmdstr + cmdlen; } if (execmode == none) { /* error: prog not found even after trying PATHEXT extensions */ errno = ENOENT; return (-1); } concat_args_and_quote(args, &cmdstr, &cmdlen, &cmdend, &cmdsize); if (*cmdstr == ' ') { /* if we left a ' ' for the quote and there is no quote */ cmdstr++; cmdlen--; } *cmdend = 0; init_startupinfo(&si); dwCreationflags = GetPriorityClass(GetCurrentProcess()); priority = GetThreadPriority(GetCurrentThread()); #if defined(W32DEBUG) /* DebugView output is very difficult to read with overlong lines */ if (cmdlen < 128) dbgprintf(PR_EXEC, "%s(): CreateProcess(%s, ..) cmdstr=[%s]\n", __FUNCTION__, argv0, cmdstr); else { char shortbuf[128+4]; memcpy(shortbuf, cmdstr, 128); memcpy(shortbuf + 128, "...", 4); dbgprintf(PR_EXEC, "nt_execve(): CreateProcess(%s, ..) cmdstr=[%s]\n", argv0, shortbuf); } #endif if (!CreateProcess(argv0, cmdstr, NULL, NULL, TRUE, // need this for redirecting std handles dwCreationflags | CREATE_SUSPENDED, NULL, NULL, &si, &pi)) { exitcode = GetLastError(); if (exitcode == ERROR_BAD_EXE_FORMAT) { dbgprintf(PR_ERROR, "!!! CreateProcess(%s, ..) error BAD_EXE_FORMAT in %s\n", argv0, __FUNCTION__); errno = ENOEXEC; } else if (exitcode == ERROR_INVALID_PARAMETER) { dbgprintf(PR_ERROR, "!!! CreateProcess(%s, ..) error INVALID_PARAMETER in %s, cmdstr len=%u\n", argv0, __FUNCTION__, strlen(cmdstr)); /* exceeded command line */ /* return NOT found, ENAMETOOLONG is correct but not understood by the shell that will retry with another path ... */ errno = ENOENT; } else { dbgprintf(PR_ERROR, "!!! CreateProcess(%s, ..) error %ld in %s\n", argv0, exitcode, __FUNCTION__); errno = ENOENT; } goto fail_return; } else { exitcode = 0; if (!SetThreadPriority(pi.hThread, priority)) dbgprintf(PR_ERROR, "!!! SetThreadPriority(0x%p) failed, error %ld\n", pi.hThread, GetLastError()); ResumeThread(pi.hThread); if (!is_gui(argv0)) { if (WaitForSingleObject(pi.hProcess, INFINITE) != WAIT_OBJECT_0) dbgprintf(PR_ERROR, "!!! error %ld waiting for process %ld\n", GetLastError(), pi.dwProcessId); if (!GetExitCodeProcess(pi.hProcess, &exitcode)) dbgprintf(PR_ERROR, "!!! GetExitCodeProcess(0x%p, ..) error %ld in %s\n", pi.hProcess, GetLastError(), __FUNCTION__); } CloseHandle(pi.hProcess); CloseHandle(pi.hThread); close_si_handles(); /* @@@@ should wait for the clipboard ? if (is_dev_clipboard_active) { CloseHandle((HANDLE)_get_osfhandle(0)); CloseHandle((HANDLE)_get_osfhandle(1)); CloseHandle((HANDLE)_get_osfhandle(2)); ... WaitForSingleObject(ghdevclipthread,60*1000); } */ dbgprintf(PR_ALL, "--- %s(): Exec'd process %ld terminated with exitcode %ld\n", __FUNCTION__, pi.dwProcessId, exitcode); exec_exit((int)exitcode); } fail_return: heap_free(cmdstr); close_si_handles(); exec_exit(-1); return (-1); }
static int try_shell_ex(char *argv0, const char *const *argv, unsigned long shellexflags, char **cmdstr, unsigned int *cmdsize) { char *cmdend; size_t cmdlen; SHELLEXECUTEINFO shinfo; BOOL nocmd = 0; path_to_backslash(argv0); /* @@@@ is this code really needed ? when ? */ if ((!*argv) && (argv0[0] == '\\') && (argv0[1] == '\\')) { shellexflags |= SEE_MASK_CONNECTNETDRV; nocmd = 1; goto noargs; } cmdend = *cmdstr; cmdlen = 0; concat_args_and_quote(argv, cmdstr, &cmdlen, &cmdend, cmdsize); *cmdend = '\0'; noargs: dbgprintf(PR_EXEC, "ShellExecute(%s, ..) with cmdstr [%s]\n", argv0, *cmdstr); memset(&shinfo, 0, sizeof(shinfo)); shinfo.cbSize = sizeof(shinfo); shinfo.fMask = SEE_MASK_FLAG_NO_UI | SEE_MASK_FLAG_DDEWAIT | shellexflags; shinfo.hwnd = NULL; shinfo.lpVerb = NULL; shinfo.lpFile = argv0; shinfo.lpParameters = nocmd ? NULL : *cmdstr; shinfo.lpDirectory = 0; shinfo.nShow = SW_SHOWDEFAULT; if (ShellExecuteEx(&shinfo)) { DWORD retval = 255; dbgprintf(PR_EXEC, "ShellExecute() created process handle 0x%p\n", shinfo.hProcess); /* may happen if "executing" a file associated to a running program, i.e. "execute" a .html file with an already opened browser window */ if (shinfo.hProcess != (HANDLE)0) { if (shellexflags & SEE_MASK_NOCLOSEPROCESS) { if ((intptr_t)(shinfo.hInstApp) > 32) { if (WaitForSingleObject(shinfo.hProcess, INFINITE) == WAIT_OBJECT_0) { /* try to get the return value */ GetExitCodeProcess(shinfo.hProcess, &retval); } else { dbgprintf(PR_ERROR, "!!! ShellExecute() [%s] WaitForSingleObject() error %ld\n", argv0, GetLastError()); } } else { dbgprintf(PR_ERROR, "!!! ShellExecute() [%s] error %p\n", argv0, shinfo.hInstApp); } } /* try to close, it may fail but .. what else could we do */ CloseHandle(shinfo.hProcess); } dbgprintf(PR_ALL, "--- %s(): ShellExecute() OK, exiting with code %ld\n", __FUNCTION__, retval); exec_exit((int)retval); } else { dbgprintf(PR_EXEC, "ShellExecute() failed\n"); } return (0); }
static void * _workqueue_job_scheduler(void *data) { struct workqueue_thread *thread = (struct workqueue_thread *) data; struct workqueue_ctx *ctx; struct TIME_STRUCT_TYPE wait_time; int ret; long long wait_ms = 1000; DEBUG_MSG("starting data=%p\n", data); assert(thread); ctx = thread->ctx; DEBUG_MSG("thread %d starting\n",thread->thread_num); if (ctx->ops && ctx->ops->worker_constructor) { DEBUG_MSG("thread %d calling constructor\n",thread->thread_num); ctx->ops->worker_constructor(ctx->ops->data); } LOCK_MUTEX(&thread->mutex); while (thread->keep_running) { DEBUG_MSG("thread %d looking for work \n",thread->thread_num); thread->job = _workqueue_get_job(thread, &wait_time, &wait_ms); /* is there a job that needs to be run now */ if (thread->job) { /* there is work to do */ DEBUG_MSG("launching job %d\n",thread->job->job_id); /* keep job_mutex locked while running to test if running */ LOCK_MUTEX(&thread->job_mutex); /* mantain unlocked while running so we can check state. in workqueue_job_running() */ UNLOCK_MUTEX(&thread->mutex); /* launch worker job */ thread->job->func(thread->job->data); DEBUG_MSG("job %d finished\n", thread->job->job_id); /* done with job free it */ free(thread->job); thread->job = NULL; UNLOCK_MUTEX(&thread->job_mutex); LOCK_MUTEX(&thread->mutex); } else { /* wait until we are signaled that there is new work, or until the wait time is up */ /* we should idle */ UNLOCK_MUTEX(&thread->mutex); #ifdef WINDOWS DEBUG_MSG("thread %d going idle\n",thread->thread_num); ret = WaitForSingleObject(ctx->work_ready_cond, (DWORD) wait_ms); #else DEBUG_MSG("thread %d going idle. %d sec; %ld nsec\n", thread->thread_num, (int) wait_time.tv_sec, wait_time.tv_nsec); // note this wait may be a long time, if the system time changes LOCK_MUTEX(&ctx->cond_mutex); ret = pthread_cond_timedwait(&ctx->work_ready_cond, &ctx->cond_mutex, &wait_time); UNLOCK_MUTEX(&ctx->cond_mutex); #endif LOCK_MUTEX(&thread->mutex); if (!thread->keep_running) { DEBUG_MSG("thread %d stopping\n",thread->thread_num); break; } #ifdef WINDOWS /* check windows error cases*/ if( !ret && WAIT_TIMEOUT == GetLastError()) { DEBUG_MSG("thread %d idle timeout\n",thread->thread_num); continue; /* wait again */ } if (!ret) { // other error } #else if (ret == ETIMEDOUT) { DEBUG_MSG("thread %d idle timeout lock\n",thread->thread_num); continue; /* wait again */ } else if (ret == EINVAL) { ERROR_MSG("thread %d pthread_cond_timedwait EINVAL\n", thread->thread_num); usleep(wait_ms); // wait 1000th of time wait } else if (ret) { ERROR_MSG("thread %d pthread_cond_timedwait ret =%d\n", thread->thread_num, ret); } #endif } } UNLOCK_MUTEX(&thread->mutex); if (ctx->ops && ctx->ops->worker_destructor) { DEBUG_MSG("thread %d calling destructor\n",thread->thread_num); ctx->ops->worker_destructor(ctx->ops->data); } return NULL; }
int main( int argc, char *argv[] ) { extern HANDLE CDECL __wine_make_process_system(void); static const WCHAR RunW[] = {'R','u','n',0}; static const WCHAR RunOnceW[] = {'R','u','n','O','n','c','e',0}; static const WCHAR RunServicesW[] = {'R','u','n','S','e','r','v','i','c','e','s',0}; static const WCHAR RunServicesOnceW[] = {'R','u','n','S','e','r','v','i','c','e','s','O','n','c','e',0}; static const WCHAR wineboot_eventW[] = {'_','_','w','i','n','e','b','o','o','t','_','e','v','e','n','t',0}; /* First, set the current directory to SystemRoot */ int optc; BOOL end_session, force, init, kill, restart, shutdown, update; HANDLE event; SECURITY_ATTRIBUTES sa; BOOL is_wow64; end_session = force = init = kill = restart = shutdown = update = FALSE; GetWindowsDirectoryW( windowsdir, MAX_PATH ); if( !SetCurrentDirectoryW( windowsdir ) ) WINE_ERR("Cannot set the dir to %s (%d)\n", wine_dbgstr_w(windowsdir), GetLastError() ); if (IsWow64Process( GetCurrentProcess(), &is_wow64 ) && is_wow64) { STARTUPINFOW si; PROCESS_INFORMATION pi; WCHAR filename[MAX_PATH]; void *redir; DWORD exit_code; memset( &si, 0, sizeof(si) ); si.cb = sizeof(si); GetModuleFileNameW( 0, filename, MAX_PATH ); Wow64DisableWow64FsRedirection( &redir ); if (CreateProcessW( filename, GetCommandLineW(), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi )) { WINE_TRACE( "restarting %s\n", wine_dbgstr_w(filename) ); WaitForSingleObject( pi.hProcess, INFINITE ); GetExitCodeProcess( pi.hProcess, &exit_code ); ExitProcess( exit_code ); } else WINE_ERR( "failed to restart 64-bit %s, err %d\n", wine_dbgstr_w(filename), GetLastError() ); Wow64RevertWow64FsRedirection( redir ); } while ((optc = getopt_long(argc, argv, short_options, long_options, NULL )) != -1) { switch(optc) { case 'e': end_session = TRUE; break; case 'f': force = TRUE; break; case 'i': init = TRUE; break; case 'k': kill = TRUE; break; case 'r': restart = TRUE; break; case 's': shutdown = TRUE; break; case 'u': update = TRUE; break; case 'h': usage(); return 0; case '?': usage(); return 1; } } if (end_session) { if (kill) { if (!shutdown_all_desktops( force )) return 1; } else if (!shutdown_close_windows( force )) return 1; } if (kill) kill_processes( shutdown ); if (shutdown) return 0; sa.nLength = sizeof(sa); sa.lpSecurityDescriptor = NULL; sa.bInheritHandle = TRUE; /* so that services.exe inherits it */ event = CreateEventW( &sa, TRUE, FALSE, wineboot_eventW ); ResetEvent( event ); /* in case this is a restart */ create_hardware_registry_keys(); create_dynamic_registry_keys(); create_environment_registry_keys(); wininit(); pendingRename(); ProcessWindowsFileProtection(); ProcessRunKeys( HKEY_LOCAL_MACHINE, RunServicesOnceW, TRUE, FALSE ); if (init || (kill && !restart)) { ProcessRunKeys( HKEY_LOCAL_MACHINE, RunServicesW, FALSE, FALSE ); start_services_process(); } if (init || update) update_wineprefix( update ); create_volatile_environment_registry_key(); ProcessRunKeys( HKEY_LOCAL_MACHINE, RunOnceW, TRUE, TRUE ); if (!init && !restart) { ProcessRunKeys( HKEY_LOCAL_MACHINE, RunW, FALSE, FALSE ); ProcessRunKeys( HKEY_CURRENT_USER, RunW, FALSE, FALSE ); ProcessStartupItems(); } WINE_TRACE("Operation done\n"); SetEvent( event ); return 0; }
bool execute(const char* command, std::string currentDir, DWORD& retCode, std::string& output) { HANDLE outWR; SECURITY_ATTRIBUTES sa; sa.nLength = sizeof(SECURITY_ATTRIBUTES); sa.lpSecurityDescriptor = NULL; sa.bInheritHandle = TRUE; TCHAR lpTempPathBuffer[BUFSIZE]; TCHAR szTempFileName[MAX_PATH]; DWORD ret = GetTempPath(BUFSIZE, lpTempPathBuffer); if (ret > BUFSIZE || ret == 0) { MessageBox( NULL, "Error GetTempPath", "Error", MB_OK ); return false; } ret = GetTempFileName(lpTempPathBuffer, "svn", 0, szTempFileName); if (ret == 0) { MessageBox( NULL, "Error GetTempFileName", "Error", MB_OK ); return false; } outWR = CreateFile(szTempFileName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, &sa, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (outWR == INVALID_HANDLE_VALUE) { MessageBox( NULL, "Error create file", "Error", MB_OK ); return false; } PROCESS_INFORMATION processInfomation; STARTUPINFO startupInfo; memset(&processInfomation, 0, sizeof(processInfomation)); memset(&startupInfo, 0, sizeof(startupInfo)); startupInfo.cb = sizeof(startupInfo); startupInfo.hStdError = outWR; startupInfo.hStdOutput = outWR; startupInfo.dwFlags |= STARTF_USESTDHANDLES; startupInfo.wShowWindow = SW_HIDE; BOOL result = CreateProcess( NULL, (char*) command, NULL, NULL, TRUE, 0, NULL, currentDir.c_str(), &startupInfo, &processInfomation); if (!result) { MessageBox( NULL, "Can't CreateProcess", "Error", MB_OK ); CloseHandle(outWR); return false; } else { WaitForSingleObject(processInfomation.hProcess, INFINITE); GetExitCodeProcess(processInfomation.hProcess, &retCode); CloseHandle(processInfomation.hProcess); CloseHandle(processInfomation.hThread); // read from stdout if (!CloseHandle(outWR)) { MessageBox( NULL, "Can't CloseHandle", "Error", MB_OK ); return false; } outWR = CreateFile(szTempFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (outWR == INVALID_HANDLE_VALUE) { MessageBox( NULL, "Error open file", "Error", MB_OK ); return false; } CHAR buf[BUFSIZE]; DWORD dwRead; DWORD totalSize = 0; std::vector<char*> allBufs; std::vector<DWORD> lens; while (true) { result = ReadFile(outWR, buf, BUFSIZE, &dwRead, NULL); if (!result || dwRead == 0) break; totalSize += dwRead; char* content = new char[dwRead]; memcpy(content, buf, dwRead); allBufs.push_back(content); lens.push_back(dwRead); } char* content = new char[totalSize + 1]; char* currentPtr = content; for (std::size_t i = 0; i < allBufs.size(); i++) { memcpy(currentPtr, allBufs[i], lens[i]); currentPtr += lens[i]; } content[totalSize] = 0; for (std::size_t i = 0; i < allBufs.size(); i++) { delete[] allBufs[i]; } output.swap(std::string(content)); delete[] content; CloseHandle(outWR); return true; } }