int x264_is_pipe( const char *path ) { wchar_t path_utf16[MAX_PATH]; if( utf8_to_utf16( path, path_utf16 ) ) return WaitNamedPipeW( path_utf16, 0 ); return 0; }
void log_init_thread() { if (!logger_attached) return; LPCWSTR pipeName = L"\\\\.\\pipe\\flog_server"; for (;;) { hLoggerPipe = CreateFileW(pipeName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); if (hLoggerPipe == INVALID_HANDLE_VALUE) { /* Non critical error code, just wait and try connecting again */ if (GetLastError() != ERROR_PIPE_BUSY || !WaitNamedPipeW(pipeName, NMPWAIT_WAIT_FOREVER)) { logger_attached = 0; break; } continue; } /* Send initial request */ struct request request; request.magic = PROTOCOL_MAGIC; request.version = PROTOCOL_VERSION; request.pid = GetProcessId(GetCurrentProcess()); request.tid = GetThreadId(GetCurrentThread()); DWORD written; if (!WriteFile(hLoggerPipe, &request, sizeof(request), &written, NULL)) { CloseHandle(hLoggerPipe); logger_attached = 0; } break; } }
static bool connect_namedpipe(impl_type& impl,const String& name_,DWORD t) { String name=make_pipename(name_); (void)&impl; if(t==0) t=1; if (WaitNamedPipeW(IConv::to_wide(name).c_str(), t) == FALSE) { return false; } return true; }
static DWORD WINAPI pipe_connect_thread_proc(void* parameter) { HANDLE pipeHandle = INVALID_HANDLE_VALUE; int errno; uv_pipe_t* handle; uv_connect_t* req; req = (uv_connect_t*)parameter; assert(req); handle = (uv_pipe_t*)req->handle; assert(handle); /* We're here because CreateFile on a pipe returned ERROR_PIPE_BUSY. We wait for the pipe to become available with WaitNamedPipe. */ while (WaitNamedPipeW(handle->name, 30000)) { /* The pipe is now available, try to connect. */ pipeHandle = CreateFileW(handle->name, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); if (pipeHandle != INVALID_HANDLE_VALUE) { break; } } if (pipeHandle != INVALID_HANDLE_VALUE && !uv_set_pipe_handle(handle, pipeHandle)) { handle->handle = pipeHandle; req->error = uv_ok_; } else { req->error = uv_new_sys_error(GetLastError()); } memset(&req->overlapped, 0, sizeof(req->overlapped)); /* Post completed */ if (!PostQueuedCompletionStatus(LOOP->iocp, 0, 0, &req->overlapped)) { uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus"); } return 0; }
static DWORD WINAPI pipe_connect_thread_proc(void* parameter) { HANDLE pipeHandle = INVALID_HANDLE_VALUE; int errno; uv_loop_t* loop; uv_pipe_t* handle; uv_connect_t* req; req = (uv_connect_t*) parameter; assert(req); handle = (uv_pipe_t*) req->handle; assert(handle); loop = handle->loop; assert(loop); /* We're here because CreateFile on a pipe returned ERROR_PIPE_BUSY. */ /* We wait for the pipe to become available with WaitNamedPipe. */ while (WaitNamedPipeW(handle->name, 30000)) { /* The pipe is now available, try to connect. */ pipeHandle = CreateFileW(handle->name, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); if (pipeHandle != INVALID_HANDLE_VALUE) { break; } SwitchToThread(); } if (pipeHandle != INVALID_HANDLE_VALUE && !uv_set_pipe_handle(loop, handle, pipeHandle)) { handle->handle = pipeHandle; SET_REQ_SUCCESS(req); } else { SET_REQ_ERROR(req, GetLastError()); } /* Post completed */ POST_COMPLETION_FOR_REQ(loop, req); return 0; }
void CTextService::_ConnectDic() { DWORD dwMode; if(WaitNamedPipeW(mgrpipename, NMPWAIT_USE_DEFAULT_WAIT) == 0) { return; } hPipe = CreateFileW(mgrpipename, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, SECURITY_SQOS_PRESENT | SECURITY_EFFECTIVE_ONLY | SECURITY_IDENTIFICATION, nullptr); if(hPipe == INVALID_HANDLE_VALUE) { return; } dwMode = PIPE_READMODE_MESSAGE | PIPE_WAIT; SetNamedPipeHandleState(hPipe, &dwMode, nullptr, nullptr); }
/* * @implemented */ BOOL WINAPI WaitNamedPipeA(LPCSTR lpNamedPipeName, DWORD nTimeOut) { BOOL r; UNICODE_STRING NameU; /* Convert the name to Unicode */ Basep8BitStringToDynamicUnicodeString(&NameU, lpNamedPipeName); /* Call the Unicode API */ r = WaitNamedPipeW(NameU.Buffer, nTimeOut); /* Free the Unicode string */ RtlFreeUnicodeString(&NameU); /* Return result */ return r; }
void service_process(BOOL (*start_service)(PCSTR, PCWSTR), int argc, char** argv) { BOOL res; StringCbCopyA(service_nameA, sizeof(service_nameA), argv[2]); MultiByteToWideChar(CP_ACP, 0, service_nameA, -1, service_nameW, _countof(service_nameW)); StringCbPrintfW(named_pipe_name, sizeof(named_pipe_name), L"\\\\.\\pipe\\%ls_pipe", service_nameW); res = WaitNamedPipeW(named_pipe_name, NMPWAIT_USE_DEFAULT_WAIT); if (!res) return; hClientPipe = CreateFileW(named_pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (hClientPipe == INVALID_HANDLE_VALUE) return; service_trace("Service process starting...\n"); res = start_service(service_nameA, service_nameW); service_trace("Service process stopped.\n"); CloseHandle(hClientPipe); }
static DWORD WINAPI pipe_connect_thread_proc(void* parameter) { uv_loop_t* loop; uv_pipe_t* handle; uv_connect_t* req; HANDLE pipeHandle = INVALID_HANDLE_VALUE; DWORD duplex_flags; req = (uv_connect_t*) parameter; assert(req); handle = (uv_pipe_t*) req->handle; assert(handle); loop = handle->loop; assert(loop); /* We're here because CreateFile on a pipe returned ERROR_PIPE_BUSY. */ /* We wait for the pipe to become available with WaitNamedPipe. */ while (WaitNamedPipeW(handle->name, 30000)) { /* The pipe is now available, try to connect. */ pipeHandle = open_named_pipe(handle->name, &duplex_flags); if (pipeHandle != INVALID_HANDLE_VALUE) { break; } SwitchToThread(); } if (pipeHandle != INVALID_HANDLE_VALUE && !uv_set_pipe_handle(loop, handle, pipeHandle, duplex_flags)) { SET_REQ_SUCCESS(req); } else { SET_REQ_ERROR(req, GetLastError()); } /* Post completed */ POST_COMPLETION_FOR_REQ(loop, req); return 0; }
HRESULT PipeStream::Open(const wchar_t* name, DWORD timeout) { if (name == nullptr) return E_INVALIDARG; if (IsValid()) return E_HANDLE; Reset(); std::wstring pipe_name(L"\\\\.\\pipe\\"); pipe_name.append(name); if (!WaitNamedPipeW(pipe_name.c_str(), timeout)) return HRESULT_FROM_LAST_ERROR(); handle_ = CreateFileW(pipe_name.c_str(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); if (handle_ == INVALID_HANDLE_VALUE) return HRESULT_FROM_LAST_ERROR(); connected_ = true; return S_OK; }
BOOL CreateRemoteSessionProcess( IN DWORD dwSessionId, IN BOOL bUseDefaultToken, IN HANDLE hToken, IN LPCWSTR lpApplicationName, IN LPSTR A_lpCommandLine, IN LPSECURITY_ATTRIBUTES lpProcessAttributes, IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN BOOL bInheritHandles, IN DWORD dwCreationFlags, IN LPVOID lpEnvironment, IN LPCWSTR lpCurrentDirectory, IN LPSTARTUPINFO A_lpStartupInfo, OUT LPPROCESS_INFORMATION lpProcessInformation) { WCHAR lpCommandLine[255]; STARTUPINFOW StartupInfo; Char2Wchar(lpCommandLine, A_lpCommandLine, 255); ZeroMemory(&StartupInfo,sizeof(STARTUPINFOW)); StartupInfo.wShowWindow = SW_SHOW; StartupInfo.lpDesktop = L"Winsta0\\Winlogon"; StartupInfo.cb = sizeof(STARTUPINFOW); WCHAR szWinStaPath[MAX_PATH]; BOOL bGetNPName=FALSE; WCHAR szNamedPipeName[MAX_PATH]=L""; DWORD dwNameLen; HINSTANCE hInstWinSta; HANDLE hNamedPipe; LPVOID pData=NULL; BOOL bRet = FALSE; DWORD cbReadBytes,cbWriteBytes; DWORD dwEnvLen = 0; union{ CPAU_PARAM cpauData; BYTE bDump[0x2000]; }; CPAU_RET_PARAM cpauRetData; DWORD dwUsedBytes = sizeof(cpauData); LPBYTE pBuffer = (LPBYTE)(&cpauData+1); GetSystemDirectoryW(szWinStaPath, MAX_PATH); lstrcatW(szWinStaPath,L"\\winsta.dll"); hInstWinSta = LoadLibraryW(szWinStaPath); if(hInstWinSta) { pWinStationQueryInformationW pfWinStationQueryInformationW=(pWinStationQueryInformationW)GetProcAddress(hInstWinSta,"WinStationQueryInformationW"); if(pfWinStationQueryInformationW) { bGetNPName = pfWinStationQueryInformationW(0, dwSessionId, 0x21,szNamedPipeName, sizeof(szNamedPipeName), &dwNameLen); } FreeLibrary(hInstWinSta); } if(!bGetNPName || szNamedPipeName[0] == '\0') { swprintf(szNamedPipeName,260,L"\\\\.\\Pipe\\TerminalServer\\SystemExecSrvr\\%d", dwSessionId); } do{ hNamedPipe = CreateFileW(szNamedPipeName, GENERIC_READ|GENERIC_WRITE,0, NULL, OPEN_EXISTING, 0, 0); if(hNamedPipe == INVALID_HANDLE_VALUE) { if(GetLastError() == ERROR_PIPE_BUSY) { if(!WaitNamedPipeW(szNamedPipeName, 30000)) return FALSE; } else { return FALSE; } } }while(hNamedPipe == INVALID_HANDLE_VALUE); memset(&cpauData, 0, sizeof(cpauData)); cpauData.bInheritHandles = bInheritHandles; cpauData.bUseDefaultToken = bUseDefaultToken; cpauData.dwCreationFlags = dwCreationFlags; cpauData.dwProcessId = GetCurrentProcessId(); cpauData.hToken = hToken; cpauData.lpApplicationName =(LPWSTR)MarshallString(lpApplicationName, &cpauData, sizeof(bDump),&pBuffer, &dwUsedBytes); cpauData.lpCommandLine = (LPWSTR)MarshallString(lpCommandLine,&cpauData, sizeof(bDump), &pBuffer, &dwUsedBytes); cpauData.StartupInfo = StartupInfo; cpauData.StartupInfo.lpDesktop =(LPWSTR)MarshallString(cpauData.StartupInfo.lpDesktop, &cpauData,sizeof(bDump), &pBuffer, &dwUsedBytes); cpauData.StartupInfo.lpTitle =(LPWSTR)MarshallString(cpauData.StartupInfo.lpTitle, &cpauData,sizeof(bDump), &pBuffer, &dwUsedBytes); if(lpEnvironment) { if(dwCreationFlags & CREATE_UNICODE_ENVIRONMENT) { while((dwEnvLen+dwUsedBytes <= sizeof(bDump))) { if(((LPWSTR)lpEnvironment)[dwEnvLen/2]=='\0' &&((LPWSTR)lpEnvironment)[dwEnvLen/2+1] == '\0') { dwEnvLen+=2*sizeof(WCHAR); break; } dwEnvLen+=sizeof(WCHAR); } } else { while(dwEnvLen+dwUsedBytes <= sizeof(bDump)) { if(((LPSTR)lpEnvironment)[dwEnvLen]=='\0' && ((LPSTR)lpEnvironment)[dwEnvLen+1]=='\0') { dwEnvLen+=2; break; } dwEnvLen++; } } if(dwEnvLen+dwUsedBytes <= sizeof(bDump)) { memmove(pBuffer, lpEnvironment, dwEnvLen); cpauData.lpEnvironment = (LPVOID)dwUsedBytes; pBuffer += dwEnvLen; dwUsedBytes += dwEnvLen; } else { cpauData.lpEnvironment = NULL; } } else { cpauData.lpEnvironment = NULL; } cpauData.cbSize = dwUsedBytes; HANDLE hProcess=NULL; if(WriteFile(hNamedPipe, &cpauData, cpauData.cbSize, &cbWriteBytes,NULL)) { Sleep(250); if (ReadFile(hNamedPipe, & cpauRetData, sizeof(cpauRetData),&cbReadBytes, NULL)) { hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, cpauRetData.ProcInfo.dwProcessId); #ifdef _DEBUG char szText[256]; sprintf(szText," ++++++cpau %i %i %i %i %i %i\n",cpauRetData.bRetValue,cpauRetData.ProcInfo.hProcess,cpauRetData.ProcInfo.dwProcessId,cpauRetData.ProcInfo.dwThreadId,cpauRetData.ProcInfo.hThread,hProcess); OutputDebugString(szText); #endif bRet = cpauRetData.bRetValue; if(bRet) { *lpProcessInformation = cpauRetData.ProcInfo; } else SetLastError(cpauRetData.dwLastErr); } } else bRet = FALSE; // function sometimes fail, the use processid to get hprocess... bug MS if (lpProcessInformation->hProcess==0) lpProcessInformation->hProcess=hProcess; //this should never happen, looping connections if (lpProcessInformation->hProcess==0) Sleep(5000); CloseHandle(hNamedPipe); return bRet; }
oslPipe SAL_CALL osl_createPipe(rtl_uString *strPipeName, oslPipeOptions Options, oslSecurity Security) { rtl_uString* name = NULL; rtl_uString* path = NULL; rtl_uString* temp = NULL; oslPipe pPipe; PSECURITY_ATTRIBUTES pSecAttr = NULL; rtl_uString_newFromAscii(&path, PIPESYSTEM); rtl_uString_newFromAscii(&name, PIPEPREFIX); if ( /*IS_NT &&*/ Security) { rtl_uString *Ident = NULL; rtl_uString *Delim = NULL; OSL_VERIFY(osl_getUserIdent(Security, &Ident)); rtl_uString_newFromAscii(&Delim, "_"); rtl_uString_newConcat(&temp, name, Ident); rtl_uString_newConcat(&name, temp, Delim); rtl_uString_release(Ident); rtl_uString_release(Delim); } else { if (Options & osl_Pipe_CREATE) { PSECURITY_DESCRIPTOR pSecDesc; pSecDesc = (PSECURITY_DESCRIPTOR) rtl_allocateMemory(SECURITY_DESCRIPTOR_MIN_LENGTH); /* add a NULL disc. ACL to the security descriptor */ OSL_VERIFY(InitializeSecurityDescriptor(pSecDesc, SECURITY_DESCRIPTOR_REVISION)); OSL_VERIFY(SetSecurityDescriptorDacl(pSecDesc, TRUE, (PACL) NULL, FALSE)); pSecAttr = rtl_allocateMemory(sizeof(SECURITY_ATTRIBUTES)); pSecAttr->nLength = sizeof(SECURITY_ATTRIBUTES); pSecAttr->lpSecurityDescriptor = pSecDesc; pSecAttr->bInheritHandle = TRUE; } } rtl_uString_assign(&temp, name); rtl_uString_newConcat(&name, temp, strPipeName); /* alloc memory */ pPipe= __osl_createPipeImpl(); osl_incrementInterlockedCount(&(pPipe->m_Reference)); /* build system pipe name */ rtl_uString_assign(&temp, path); rtl_uString_newConcat(&path, temp, name); rtl_uString_release(temp); temp = NULL; if (Options & osl_Pipe_CREATE) { SetLastError( ERROR_SUCCESS ); if ( IS_NT ) pPipe->m_NamedObject = CreateMutexW( NULL, FALSE, name->buffer ); else { LPSTR pszTempBuffer = NULL; int nCharsNeeded; nCharsNeeded = WideCharToMultiByte( CP_ACP, 0, name->buffer, name->length, NULL, 0, NULL, NULL ); pszTempBuffer = alloca( nCharsNeeded * sizeof(CHAR) ); nCharsNeeded = WideCharToMultiByte( CP_ACP, 0, name->buffer, name->length, pszTempBuffer, nCharsNeeded, NULL, NULL ); pszTempBuffer[nCharsNeeded-1] = 0; pPipe->m_NamedObject = CreateMutexA( NULL, FALSE, pszTempBuffer ); } if ( pPipe->m_NamedObject != INVALID_HANDLE_VALUE && pPipe->m_NamedObject != NULL ) { if ( GetLastError() != ERROR_ALREADY_EXISTS ) { pPipe->m_Security = pSecAttr; rtl_uString_assign(&pPipe->m_Name, name); if (IS_NT) { /* try to open system pipe */ pPipe->m_File = CreateNamedPipeW( path->buffer, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, PIPE_WAIT | PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE, PIPE_UNLIMITED_INSTANCES, 4096, 4096, NMPWAIT_WAIT_FOREVER, pPipe->m_Security); if (pPipe->m_File != INVALID_HANDLE_VALUE) { rtl_uString_release( name ); rtl_uString_release( path ); return pPipe; } } else /* Win 9x */ { LPSTR pszTempBuffer = NULL; int nCharsNeeded; nCharsNeeded = WideCharToMultiByte( CP_ACP, 0, path->buffer, path->length, NULL, 0, NULL, NULL ); pszTempBuffer = alloca( nCharsNeeded * sizeof(CHAR) ); nCharsNeeded = WideCharToMultiByte( CP_ACP, 0, path->buffer, path->length, pszTempBuffer, nCharsNeeded, NULL, NULL ); pszTempBuffer[nCharsNeeded-1] = 0; pPipe->m_File = CreateSimplePipe( pszTempBuffer ); if ( IsValidHandle(pPipe->m_File) ) { rtl_uString_release( name ); rtl_uString_release( path ); return pPipe; } } } else { CloseHandle( pPipe->m_NamedObject ); pPipe->m_NamedObject = INVALID_HANDLE_VALUE; } } } else { if (IS_NT) { BOOL fPipeAvailable; do { /* free instance should be available first */ fPipeAvailable = WaitNamedPipeW(path->buffer, NMPWAIT_WAIT_FOREVER); /* first try to open system pipe */ if ( fPipeAvailable ) { pPipe->m_File = CreateFileW( path->buffer, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL); if ( pPipe->m_File != INVALID_HANDLE_VALUE ) { // We got it ! rtl_uString_release( name ); rtl_uString_release( path ); return (pPipe); } else { // Pipe instance maybe catched by another client -> try again } } } while ( fPipeAvailable ); } else /* Win 9x */ { LPSTR pszTempBuffer = NULL; int nCharsNeeded; nCharsNeeded = WideCharToMultiByte( CP_ACP, 0, path->buffer, path->length, NULL, 0, NULL, NULL ); pszTempBuffer = alloca( nCharsNeeded * sizeof(CHAR) ); nCharsNeeded = WideCharToMultiByte( CP_ACP, 0, path->buffer, path->length, pszTempBuffer, nCharsNeeded, NULL, NULL ); pszTempBuffer[nCharsNeeded-1] = 0; pPipe->m_File = OpenSimplePipe( pszTempBuffer ); if ( IsValidHandle(pPipe->m_File) ) { // We got it ! rtl_uString_release( name ); rtl_uString_release( path ); return (pPipe); } } } /* if we reach here something went wrong */ __osl_destroyPipeImpl(pPipe); return NULL; }
/* * @implemented */ BOOL WINAPI CallNamedPipeW(LPCWSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut) { HANDLE hPipe; BOOL bRetry = TRUE; BOOL bError; DWORD dwPipeMode; while (TRUE) { /* Try creating it */ hPipe = CreateFileW(lpNamedPipeName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); /* Success, break out */ if (hPipe != INVALID_HANDLE_VALUE) break; /* Already tried twice, give up */ if (bRetry == FALSE) return FALSE; /* Wait on it */ WaitNamedPipeW(lpNamedPipeName, nTimeOut); /* Get ready to try again */ bRetry = FALSE; } /* Set the pipe mode */ dwPipeMode = PIPE_READMODE_MESSAGE | PIPE_WAIT; bError = SetNamedPipeHandleState(hPipe, &dwPipeMode, NULL, NULL); if (!bError) { /* Couldn't change state, fail */ CloseHandle(hPipe); return FALSE; } /* Do the transact */ bError = TransactNamedPipe(hPipe, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesRead, NULL); /* Close the handle */ CloseHandle(hPipe); return bError; }
static DWORD ScConnectControlPipe(HANDLE *hPipe) { DWORD dwBytesWritten; DWORD dwState; DWORD dwServiceCurrent = 0; NTSTATUS Status; WCHAR NtControlPipeName[MAX_PATH + 1]; RTL_QUERY_REGISTRY_TABLE QueryTable[2]; DWORD dwProcessId; /* Get the service number and create the named pipe */ RtlZeroMemory(&QueryTable, sizeof(QueryTable)); QueryTable[0].Name = L""; QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED; QueryTable[0].EntryContext = &dwServiceCurrent; Status = RtlQueryRegistryValues(RTL_REGISTRY_CONTROL, L"ServiceCurrent", QueryTable, NULL, NULL); if (!NT_SUCCESS(Status)) { ERR("RtlQueryRegistryValues() failed (Status %lx)\n", Status); return RtlNtStatusToDosError(Status); } swprintf(NtControlPipeName, L"\\\\.\\pipe\\net\\NtControlPipe%u", dwServiceCurrent); if (!WaitNamedPipeW(NtControlPipeName, 30000)) { ERR("WaitNamedPipe(%S) failed (Error %lu)\n", NtControlPipeName, GetLastError()); return ERROR_FAILED_SERVICE_CONTROLLER_CONNECT; } *hPipe = CreateFileW(NtControlPipeName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (*hPipe == INVALID_HANDLE_VALUE) { ERR("CreateFileW() failed for pipe %S (Error %lu)\n", NtControlPipeName, GetLastError()); return ERROR_FAILED_SERVICE_CONTROLLER_CONNECT; } dwState = PIPE_READMODE_MESSAGE; if (!SetNamedPipeHandleState(*hPipe, &dwState, NULL, NULL)) { CloseHandle(*hPipe); *hPipe = INVALID_HANDLE_VALUE; return ERROR_FAILED_SERVICE_CONTROLLER_CONNECT; } /* Pass the ProcessId to the SCM */ dwProcessId = GetCurrentProcessId(); WriteFile(*hPipe, &dwProcessId, sizeof(DWORD), &dwBytesWritten, NULL); TRACE("Sent Process ID %lu\n", dwProcessId); return ERROR_SUCCESS; }
CPipe::CPipe(char *szName, DWORD dWait){ int iTemp; int iFlag = 1; WCHAR wbuffer[MAX_PATH+1]; dTHX; hPipe = 0; dBufferSize = BUFFER_SIZE; dBytes = 0; char szPipeName[PIPE_NAME_SIZE + 1]; dwOpenMode = PIPE_ACCESS_DUPLEX; dwPipeMode = PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT; nMaxInstances = PIPE_UNLIMITED_INSTANCES; nOutBufferSize = dBufferSize; nInBufferSize = dBufferSize; nDefaultTimeOut = PIPE_TIMEOUT; lpSecurityAttributes= NULL; iError = 0; strcpy((char *)szError, ""); cBuffer = new char [dBufferSize]; if (! cBuffer){ dBufferSize = 0; } memset((void *)szError, 0, ERROR_TEXT_SIZE); memset((void *)szPipeName, 0, PIPE_NAME_SIZE + 1); if (strncmp((char *)szName, "\\\\", 2) == 0){ iPipeType = CLIENT; iTemp = 0; }else{ iPipeType = SERVER; strcpy(szPipeName, PIPE_NAME_PREFIX); iTemp = strlen(PIPE_NAME_PREFIX); } strncat(szPipeName, szName, PIPE_NAME_SIZE - iTemp); if (USING_WIDE()) { A2WHELPER(szPipeName, wbuffer, sizeof(wbuffer)); } if(iPipeType == SERVER){ if (USING_WIDE()) { hPipe = CreateNamedPipeW(wbuffer, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes); } else { hPipe = CreateNamedPipeA(szPipeName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes); } }else{ while(iFlag){ if (USING_WIDE()) { hPipe = CreateFileW(wbuffer, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, NULL); } else { hPipe = CreateFileA(szPipeName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, NULL); } if (GetLastError() == ERROR_PIPE_BUSY){ if (USING_WIDE()) iFlag = WaitNamedPipeW(wbuffer, dWait); else iFlag = WaitNamedPipeA(szPipeName, dWait); }else{ iFlag = 0; } } } if (cBuffer == 0){ iError = 998; strcpy((char *)szError, "Could not allocate a buffer for the pipe connection"); } if (hPipe == INVALID_HANDLE_VALUE){ iError = 999; strcpy((char *)szError, "Could not connect"); delete this; } }
DWORD main(int argc, char *argv[]) { HANDLE hPipe; SYELOG_MESSAGE Message; BOOL fSuccess; DWORD cbWritten, dwMode; // Try to open a named pipe; wait for it, if necessary. TIME_ZONE_INFORMATION tzi; GetTimeZoneInformation(&tzi); for (;;) { hPipe = CreateFileW(SYELOG_PIPE_NAMEW, // pipe name GENERIC_WRITE, // write access only 0, // no sharing NULL, // no security attributes OPEN_EXISTING, // opens existing pipe 0, // default attributes NULL); // no template file // Break if the pipe handle is valid. if (hPipe != INVALID_HANDLE_VALUE) break; // Exit if an error other than ERROR_PIPE_BUSY occurs. if (GetLastError() != ERROR_PIPE_BUSY) MyErrExit("Could not open pipe"); // All pipe instances are busy, so wait for 1 seconds. if (!WaitNamedPipeW(SYELOG_PIPE_NAMEW, 1000)) MyErrExit("Could not open pipe"); } // The pipe connected; change to message-read mode. dwMode = PIPE_READMODE_MESSAGE; fSuccess = SetNamedPipeHandleState(hPipe, // pipe handle &dwMode, // new pipe mode NULL, // don't set maximum bytes NULL); // don't set maximum time if (!fSuccess) MyErrExit("SetNamedPipeHandleState"); // Send a message to the pipe server. memset(&Message, 0, sizeof(Message)); StringCchCopyA(Message.szMessage, ARRAYSIZE(Message.szMessage), (argc > 1) ? argv[1] : "sltestp: hello world!"); Message.nFacility = SYELOG_FACILITY_APPLICATION; Message.nSeverity = SYELOG_SEVERITY_INFORMATION; Message.nProcessId = GetCurrentProcessId(); GetSystemTimeAsFileTime(&Message.ftOccurance); PCSTR pszEnd = Message.szMessage; for (; *pszEnd; pszEnd++) { // no internal contents. } Message.nBytes = (USHORT)(pszEnd - ((PCSTR)&Message) + 1); fSuccess = WriteFile(hPipe, // pipe handle &Message, // message Message.nBytes, // message length &cbWritten, // bytes written NULL); // not overlapped if (! fSuccess) MyErrExit("WriteFile"); CloseHandle(hPipe); GetTimeZoneInformation(&tzi); return 0; }
DWORD executeWpkgViaPipe(int called_by, bool debug_flag) { BOOL fSuccess = FALSE; int err; if (debug_flag) { DEBUG = TRUE; // Get install path from registry HKEY hKey = NULL; DWORD dwDataType = REG_SZ; DWORD dwSize = 0; LPBYTE lpValue = NULL; LONG lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Wpkg-GP", 0, KEY_QUERY_VALUE, &hKey); lRet = RegQueryValueExA(hKey, "InstallPath", 0, &dwDataType, lpValue, &dwSize); // dwSize will contain the data size if (lRet == ERROR_SUCCESS) { // Allocate the buffer lpValue = (LPBYTE) malloc(dwSize + 1); lRet = RegQueryValueExA(hKey, "InstallPath", 0, &dwDataType, lpValue, &dwSize); RegCloseKey(hKey); // Adding null termination lpValue[dwSize] = '\0'; wchar_t debuglogpath[BUFSIZE]; swprintf_s(debuglogpath, BUFSIZE, L"%hs\\logs\\wpkg-gp-debug.log", lpValue); _wfopen_s(&debugfh, debuglogpath, L"a"); free(lpValue); } } if (called_by == GPE) EXECUTE_FROM_GPE = TRUE; else if (called_by == EXE) EXECUTE_FROM_EXE = TRUE; //Making sure the service has started SERVICE_STATUS_PROCESS ssStatus; DWORD dwBytesNeeded; // Get a handle to the SCM database. debug(L"Starting OpenSCManager\n"); SC_HANDLE schSCManager = OpenSCManager( NULL, // local computer NULL, // servicesActive database SC_MANAGER_ALL_ACCESS); // full access rights if (schSCManager == NULL) { err = GetLastError(); UpdateStatus(LOG_ERROR, L"Error when calling OpenSCManager", err); return err; } debug(L"Started OpenSCManager\n"); // Get a handle to the service. debug(L"Starting OpenService\n"); SC_HANDLE schService = OpenServiceW( schSCManager, // SCM database L"WpkgServer", // name of service SERVICE_ALL_ACCESS); // full access if (schService == NULL) { err = GetLastError(); CloseServiceHandle(schSCManager); UpdateStatus(LOG_ERROR, L"Error when calling OpenService", err); return err; } debug(L"Started OpenService\n"); // Check the status of the service debug(L"Starting QueryServiceStatusEx\n"); if (!QueryServiceStatusEx( schService, // handle to service SC_STATUS_PROCESS_INFO, // information level (LPBYTE) &ssStatus, // address of structure sizeof(SERVICE_STATUS_PROCESS), // size of structure &dwBytesNeeded ) ) // size needed if buffer is too small { err = GetLastError(); CloseServiceHandle(schService); CloseServiceHandle(schSCManager); UpdateStatus(LOG_ERROR, L"Error when calling QueryServiceStatusEx", err); return err; } debug(L"Finished QueryServiceStatusEx\n"); debug(L"Checking the status of the service\n"); for (int i = 0; ssStatus.dwCurrentState != SERVICE_RUNNING; i++) { UpdateStatus(LOG_INFO, L"Waiting for the WPKG-GP software installation service to start.", FALSE); debug(L"The current status was not SERVICE_RUNNING: %i, but %i, entering wait loop. i is %i (max 120)\n", SERVICE_RUNNING, ssStatus.dwCurrentState, i); //Then wait for the service for maximum 120 seconds if (i >= 120) { UpdateStatus(LOG_ERROR, L"Service did not start for 120 seconds, quitting.", FALSE); return 101; //Timeout } if (EXECUTE_FROM_EXE) { UpdateStatus(LOG_INFO, L"Executed from exe file, will not wait for service to start", FALSE); break; } debug(L" Sleeping 1 second\n"); Sleep(1000); if (!QueryServiceStatusEx( schService, // handle to service SC_STATUS_PROCESS_INFO, // information level (LPBYTE) &ssStatus, // address of structure sizeof(SERVICE_STATUS_PROCESS), // size of structure &dwBytesNeeded ) ) // size needed if buffer is too small { err = GetLastError(); CloseServiceHandle(schService); CloseServiceHandle(schSCManager); UpdateStatus(LOG_ERROR, L"Error when calling QueryServiceStatusEx in loop", err); return err; } debug(L"Checking if service is running, comparing CurrentState: %i to SERVICE_RUNNING: %i\n", ssStatus.dwCurrentState, SERVICE_RUNNING); } CloseServiceHandle(schService); CloseServiceHandle(schSCManager); HANDLE hPipe; LPCWSTR lpszPipename = L"\\\\.\\pipe\\WPKG"; // Try to open a named pipe; wait for it, if necessary. while (1) { debug(L"Trying to run CreateFile on named pipe\n"); hPipe = CreateFileW( lpszPipename, // pipe name GENERIC_READ | // read and write access GENERIC_WRITE, 0, // no sharing NULL, // default security attributes OPEN_EXISTING, // opens existing pipe 0, // default attributes NULL); // no template file // Break the loop if the pipe handle is valid. if (hPipe != INVALID_HANDLE_VALUE) { debug(L"The pipe handle was valid, continuing\n"); break; } // Exit if an error other than ERROR_PIPE_BUSY occurs. err = GetLastError(); if (err != ERROR_PIPE_BUSY) { UpdateStatus(LOG_ERROR, L"CreatePipe returned an error.", err); return err; } // All pipe instances are busy, so wait for 20 seconds. debug(L"Waiting in 20 seconds for a free pipe instance\n"); if (!WaitNamedPipeW(lpszPipename, 20000)){ err = GetLastError(); UpdateStatus(LOG_ERROR, L"Pipe server had no free instances for 20 seconds, quitting.", err); return err; } } // The pipe connected; change to message-read mode. DWORD dwMode = PIPE_READMODE_MESSAGE; debug(L"Executing SetNamedPipeHandleState\n"); fSuccess = SetNamedPipeHandleState( hPipe, // pipe handle &dwMode, // new pipe mode NULL, // don't set maximum bytes NULL); // don't set maximum time if (!fSuccess){ err = GetLastError(); UpdateStatus(LOG_ERROR, L"CreatePipe returned an error.", err); return 206; } debug(L"Sending message to pipe server\n"); // Send a message to the pipe server. LPCSTR lpvMessage="ExecuteFromGPE"; DWORD cbWritten; fSuccess = WriteFile( hPipe, // pipe handle lpvMessage, // message lstrlenA(lpvMessage)+1, // message length &cbWritten, // bytes written NULL); // not overlapped if (!fSuccess) { err = GetLastError(); UpdateStatus(LOG_ERROR, L"WriteFile to named pipe returned an error.", err); return err; } debug(L"Waiting for reply from pipe server\n"); while (1) { char chBuf[BUFSIZE]; wchar_t wcBuf[BUFSIZE]; DWORD cbRead; // Read from the pipe. debug(L"Executing ReadFile on pipe\n"); fSuccess = ReadFile( hPipe, // pipe handle chBuf, // buffer to receive reply sizeof(chBuf), // size of buffer &cbRead, // number of bytes read NULL); // not overlapped err = GetLastError(); if (err == ERROR_HANDLE_EOF) { debug(L"Got to EOF, continuing"); break; } if (err == ERROR_PIPE_NOT_CONNECTED) { debug(L"Other end closed the pipe, continuing\n"); break; } if (!fSuccess && err != ERROR_MORE_DATA) { UpdateStatus(LOG_ERROR, L"ReadFile from named pipe returned an error.", err); return err; } if (cbRead < 4) { debug(L"Short message received %d bytes", cbRead); continue; } debug(L"Successfully read from pipe, retrieved Status Code %3.3S\n", chBuf); debug(L"Converting string to wchar_t\n"); cbWritten = MultiByteToWideChar(CP_UTF8, 0, &chBuf[4], cbRead-4, wcBuf, BUFSIZE-1); if (cbWritten == 0) { err = GetLastError(); UpdateStatus(LOG_ERROR, L"Conversion of data read from pipe failed.", err); return err; } wcBuf[cbWritten] = 0; debug(L"Calling UpdateStatus\n"); //pStatusCallback(FALSE, wcBuf); UpdateStatus(NO_LOG, wcBuf, FALSE); } CloseHandle(hPipe); if (DEBUG) if (debugfh != false) fclose(debugfh); return ERROR_SUCCESS; }