int EDT_UtilReg_LogPermissions(HKEY hRootKey, const wchar_t *wzKey) { int iReturnCode = EDT_OK; int err = ERROR_SUCCESS; HKEY hRegKey; LOG_ENTER(); LOG_TIME(L"registry key (%ls\\%ls) --> \n",hRootKey==HKEY_CURRENT_USER?L"HKCU":L"HKLM",wzKey); if(ERROR_SUCCESS != (err = RegOpenKeyEx(hRootKey, wzKey, 0L, KEY_READ , &hRegKey))) { if(err != ERROR_FILE_NOT_FOUND) { LOG_ERRORCODE(L"RegOpenKeyEx failed",err); return EDT_ERR_REGISTRY_READ_FAILED; } else { LOG_EXIT(L"NOT FOUND\n"); return EDT_ERR_REGISTRY_NOT_FOUND; } } PSECURITY_DESCRIPTOR pSecurityDescriptor = NULL; DWORD lcbSecurityDescriptor = 0; if(ERROR_INSUFFICIENT_BUFFER == (err = RegGetKeySecurity(hRegKey, DACL_SECURITY_INFORMATION, pSecurityDescriptor, &lcbSecurityDescriptor))) { pSecurityDescriptor = (PSECURITY_DESCRIPTOR)malloc(lcbSecurityDescriptor); if(ERROR_SUCCESS != (err = RegGetKeySecurity(hRegKey, DACL_SECURITY_INFORMATION, pSecurityDescriptor, &lcbSecurityDescriptor))) { LOG_ERRORCODE(L"RegQueryValueEx failed",err); iReturnCode = EDT_ERR_REGISTRY_READ_FAILED; } else { BOOL bDaclPresent = FALSE; BOOL bDaclDefaulted = FALSE; PACL pDacl = NULL; GetSecurityDescriptorDacl(pSecurityDescriptor, &bDaclPresent, &pDacl, &bDaclDefaulted); if(bDaclPresent == TRUE) { if(pDacl == NULL) { LOG(L"A NULL discretionary access control list (DACL) found \nA NULL DACL implicitly allows all access to an object.\n"); } else { LOG(L"A discretionary access control list (DACL) was found with Length = %d\n",pDacl->AclSize); LOG(L"Number of Access Control Elements (ACE's): %d\n",pDacl->AceCount); registryLogAces(pDacl); } } else { LOG(L"No discretionary access control list (DACL) found \n"); } LPTSTR StringSecurityDescriptor; ULONG StringSecurityDescriptorLen; ConvertSecurityDescriptorToStringSecurityDescriptor(pSecurityDescriptor,SDDL_REVISION_1,DACL_SECURITY_INFORMATION, &StringSecurityDescriptor,&StringSecurityDescriptorLen); LOG(L"%s\n",(const wchar_t*)StringSecurityDescriptor); //parse info see http://msdn.microsoft.com/en-us/library/aa379570%28v=vs.85%29.aspx LocalFree(StringSecurityDescriptor); } free(pSecurityDescriptor); } else { LOG_ERRORCODE(L"RegGetKeySecurity failed",err); } if(ERROR_SUCCESS != (err = RegCloseKey(hRegKey))) { LOG_ERRORCODE(L"RegCloseKey failed",err); } LOG_EXIT(iReturnCode); return iReturnCode; }
NTSTATUS kuhl_m_kerberos_list(int argc, wchar_t * argv[]) { NTSTATUS status, packageStatus; KERB_QUERY_TKT_CACHE_REQUEST kerbCacheRequest = {KerbQueryTicketCacheExMessage, {0, 0}}; PKERB_QUERY_TKT_CACHE_EX_RESPONSE pKerbCacheResponse; PKERB_RETRIEVE_TKT_REQUEST pKerbRetrieveRequest; PKERB_RETRIEVE_TKT_RESPONSE pKerbRetrieveResponse; DWORD szData, i; wchar_t * filename; BOOL export = kull_m_string_args_byName(argc, argv, L"export", NULL, NULL); status = LsaCallKerberosPackage(&kerbCacheRequest, sizeof(KERB_QUERY_TKT_CACHE_REQUEST), (PVOID *) &pKerbCacheResponse, &szData, &packageStatus); if(NT_SUCCESS(status)) { if(NT_SUCCESS(packageStatus)) { for(i = 0; i < pKerbCacheResponse->CountOfTickets; i++) { kprintf(L"\n[%08x] - 0x%08x - %s", i, pKerbCacheResponse->Tickets[i].EncryptionType, kuhl_m_kerberos_ticket_etype(pKerbCacheResponse->Tickets[i].EncryptionType)); kprintf(L"\n Start/End/MaxRenew: "); kull_m_string_displayLocalFileTime((PFILETIME) &pKerbCacheResponse->Tickets[i].StartTime); kprintf(L" ; "); kull_m_string_displayLocalFileTime((PFILETIME) &pKerbCacheResponse->Tickets[i].EndTime); kprintf(L" ; "); kull_m_string_displayLocalFileTime((PFILETIME) &pKerbCacheResponse->Tickets[i].RenewTime); kprintf(L"\n Server Name : %wZ @ %wZ", &pKerbCacheResponse->Tickets[i].ServerName, &pKerbCacheResponse->Tickets[i].ServerRealm); kprintf(L"\n Client Name : %wZ @ %wZ", &pKerbCacheResponse->Tickets[i].ClientName, &pKerbCacheResponse->Tickets[i].ClientRealm); kprintf(L"\n Flags %08x : ", pKerbCacheResponse->Tickets[i].TicketFlags); kuhl_m_kerberos_ticket_displayFlags(pKerbCacheResponse->Tickets[i].TicketFlags); if(export) { szData = sizeof(KERB_RETRIEVE_TKT_REQUEST) + pKerbCacheResponse->Tickets[i].ServerName.MaximumLength; if(pKerbRetrieveRequest = (PKERB_RETRIEVE_TKT_REQUEST) LocalAlloc(LPTR, szData)) // LPTR implicates KERB_ETYPE_NULL { pKerbRetrieveRequest->MessageType = KerbRetrieveEncodedTicketMessage; pKerbRetrieveRequest->CacheOptions = /*KERB_RETRIEVE_TICKET_USE_CACHE_ONLY | */KERB_RETRIEVE_TICKET_AS_KERB_CRED; pKerbRetrieveRequest->TicketFlags = pKerbCacheResponse->Tickets[i].TicketFlags; pKerbRetrieveRequest->TargetName = pKerbCacheResponse->Tickets[i].ServerName; pKerbRetrieveRequest->TargetName.Buffer = (PWSTR) ((PBYTE) pKerbRetrieveRequest + sizeof(KERB_RETRIEVE_TKT_REQUEST)); RtlCopyMemory(pKerbRetrieveRequest->TargetName.Buffer, pKerbCacheResponse->Tickets[i].ServerName.Buffer, pKerbRetrieveRequest->TargetName.MaximumLength); status = LsaCallKerberosPackage(pKerbRetrieveRequest, szData, (PVOID *) &pKerbRetrieveResponse, &szData, &packageStatus); if(NT_SUCCESS(status)) { if(NT_SUCCESS(packageStatus)) { if(filename = kuhl_m_kerberos_generateFileName(i, &pKerbCacheResponse->Tickets[i], MIMIKATZ_KERBEROS_EXT)) { if(kull_m_file_writeData(filename, pKerbRetrieveResponse->Ticket.EncodedTicket, pKerbRetrieveResponse->Ticket.EncodedTicketSize)) kprintf(L"\n * Saved to file : %s", filename); else PRINT_ERROR_AUTO(L"kull_m_file_writeData"); LocalFree(filename); } LsaFreeReturnBuffer(pKerbRetrieveResponse); } else PRINT_ERROR(L"LsaCallAuthenticationPackage KerbRetrieveEncodedTicketMessage / Package : %08x\n", packageStatus); } else PRINT_ERROR(L"LsaCallAuthenticationPackage KerbRetrieveEncodedTicketMessage : %08x\n", status); LocalFree(pKerbRetrieveRequest); } } kprintf(L"\n"); } LsaFreeReturnBuffer(pKerbCacheResponse); } else PRINT_ERROR(L"LsaCallAuthenticationPackage KerbQueryTicketCacheEx2Message / Package : %08x\n", packageStatus); }
int LLProcessLauncher::launch(void) { // If there was already a process associated with this object, kill it. kill(); orphan(); int result = 0; PROCESS_INFORMATION pinfo; STARTUPINFOA sinfo; memset(&sinfo, 0, sizeof(sinfo)); std::string args = mExecutable; for(int i = 0; i < (int)mLaunchArguments.size(); i++) { args += " "; args += mLaunchArguments[i]; } // So retarded. Windows requires that the second parameter to CreateProcessA be a writable (non-const) string... char *args2 = new char[args.size() + 1]; strcpy(args2, args.c_str()); const char * working_directory = 0; if(!mWorkingDir.empty()) working_directory = mWorkingDir.c_str(); if( ! CreateProcessA( NULL, args2, NULL, NULL, FALSE, 0, NULL, working_directory, &sinfo, &pinfo ) ) { result = GetLastError(); LPTSTR error_str = 0; if( FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, result, 0, (LPTSTR)&error_str, 0, NULL) != 0) { char message[256]; wcstombs(message, error_str, 256); message[255] = 0; llwarns << "CreateProcessA failed: " << message << llendl; LocalFree(error_str); } if(result == 0) { // Make absolutely certain we return a non-zero value on failure. result = -1; } } else { // foo = pinfo.dwProcessId; // get your pid here if you want to use it later on // CloseHandle(pinfo.hProcess); // stops leaks - nothing else mProcessHandle = pinfo.hProcess; CloseHandle(pinfo.hThread); // stops leaks - nothing else } delete[] args2; return result; }
int make_private_security_descriptor(DWORD permissions, PSECURITY_DESCRIPTOR *psd, PACL *acl, char **error) { SID_IDENTIFIER_AUTHORITY world_auth = SECURITY_WORLD_SID_AUTHORITY; SID_IDENTIFIER_AUTHORITY nt_auth = SECURITY_NT_AUTHORITY; EXPLICIT_ACCESS ea[3]; int acl_err; int ret = FALSE; /* Initialised once, then kept around to reuse forever */ static PSID worldsid, networksid, usersid; *psd = NULL; *acl = NULL; *error = NULL; if (!got_advapi()) { *error = dupprintf("unable to load advapi32.dll"); goto cleanup; } if (!usersid) { if ((usersid = get_user_sid()) == NULL) { *error = dupprintf("unable to construct SID for current user: %s", win_strerror(GetLastError())); goto cleanup; } } if (!worldsid) { if (!AllocateAndInitializeSid(&world_auth, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &worldsid)) { *error = dupprintf("unable to construct SID for world: %s", win_strerror(GetLastError())); goto cleanup; } } if (!networksid) { if (!AllocateAndInitializeSid(&nt_auth, 1, SECURITY_NETWORK_RID, 0, 0, 0, 0, 0, 0, 0, &networksid)) { *error = dupprintf("unable to construct SID for " "local same-user access only: %s", win_strerror(GetLastError())); goto cleanup; } } memset(ea, 0, sizeof(ea)); ea[0].grfAccessPermissions = permissions; ea[0].grfAccessMode = REVOKE_ACCESS; ea[0].grfInheritance = NO_INHERITANCE; ea[0].Trustee.TrusteeForm = TRUSTEE_IS_SID; ea[0].Trustee.ptstrName = (LPTSTR)worldsid; ea[1].grfAccessPermissions = permissions; ea[1].grfAccessMode = GRANT_ACCESS; ea[1].grfInheritance = NO_INHERITANCE; ea[1].Trustee.TrusteeForm = TRUSTEE_IS_SID; ea[1].Trustee.ptstrName = (LPTSTR)usersid; ea[2].grfAccessPermissions = permissions; ea[2].grfAccessMode = REVOKE_ACCESS; ea[2].grfInheritance = NO_INHERITANCE; ea[2].Trustee.TrusteeForm = TRUSTEE_IS_SID; ea[2].Trustee.ptstrName = (LPTSTR)networksid; acl_err = p_SetEntriesInAclA(3, ea, NULL, acl); if (acl_err != ERROR_SUCCESS || *acl == NULL) { *error = dupprintf("unable to construct ACL: %s", win_strerror(acl_err)); goto cleanup; } *psd = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, SECURITY_DESCRIPTOR_MIN_LENGTH); if (!*psd) { *error = dupprintf("unable to allocate security descriptor: %s", win_strerror(GetLastError())); goto cleanup; } if (!InitializeSecurityDescriptor(*psd, SECURITY_DESCRIPTOR_REVISION)) { *error = dupprintf("unable to initialise security descriptor: %s", win_strerror(GetLastError())); goto cleanup; } if (!SetSecurityDescriptorDacl(*psd, TRUE, *acl, FALSE)) { *error = dupprintf("unable to set DACL in security descriptor: %s", win_strerror(GetLastError())); goto cleanup; } ret = TRUE; cleanup: if (!ret) { if (*psd) { LocalFree(*psd); *psd = NULL; } if (*acl) { LocalFree(*acl); *acl = NULL; } } else { sfree(*error); *error = NULL; } return ret; }
void SetException(DWORD code, EXCEPTION_RECORD *pr) { TCHAR *lpMsgBuf; lpMsgBuf = FormatError(code); if(lpMsgBuf) { PyErr_SetFromWindowsErr(code); LocalFree(lpMsgBuf); } else { switch (code) { case EXCEPTION_ACCESS_VIOLATION: /* The thread attempted to read from or write to a virtual address for which it does not have the appropriate access. */ if (pr->ExceptionInformation[0] == 0) PyErr_Format(PyExc_WindowsError, "exception: access violation reading %p", pr->ExceptionInformation[1]); else PyErr_Format(PyExc_WindowsError, "exception: access violation writing %p", pr->ExceptionInformation[1]); break; case EXCEPTION_BREAKPOINT: /* A breakpoint was encountered. */ PyErr_SetString(PyExc_WindowsError, "exception: breakpoint encountered"); break; case EXCEPTION_DATATYPE_MISALIGNMENT: /* The thread attempted to read or write data that is misaligned on hardware that does not provide alignment. For example, 16-bit values must be aligned on 2-byte boundaries, 32-bit values on 4-byte boundaries, and so on. */ PyErr_SetString(PyExc_WindowsError, "exception: datatype misalignment"); break; case EXCEPTION_SINGLE_STEP: /* A trace trap or other single-instruction mechanism signaled that one instruction has been executed. */ PyErr_SetString(PyExc_WindowsError, "exception: single step"); break; case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: /* The thread attempted to access an array element that is out of bounds, and the underlying hardware supports bounds checking. */ PyErr_SetString(PyExc_WindowsError, "exception: array bounds exceeded"); break; case EXCEPTION_FLT_DENORMAL_OPERAND: /* One of the operands in a floating-point operation is denormal. A denormal value is one that is too small to represent as a standard floating-point value. */ PyErr_SetString(PyExc_WindowsError, "exception: floating-point operand denormal"); break; case EXCEPTION_FLT_DIVIDE_BY_ZERO: /* The thread attempted to divide a floating-point value by a floating-point divisor of zero. */ PyErr_SetString(PyExc_WindowsError, "exception: float divide by zero"); break; case EXCEPTION_FLT_INEXACT_RESULT: /* The result of a floating-point operation cannot be represented exactly as a decimal fraction. */ PyErr_SetString(PyExc_WindowsError, "exception: float inexact"); break; case EXCEPTION_FLT_INVALID_OPERATION: /* This exception represents any floating-point exception not included in this list. */ PyErr_SetString(PyExc_WindowsError, "exception: float invalid operation"); break; case EXCEPTION_FLT_OVERFLOW: /* The exponent of a floating-point operation is greater than the magnitude allowed by the corresponding type. */ PyErr_SetString(PyExc_WindowsError, "exception: float overflow"); break; case EXCEPTION_FLT_STACK_CHECK: /* The stack overflowed or underflowed as the result of a floating-point operation. */ PyErr_SetString(PyExc_WindowsError, "exception: stack over/underflow"); break; case EXCEPTION_STACK_OVERFLOW: /* The stack overflowed or underflowed as the result of a floating-point operation. */ PyErr_SetString(PyExc_WindowsError, "exception: stack overflow"); break; case EXCEPTION_FLT_UNDERFLOW: /* The exponent of a floating-point operation is less than the magnitude allowed by the corresponding type. */ PyErr_SetString(PyExc_WindowsError, "exception: float underflow"); break; case EXCEPTION_INT_DIVIDE_BY_ZERO: /* The thread attempted to divide an integer value by an integer divisor of zero. */ PyErr_SetString(PyExc_WindowsError, "exception: integer divide by zero"); break; case EXCEPTION_INT_OVERFLOW: /* The result of an integer operation caused a carry out of the most significant bit of the result. */ PyErr_SetString(PyExc_WindowsError, "exception: integer overflow"); break; case EXCEPTION_PRIV_INSTRUCTION: /* The thread attempted to execute an instruction whose operation is not allowed in the current machine mode. */ PyErr_SetString(PyExc_WindowsError, "exception: priviledged instruction"); break; case EXCEPTION_NONCONTINUABLE_EXCEPTION: /* The thread attempted to continue execution after a noncontinuable exception occurred. */ PyErr_SetString(PyExc_WindowsError, "exception: nocontinuable"); break; default: printf("error %d\n", code); PyErr_Format(PyExc_WindowsError, "exception code 0x%08x", code); break; } } }
BOOL OpenPortalHandleFromGUID(GUID guid, PHANDLE phPortalHandle) { int memberIndex = 0; BOOL bResult = TRUE; HDEVINFO hDevInfo; SP_DEVICE_INTERFACE_DATA deviceInterfaceData; PSP_DEVICE_INTERFACE_DETAIL_DATA pInterfaceDetailData = NULL; HIDD_ATTRIBUTES attributes; ULONG requiredLength=0; hDevInfo = SetupDiGetClassDevs(&guid, NULL, NULL, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT); deviceInterfaceData.cbSize = sizeof(SP_INTERFACE_DEVICE_DATA); *phPortalHandle = NULL; for(memberIndex = 0; SetupDiEnumDeviceInterfaces(hDevInfo, NULL, &guid, memberIndex, &deviceInterfaceData); memberIndex++) { SetupDiGetDeviceInterfaceDetail(hDevInfo, &deviceInterfaceData, NULL, 0, &requiredLength, NULL); //we got the size, allocate buffer pInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)LocalAlloc(LPTR, requiredLength); assert(pInterfaceDetailData); //get the interface detailed data pInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA); if (!SetupDiGetDeviceInterfaceDetail(hDevInfo, &deviceInterfaceData, pInterfaceDetailData, requiredLength, &requiredLength, NULL)) { continue; } *phPortalHandle = CreateFile ( pInterfaceDetailData->DevicePath, GENERIC_EXECUTE | GENERIC_ALL, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); LocalFree(pInterfaceDetailData); pInterfaceDetailData = NULL; if(guid == xbox_guid) { break; // we are done. xbox_guid does not have HID attributes } if (*phPortalHandle != INVALID_HANDLE_VALUE) { if (HidD_GetAttributes(*phPortalHandle , &attributes)) { if (((attributes.VendorID == 0x12ba) || (attributes.VendorID == 0x54c)) || (attributes.VendorID == 0x1430)) { if ((attributes.ProductID == 0x150) || (attributes.ProductID == 0x967)) { break; // found the portal. leave the handle open } } } CloseHandle(*phPortalHandle); *phPortalHandle = NULL; } } SetupDiDestroyDeviceInfoList(hDevInfo); return (*phPortalHandle != NULL); }
void InitRunDlg(HWND hDlg, LPRUNDLG_DATA lprd) { HWND hCB; int i; #ifdef WINNT HANDLE hThread = NULL; DWORD dwDummy; #endif if (lprd->lpszTitle) SetWindowText(hDlg, lprd->lpszTitle); if (lprd->lpszPrompt) { SetDlgItemText(hDlg, IDD_PROMPT, lprd->lpszPrompt); } if (lprd->hIcon) { Static_SetIcon(GetDlgItem(hDlg, IDD_ICON), lprd->hIcon); } if (lprd->dwFlags & RFD_NOBROWSE) { HWND hBrowse; hBrowse = GetDlgItem(hDlg, IDD_BROWSE); ExchangeWindowPos(hBrowse, GetDlgItem(hDlg, IDCANCEL)); ExchangeWindowPos(hBrowse, GetDlgItem(hDlg, IDOK)); ShowWindow(hBrowse, SW_HIDE); } if (lprd->dwFlags & RFD_NOSHOWOPEN) { ShowWindow(GetDlgItem(hDlg, IDD_RUNDLGOPENPROMPT), SW_HIDE); } #ifdef SHOWSTATES /* Note that we need to fill this list first so that the SELCHANGE * message sent below will do the right thing. */ hCB = GetDlgItem(hDlg, IDD_STATE); for (i = 0; i < ARRAYSIZE(pnStates); ++i) { if (SendMessage(hCB, CB_ADDSTRING, 0, (LPARAM)(LPTSTR)szStates[i]) < 0) { break; } } SendMessage(hCB, CB_SETCURSEL, 0, 0L); #endif hCB = GetDlgItem(hDlg, IDD_COMMAND); SendMessage(hCB, CB_LIMITTEXT, MAX_PATH-1, 0L); OpenRunDlgMRU(); if (g_hMRURunDlg) { int nMax; TCHAR szCommand[MAX_PATH]; for (nMax=EnumMRUList(g_hMRURunDlg, -1, NULL, 0), i=0; i<nMax; ++i) { if (EnumMRUList(g_hMRURunDlg, i, szCommand, ARRAYSIZE(szCommand)) > 0) { PSTARTINFO pStartInfo; /* Parse the line into the STARTINFO struct */ pStartInfo = ParseIniLine(szCommand); /* The command to run goes in the combobox. */ if (SendMessage(hCB, CB_ADDSTRING, 0, (LPARAM)(LPTSTR)szCommand) != i) { if (pStartInfo) { LocalFree((HLOCAL)pStartInfo); } } else { SendMessage(hCB, CB_SETITEMDATA, i, (LPARAM)(LPSTARTINFO)pStartInfo); } } } } if (!(lprd->dwFlags & RFD_NODEFFILE)) { SendMessage(hCB, CB_SETCURSEL, 0, 0L); } SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDD_COMMAND, CBN_SELCHANGE), (LPARAM) hCB); SetWindowLong(hDlg, DWL_USER, (LONG)lprd); // Make sure the OK button is initialized properly EnableOKButton(hDlg, NULL); #ifdef WINNT // // Create the thread that will take care of the // "Run in Separate Memory Space" checkbox in the background. // if (lprd->dwFlags & RFD_NOSEPMEMORY_BOX) { ShowWindow(GetDlgItem(hDlg, IDD_RUNINSEPARATE), SW_HIDE); } else { Assert( g_hCheckNow==NULL ); g_hCheckNow = CreateEvent( NULL, TRUE, FALSE, NULL ); if (g_hCheckNow) { g_bCheckRunInSep = TRUE; hThread = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)CheckRunInSeparateThread, (LPVOID)hDlg, 0, &dwDummy ); } if ((g_hCheckNow==NULL) || (!g_bCheckRunInSep) || (hThread==NULL)) { // // We've encountered a problem setting up, so make the user // choose. // CheckDlgButton( hDlg, IDD_RUNINSEPARATE, 1 ); EnableWindow( GetDlgItem( hDlg, IDD_RUNINSEPARATE ), TRUE ); g_bCheckRunInSep = FALSE; } // // These calls will just do nothing if either handle is NULL. // if (hThread) CloseHandle( hThread ); if (g_hCheckNow) SetEvent( g_hCheckNow ); } #endif // WINNT }
void ProgramRunner::launchProcess( int child_stdout ) { #ifdef _WIN32 stringstream ss; for( unsigned i=0; i < _argv.size(); i++ ) { if (i) ss << ' '; if (_argv[i].find(' ') == string::npos) ss << _argv[i]; else { ss << '"'; // escape all embedded quotes for (size_t j=0; j<_argv[i].size(); ++j) { if (_argv[i][j]=='"') ss << '"'; ss << _argv[i][j]; } ss << '"'; } } string args = ss.str(); boost::scoped_array<TCHAR> args_tchar (new TCHAR[args.size() + 1]); size_t i; for(i=0; i < args.size(); i++) args_tchar[i] = args[i]; args_tchar[i] = 0; HANDLE h = (HANDLE)_get_osfhandle(child_stdout); verify(h != INVALID_HANDLE_VALUE); verify(SetHandleInformation(h, HANDLE_FLAG_INHERIT, 1)); STARTUPINFO si; ZeroMemory(&si, sizeof(si)); si.cb = sizeof(si); si.hStdError = h; si.hStdOutput = h; si.dwFlags |= STARTF_USESTDHANDLES; PROCESS_INFORMATION pi; ZeroMemory(&pi, sizeof(pi)); bool success = CreateProcess( NULL, args_tchar.get(), NULL, NULL, true, 0, NULL, NULL, &si, &pi) != 0; if (!success) { LPSTR lpMsgBuf=0; DWORD dw = GetLastError(); FormatMessageA( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&lpMsgBuf, 0, NULL ); stringstream ss; ss << "couldn't start process " << _argv[0] << "; " << lpMsgBuf; uassert(14042, ss.str(), success); LocalFree(lpMsgBuf); } CloseHandle(pi.hThread); _pid = ProcessId::fromNative(pi.dwProcessId); registry._handles.insert( make_pair( _pid, pi.hProcess ) ); #else scoped_array<const char *> argvStorage( new const char* [_argv.size()+1] ); const char** argv = argvStorage.get(); for (unsigned i=0; i < _argv.size(); i++) { argv[i] = _argv[i].c_str(); } argv[_argv.size()] = 0; scoped_array<const char *> envStorage( new const char* [2] ); const char** env = envStorage.get(); env[0] = NULL; env[1] = NULL; bool isMongos = ( _argv[0].find( "mongos" ) != string::npos ); pid_t nativePid = fork(); _pid = ProcessId::fromNative(nativePid); // Async signal unsafe functions should not be called in the child process. verify( nativePid != -1 ); if ( nativePid == 0 ) { // DON'T ASSERT IN THIS BLOCK - very bad things will happen if ( dup2( child_stdout, STDOUT_FILENO ) == -1 || dup2( child_stdout, STDERR_FILENO ) == -1 ) { // Async signal unsafe code reporting a terminal error condition. cout << "Unable to dup2 child output: " << errnoWithDescription() << endl; ::_Exit(-1); //do not pass go, do not call atexit handlers } // Heap-check for mongos only. 'argv[0]' must be in the path format. if ( isMongos ) { #if defined(HEAP_CHECKING) env[0] = "HEAPCHECK=normal"; env[1] = NULL; // NOTE execve is async signal safe, but it is not clear that execvpe is async // signal safe. execvpe( argv[ 0 ], const_cast<char**>(argv) , const_cast<char**>(env) ); #endif // HEAP_CHECKING } // NOTE execve is async signal safe, but it is not clear that execvp is async // signal safe. execvp( argv[ 0 ], const_cast<char**>(argv) ); // Async signal unsafe code reporting a terminal error condition. cout << "Unable to start program " << argv[0] << ' ' << errnoWithDescription() << endl; ::_Exit(-1); } #endif }
// get error message from system const wxChar *wxSysErrorMsg(unsigned long nErrCode) { if ( nErrCode == 0 ) nErrCode = wxSysErrorCode(); #if defined(__WXMSW__) && !defined(__WXMICROWIN__) static wxChar s_szBuf[1024]; // get error message from system LPVOID lpMsgBuf; if ( ::FormatMessage ( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, nErrCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf, 0, NULL ) == 0 ) { // if this happens, something is seriously wrong, so don't use _() here // for safety wxSprintf(s_szBuf, wxS("unknown error %lx"), nErrCode); return s_szBuf; } // copy it to our buffer and free memory // Crashes on SmartPhone (FIXME) #if !defined(__SMARTPHONE__) /* of WinCE */ if( lpMsgBuf != 0 ) { wxStrlcpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf)); LocalFree(lpMsgBuf); // returned string is capitalized and ended with '\r\n' - bad s_szBuf[0] = (wxChar)wxTolower(s_szBuf[0]); size_t len = wxStrlen(s_szBuf); if ( len > 0 ) { // truncate string if ( s_szBuf[len - 2] == wxS('\r') ) s_szBuf[len - 2] = wxS('\0'); } } else #endif // !__SMARTPHONE__ { s_szBuf[0] = wxS('\0'); } return s_szBuf; #else // !__WXMSW__ #if wxUSE_UNICODE static wchar_t s_wzBuf[1024]; wxConvCurrent->MB2WC(s_wzBuf, strerror((int)nErrCode), WXSIZEOF(s_wzBuf) - 1); return s_wzBuf; #else return strerror((int)nErrCode); #endif #endif // __WXMSW__/!__WXMSW__ }
OsStatus OsProcessWnt::launch(UtlString &rAppName, UtlString parameters[],OsPath &startupDir, OsProcessPriorityClass prioClass, UtlBoolean bExeclusive, UtlBoolean bIgnoreChildSignals) { OsStatus retval = OS_FAILED; STARTUPINFO StartupInfo; PROCESS_INFORMATION ProcessInformation; UtlString cmdLine = startupDir + OsPath::separator; cmdLine += rAppName; /* int saved_stderr = dup(2); int saved_stdout = dup(1); int saved_stdin = dup(0); */ //build one string out of the array passed in int parameterCount = 0; while (!parameters[parameterCount].isNull()) { if(parameters[parameterCount].index(" ") != UTL_NOT_FOUND) parameters[parameterCount] = "\"" + parameters[parameterCount] + "\""; cmdLine.append(" "); cmdLine.append(parameters[parameterCount]); parameterCount++; } //clear out structure memset(&StartupInfo,'\0',sizeof(STARTUPINFO)); StartupInfo.cb = sizeof(STARTUPINFO); StartupInfo.lpReserved = NULL; StartupInfo.wShowWindow = SW_MINIMIZE|SW_HIDE; StartupInfo.lpDesktop = NULL; StartupInfo.lpTitle = NULL; StartupInfo.dwFlags |= STARTF_USESTDHANDLES; //now it's time to redirect the output,input and error streams if (mStdErrorFilename.length()) StartupInfo.hStdError = mStdErrorHandle; else StartupInfo.hStdError =GetStdHandle(STD_ERROR_HANDLE); if (mStdInputFilename.length()) StartupInfo.hStdInput = mStdInputHandle; else StartupInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE); if (mStdOutputFilename.length()) StartupInfo.hStdOutput = mStdOutputHandle; else StartupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE); //now apply the env variables the user may have set ApplyEnv(); //3...2...1... LAUNCH!!!! int retcode = CreateProcess( NULL, // name of executable module (null because we want to execute all commands) // even things such as dir (char *)cmdLine.data(), // command line string NULL, NULL, //this originally was TRUE but the web browser was never coming back. FALSE, // handle inheritance flag // CREATE_NEW_CONSOLE, CREATE_NO_WINDOW | DETACHED_PROCESS, // creation flags NULL, // new environment block startupDir.data(), // startupdir &StartupInfo, &ProcessInformation ); if (retcode != 0) { //translate the incoming priority to Wnt values DWORD wntPrio = NORMAL_PRIORITY_CLASS; switch(prioClass) { case IdlePriorityClass: wntPrio = IDLE_PRIORITY_CLASS; break; case NormalPriorityClass: wntPrio = NORMAL_PRIORITY_CLASS; break; case HighPriorityClass: wntPrio = HIGH_PRIORITY_CLASS; break; case RealtimePriorityClass: wntPrio = REALTIME_PRIORITY_CLASS; break; default: osPrintf("**** Invalid process priority class specified!\n"); osPrintf("*** Defaulting to NormalPriorityClass *** \n"); break; } if (!SetPriorityClass(ProcessInformation.hProcess, wntPrio)) { osPrintf("*** Could not change the process priority on launch ***\n"); osPrintf("*** Priority will be the parents priority ! ***\n"); } if (bExeclusive) { //here is where we check if a process by the same name is already running } mPID = ProcessInformation.dwProcessId; mParentPID = getpid(); mhProcess = ProcessInformation.hProcess; mhThread = ProcessInformation.hThread; retval = OS_SUCCESS; } else { LPVOID lpMsgBuf; FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language (LPTSTR) &lpMsgBuf, 0, NULL ); osPrintf("***** ERROR FROM LAUNCH: %s",(LPCTSTR)lpMsgBuf); // Free the buffer. LocalFree( lpMsgBuf ); } /* dup2(saved_stderr,2); dup2(saved_stdout,1); dup2(saved_stdin, 0); */ return retval; }
PSP_DEVICE_INTERFACE_DETAIL_DATA GetDeviceInterfaceDetailData( _In_ LPGUID InterfaceGuid ) { HDEVINFO HardwareDeviceInfo; SP_DEVICE_INTERFACE_DATA DeviceInterfaceData; PSP_DEVICE_INTERFACE_DETAIL_DATA DeviceInterfaceDetailData = NULL; ULONG Length, RequiredLength = 0; BOOL bResult; HardwareDeviceInfo = SetupDiGetClassDevs( InterfaceGuid, NULL, NULL, (DIGCF_PRESENT | DIGCF_DEVICEINTERFACE)); if (HardwareDeviceInfo == INVALID_HANDLE_VALUE) { printf("SetupDiGetClassDevs failed!\n"); exit(1); } DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA); bResult = SetupDiEnumDeviceInterfaces(HardwareDeviceInfo, 0, InterfaceGuid, 0, &DeviceInterfaceData); if (bResult == FALSE) { LPVOID lpMsgBuf = NULL; if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR) &lpMsgBuf, 0, NULL )) { printf("Error: %s", (LPSTR)lpMsgBuf); LocalFree(lpMsgBuf); } printf("SetupDiEnumDeviceInterfaces failed.\n"); SetupDiDestroyDeviceInfoList(HardwareDeviceInfo); exit(1); } SetupDiGetDeviceInterfaceDetail( HardwareDeviceInfo, &DeviceInterfaceData, NULL, 0, &RequiredLength, NULL ); DeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA) LocalAlloc(LMEM_FIXED, RequiredLength); if (DeviceInterfaceDetailData == NULL) { SetupDiDestroyDeviceInfoList(HardwareDeviceInfo); printf("Failed to allocate memory.\n"); exit(1); } DeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA); Length = RequiredLength; bResult = SetupDiGetDeviceInterfaceDetail( HardwareDeviceInfo, &DeviceInterfaceData, DeviceInterfaceDetailData, Length, &RequiredLength, NULL); if (bResult == FALSE) { LPVOID lpMsgBuf = NULL; if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR) &lpMsgBuf, 0, NULL)) { MessageBox(NULL, (LPCTSTR) lpMsgBuf, "Error", MB_OK); LocalFree(lpMsgBuf); } SetupDiDestroyDeviceInfoList(HardwareDeviceInfo); printf("Error in SetupDiGetDeviceInterfaceDetail\n"); LocalFree(DeviceInterfaceDetailData); DeviceInterfaceDetailData = NULL; exit(1); } SetupDiDestroyDeviceInfoList(HardwareDeviceInfo); return DeviceInterfaceDetailData; }
bool vrpn_Semaphore::init() { #ifdef sgi if (vrpn_Semaphore::ppaArena==NULL) { vrpn_Semaphore::allocArena(); } if (cResources==1) { fUsingLock=true; ps=NULL; // use lock instead of semaphore if ((l = usnewlock(vrpn_Semaphore::ppaArena)) == NULL) { fprintf(stderr,"vrpn_Semaphore::vrpn_Semaphore: error allocating lock from arena.\n"); return false; } } else { fUsingLock=false; l=NULL; if ((ps = usnewsema(vrpn_Semaphore::ppaArena, cResources)) == NULL) { fprintf(stderr,"vrpn_Semaphore::vrpn_Semaphore: error allocating semaphore from arena.\n"); return false; } } #elif defined(_WIN32) // args are security, initial count, max count, and name // TCH 20 Feb 2001 - Make the PC behavior closer to the SGI behavior. int numMax = cResources; if (numMax < 1) { numMax = 1; } hSemaphore = CreateSemaphore(NULL, cResources, numMax, NULL); if (!hSemaphore) { // get error info from windows (from FormatMessage help page) LPVOID lpMsgBuf; FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language (LPTSTR) &lpMsgBuf, 0, NULL ); fprintf(stderr,"vrpn_Semaphore::vrpn_Semaphore: error creating semaphore, " "WIN32 CreateSemaphore call caused the following error: %s\n", (LPTSTR) lpMsgBuf); // Free the buffer. LocalFree( lpMsgBuf ); return false; } #elif defined(__APPLE__) // We need to use sem_open on the mac because sem_init is not implemented int numMax = cResources; if (numMax < 1) { numMax = 1; } char *tempname = new char[100]; sprintf(tempname, "/tmp/vrpn_sem.XXXXXXX"); semaphore = sem_open(mktemp(tempname), O_CREAT, 0600, numMax); if (semaphore == SEM_FAILED) { perror("vrpn_Semaphore::vrpn_Semaphore: error opening semaphore"); delete [] tempname; return false; } delete [] tempname; #else // Posix threads are the default. // We use sem_init on linux (instead of sem_open). int numMax = cResources; if (numMax < 1) { numMax = 1; } semaphore = new sem_t; if (sem_init(semaphore, 0, numMax) != 0) { perror("vrpn_Semaphore::vrpn_Semaphore: error initializing semaphore"); return false; } #endif return true; }
// 0 if it can't get the resource, 1 if it can // -1 if fail int vrpn_Semaphore::condP() { int iRetVal=1; #ifdef sgi if (fUsingLock) { // don't spin at all iRetVal = uscsetlock(l, 0); if (iRetVal<=0) { perror("vrpn_Semaphore::condP: uscsetlock:"); return -1; } } else { iRetVal = uscpsema(ps); if (iRetVal<=0) { perror("vrpn_Semaphore::condP: uscpsema:"); return -1; } } #elif defined(_WIN32) switch (WaitForSingleObject(hSemaphore, 0)) { case WAIT_OBJECT_0: // got the resource break; case WAIT_TIMEOUT: // resource not free iRetVal=0; break; case WAIT_ABANDONED: ALL_ASSERT(0,"vrpn_Semaphore::condP: thread holding resource died"); return -1; break; case WAIT_FAILED: // get error info from windows (from FormatMessage help page) LPVOID lpMsgBuf; FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language (LPTSTR) &lpMsgBuf, 0, NULL ); fprintf(stderr, "Semaphore::condP: error waiting for resource, " "WIN32 WaitForSingleObject call caused the following error: %s", (LPTSTR) lpMsgBuf); // Free the buffer. LocalFree( lpMsgBuf ); return -1; break; default: ALL_ASSERT(0,"vrpn_Semaphore::p: unknown return code"); return -1; } #else // Posix by default iRetVal = sem_trywait(semaphore); if (iRetVal == 0) { iRetVal = 1; } else if (errno == EAGAIN) { iRetVal = 0; } else { perror("vrpn_Semaphore::condP: "); iRetVal = -1; } #endif return iRetVal; }
// allow different users to read\write\delete files in lock directory // in case of any error just log it and don't stop engine execution void adjustLockDirectoryAccess(const char* pathname) { PSECURITY_DESCRIPTOR pSecDesc = NULL; PSID pSID_Users = NULL; PSID pSID_Administrators = NULL; PACL pNewACL = NULL; try { // We should pass root directory in format "C:\" into GetVolumeInformation(). // In case of pathname is not local folder (i.e. \\share\folder) let // GetVolumeInformation() return an error. Firebird::PathName root(pathname); const size_t pos = root.find(':', 0); if (pos == 1) { root.erase(pos + 1, root.length()); PathUtils::ensureSeparator(root); } DWORD fsflags; if (!GetVolumeInformation(root.c_str(), NULL, 0, NULL, NULL, &fsflags, NULL, 0)) Firebird::system_error::raise("GetVolumeInformation"); if (!(fsflags & FS_PERSISTENT_ACLS)) return; // Adjust security for our new folder : allow BUILTIN\Users group to // read\write\delete files PACL pOldACL = NULL; if (GetNamedSecurityInfo((LPSTR) pathname, SE_FILE_OBJECT, DACL_SECURITY_INFORMATION, NULL, NULL, &pOldACL, NULL, &pSecDesc) != ERROR_SUCCESS) { Firebird::system_error::raise("GetNamedSecurityInfo"); } SID_IDENTIFIER_AUTHORITY sidAuth = SECURITY_NT_AUTHORITY; if (!AllocateAndInitializeSid(&sidAuth, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_USERS, 0, 0, 0, 0, 0, 0, &pSID_Users)) { Firebird::system_error::raise("AllocateAndInitializeSid"); } if (!AllocateAndInitializeSid(&sidAuth, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &pSID_Administrators)) { Firebird::system_error::raise("AllocateAndInitializeSid"); } EXPLICIT_ACCESS eas[2]; memset(eas, 0, sizeof(eas)); eas[0].grfAccessPermissions = FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE; eas[0].grfAccessMode = GRANT_ACCESS; eas[0].grfInheritance = SUB_OBJECTS_ONLY_INHERIT; eas[0].Trustee.TrusteeForm = TRUSTEE_IS_SID; eas[0].Trustee.TrusteeType = TRUSTEE_IS_GROUP; eas[0].Trustee.ptstrName = (LPSTR) pSID_Users; eas[1].grfAccessPermissions = FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE; eas[1].grfAccessMode = GRANT_ACCESS; eas[1].grfInheritance = SUB_OBJECTS_ONLY_INHERIT; eas[1].Trustee.TrusteeForm = TRUSTEE_IS_SID; eas[1].Trustee.TrusteeType = TRUSTEE_IS_GROUP; eas[1].Trustee.ptstrName = (LPSTR) pSID_Administrators; if (SetEntriesInAcl(2, eas, pOldACL, &pNewACL) != ERROR_SUCCESS) Firebird::system_error::raise("SetEntriesInAcl"); if (SetNamedSecurityInfo((LPSTR) pathname, SE_FILE_OBJECT, DACL_SECURITY_INFORMATION, NULL, NULL, pNewACL, NULL) != ERROR_SUCCESS) { Firebird::system_error::raise("SetNamedSecurityInfo"); } } catch (const Firebird::Exception& ex) { Firebird::string str; str.printf("Error adjusting access rights for folder \"%s\" :", pathname); iscLogException(str.c_str(), ex); } if (pSID_Users) { FreeSid(pSID_Users); } if (pSID_Administrators) { FreeSid(pSID_Administrators); } if (pNewACL) { LocalFree(pNewACL); } if (pSecDesc) { LocalFree(pSecDesc); } }
int MachineInstaller::PerformMachineInstallSetup() { wchar_t packageName[512]; if (!findPackageFromEmbeddedZip(packageName, sizeof(packageName))) { MessageBox(NULL, L"Corrupt installer", L"Cannot find package name for installer, is it created correctly?", MB_OK); return ERROR_INVALID_PARAMETER; } wchar_t machineInstallFolder[MAX_PATH]; SHGetFolderPath(NULL, CSIDL_COMMON_APPDATA, NULL, SHGFP_TYPE_CURRENT, machineInstallFolder); wcscat(machineInstallFolder, L"\\SquirrelMachineInstalls"); // NB: This is the DACL for Program Files wchar_t sddl[512] = L"D:PAI(A;;FA;;;S-1-5-80-956008885-3418522649-1831038044-1853292631-2271478464)(A;CIIO;GA;;;S-1-5-80-956008885-3418522649-1831038044-1853292631-2271478464)(A;;0x1301bf;;;SY)(A;OICIIO;GA;;;SY)(A;;0x1301bf;;;BA)(A;OICIIO;GA;;;BA)(A;;0x1200a9;;;BU)(A;OICIIO;GXGR;;;BU)(A;OICIIO;GA;;;CO)"; if (IsWindows8OrGreater()) { // Add ALL APPLICATION PACKAGES account (Only available on Windows 8 and greater) wcscat(sddl, L"(A;;0x1200a9;;;AC)(A;OICIIO;GXGR;;;AC)"); } PSECURITY_DESCRIPTOR descriptor; ConvertStringSecurityDescriptorToSecurityDescriptor( sddl, SDDL_REVISION_1, &descriptor, NULL); SECURITY_ATTRIBUTES attrs; attrs.nLength = sizeof(SECURITY_ATTRIBUTES); attrs.bInheritHandle = false; attrs.lpSecurityDescriptor = descriptor; if (!CreateDirectory(machineInstallFolder, &attrs) && GetLastError() != ERROR_ALREADY_EXISTS) { LocalFree(descriptor); return GetLastError(); } LocalFree(descriptor); wcscat(machineInstallFolder, L"\\"); wcscat(machineInstallFolder, packageName); wcscat(machineInstallFolder, L".exe"); wchar_t ourFile[MAX_PATH]; HMODULE hMod = GetModuleHandle(NULL); GetModuleFileName(hMod, ourFile, _countof(ourFile)); if (!CopyFile(ourFile, machineInstallFolder, false)) { return GetLastError(); } HKEY runKey; DWORD dontcare; if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &runKey, &dontcare) != ERROR_SUCCESS) { return GetLastError(); } wcscat_s(machineInstallFolder, L" --checkInstall"); if (RegSetValueEx(runKey, packageName, 0, REG_SZ, (BYTE*)machineInstallFolder, (wcsnlen(machineInstallFolder, sizeof(machineInstallFolder)) + 1) * sizeof(wchar_t)) != ERROR_SUCCESS) { return GetLastError(); } RegCloseKey(runKey); return 0; }
void SingleFace::ParseCmdString(PWSTR lpCmdLine) { const WCHAR KEY_DEPTH[] = L"-Depth"; const WCHAR KEY_COLOR[] = L"-Color"; const WCHAR KEY_NEAR_MODE[] = L"-NearMode"; const WCHAR KEY_DEFAULT_DISTANCE_MODE[] = L"-DefaultDistanceMode"; const WCHAR KEY_SEATED_SKELETON_MODE[] = L"-SeatedSkeleton"; const WCHAR STR_NUI_IMAGE_TYPE_DEPTH[] = L"DEPTH"; const WCHAR STR_NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX[] = L"PLAYERID"; const WCHAR STR_NUI_IMAGE_TYPE_COLOR[] = L"RGB"; const WCHAR STR_NUI_IMAGE_TYPE_COLOR_YUV[] = L"YUV"; const WCHAR STR_NUI_IMAGE_RESOLUTION_80x60[] = L"80x60"; const WCHAR STR_NUI_IMAGE_RESOLUTION_320x240[] = L"320x240"; const WCHAR STR_NUI_IMAGE_RESOLUTION_640x480[] = L"640x480"; const WCHAR STR_NUI_IMAGE_RESOLUTION_1280x960[] = L"1280x960"; enum TOKEN_ENUM { TOKEN_ERROR, TOKEN_DEPTH, TOKEN_COLOR, TOKEN_NEARMODE, TOKEN_DEFAULTDISTANCEMODE, TOKEN_SEATEDSKELETON }; int argc = 0; LPWSTR *argv = CommandLineToArgvW(lpCmdLine, &argc); for(int i = 0; i < argc; i++) { NUI_IMAGE_TYPE* pType = NULL; NUI_IMAGE_RESOLUTION* pRes = NULL; TOKEN_ENUM tokenType = TOKEN_ERROR; PWCHAR context = NULL; PWCHAR token = wcstok_s(argv[i], L":", &context); if(0 == wcsncmp(token, KEY_DEPTH, ARRAYSIZE(KEY_DEPTH))) { tokenType = TOKEN_DEPTH; pType = &m_depthType; pRes = &m_depthRes; } else if(0 == wcsncmp(token, KEY_COLOR, ARRAYSIZE(KEY_COLOR))) { tokenType = TOKEN_COLOR; pType = &m_colorType; pRes = &m_colorRes; } else if(0 == wcsncmp(token, KEY_NEAR_MODE, ARRAYSIZE(KEY_NEAR_MODE))) { tokenType = TOKEN_NEARMODE; m_bNearMode = TRUE; } else if(0 == wcsncmp(token, KEY_DEFAULT_DISTANCE_MODE, ARRAYSIZE(KEY_DEFAULT_DISTANCE_MODE))) { tokenType = TOKEN_DEFAULTDISTANCEMODE; m_bNearMode = FALSE; } else if(0 == wcsncmp(token, KEY_SEATED_SKELETON_MODE, ARRAYSIZE(KEY_SEATED_SKELETON_MODE))) { tokenType = TOKEN_SEATEDSKELETON; m_bSeatedSkeletonMode = TRUE; } if(tokenType == TOKEN_DEPTH || tokenType == TOKEN_COLOR) { _ASSERT(pType != NULL && pRes != NULL); while((token = wcstok_s(NULL, L":", &context)) != NULL) { if(0 == wcsncmp(token, STR_NUI_IMAGE_TYPE_DEPTH, ARRAYSIZE(STR_NUI_IMAGE_TYPE_DEPTH))) { *pType = NUI_IMAGE_TYPE_DEPTH; } else if(0 == wcsncmp(token, STR_NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX, ARRAYSIZE(STR_NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX))) { *pType = NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX; } else if(0 == wcsncmp(token, STR_NUI_IMAGE_TYPE_COLOR, ARRAYSIZE(STR_NUI_IMAGE_TYPE_COLOR))) { *pType = NUI_IMAGE_TYPE_COLOR; } else if(0 == wcsncmp(token, STR_NUI_IMAGE_TYPE_COLOR_YUV, ARRAYSIZE(STR_NUI_IMAGE_TYPE_COLOR_YUV))) { *pType = NUI_IMAGE_TYPE_COLOR_YUV; } else if(0 == wcsncmp(token, STR_NUI_IMAGE_RESOLUTION_80x60, ARRAYSIZE(STR_NUI_IMAGE_RESOLUTION_80x60))) { *pRes = NUI_IMAGE_RESOLUTION_80x60; } else if(0 == wcsncmp(token, STR_NUI_IMAGE_RESOLUTION_320x240, ARRAYSIZE(STR_NUI_IMAGE_RESOLUTION_320x240))) { *pRes = NUI_IMAGE_RESOLUTION_320x240; } else if(0 == wcsncmp(token, STR_NUI_IMAGE_RESOLUTION_640x480, ARRAYSIZE(STR_NUI_IMAGE_RESOLUTION_640x480))) { *pRes = NUI_IMAGE_RESOLUTION_640x480; } else if(0 == wcsncmp(token, STR_NUI_IMAGE_RESOLUTION_1280x960, ARRAYSIZE(STR_NUI_IMAGE_RESOLUTION_1280x960))) { *pRes = NUI_IMAGE_RESOLUTION_1280x960; } } } } if(argv) LocalFree(argv); }
//MailSlot of flush DNS cache Monitor bool __fastcall FlushDNSMailSlotMonitor( void) { //System security setting std::shared_ptr<char> ACL_Buffer(new char[FILE_BUFFER_SIZE]()); memset(ACL_Buffer.get(), 0, FILE_BUFFER_SIZE); SECURITY_ATTRIBUTES SecurityAttributes; SECURITY_DESCRIPTOR SecurityDescriptor; memset(&SecurityAttributes, 0, sizeof(SECURITY_ATTRIBUTES)); memset(&SecurityDescriptor, 0, sizeof(SECURITY_DESCRIPTOR)); PSID SID_Value = nullptr; InitializeSecurityDescriptor(&SecurityDescriptor, SECURITY_DESCRIPTOR_REVISION); InitializeAcl((PACL)ACL_Buffer.get(), FILE_BUFFER_SIZE, ACL_REVISION); ConvertStringSidToSidW(SID_ADMINISTRATORS_GROUP, &SID_Value); AddAccessAllowedAce((PACL)ACL_Buffer.get(), ACL_REVISION, GENERIC_ALL, SID_Value); SetSecurityDescriptorDacl(&SecurityDescriptor, true, (PACL)ACL_Buffer.get(), false); SecurityAttributes.lpSecurityDescriptor = &SecurityDescriptor; SecurityAttributes.bInheritHandle = true; //Create mailslot. HANDLE hSlot = CreateMailslotW(MAILSLOT_NAME, FILE_BUFFER_SIZE - 1U, MAILSLOT_WAIT_FOREVER, &SecurityAttributes); if (hSlot == INVALID_HANDLE_VALUE) { LocalFree(SID_Value); PrintError(LOG_LEVEL_2, LOG_ERROR_SYSTEM, L"Create mailslot error", GetLastError(), nullptr, 0); return false; } ACL_Buffer.reset(); LocalFree(SID_Value); //Initialization std::shared_ptr<wchar_t> lpszBuffer(new wchar_t[FILE_BUFFER_SIZE]()); wmemset(lpszBuffer.get(), 0, FILE_BUFFER_SIZE); DWORD cbMessage = 0; BOOL Result = 0; //MailSlot monitor for (;;) { Sleep(LOOP_INTERVAL_TIME_NO_DELAY); //Reset parameters. wmemset(lpszBuffer.get(), 0, FILE_BUFFER_SIZE); cbMessage = 0; //Read message from mailslot. Result = ReadFile(hSlot, lpszBuffer.get(), FILE_BUFFER_SIZE, &cbMessage, nullptr); if (Result == FALSE) { PrintError(LOG_LEVEL_3, LOG_ERROR_SYSTEM, L"MailSlot read messages error", GetLastError(), nullptr, 0); CloseHandle(hSlot); return false; } else if (memcmp(lpszBuffer.get(), MAILSLOT_MESSAGE_FLUSH_DNS, sizeof(wchar_t) * wcslen(MAILSLOT_MESSAGE_FLUSH_DNS)) == 0) { FlushAllDNSCache(); } else { Sleep(LOOP_INTERVAL_TIME_MONITOR); } } //Monitor terminated CloseHandle(hSlot); PrintError(LOG_LEVEL_2, LOG_ERROR_SYSTEM, L"MailSlot module Monitor terminated", 0, nullptr, 0); return false; }
int LogLastError(char* szFilePath, long llastLineCode, char* szModuleCode, long lSystemCode, long lMiscCode, char* pszModuleErrorString, char* pAddInfo1, char* pAddInfo2, char* pAddInfo3) { char* pszFinalErrorString = NULL; LPVOID pMsgBuf = NULL; char* pchBackChar = NULL; char* pszFindChar = NULL; char szFinalErrLogFile[MAX_PATH + 100] = {0}; char szDateTime[101] = {0}; char szDate[101] = {0}; char szLineCode[25] = {0}; char szSystemCode[25] = {0}; char szMiscCode[25] = {0}; int iReqMemAllocated = 0; __try { __try { //prepare the error file lstrcpy(szFinalErrLogFile,szFilePath); memset(szDate,NULL,25); memset(szDateTime,NULL,25); GetDateTime(szDate,szDateTime); ltoa(llastLineCode,szLineCode,10); ltoa(lSystemCode,szSystemCode,10); ltoa(lMiscCode,szMiscCode,10); //calculate the memory requirements //szDateTime iReqMemAllocated += 30; iReqMemAllocated += 5; //llastLineCode iReqMemAllocated += 30; iReqMemAllocated += 5; //lModuleCode iReqMemAllocated += 30; iReqMemAllocated += 5; //lSystemCode iReqMemAllocated += 30; iReqMemAllocated += 5; //lMiscCode iReqMemAllocated += 30; iReqMemAllocated += 5; if(NULL != pszModuleErrorString) { iReqMemAllocated += lstrlen(pszModuleErrorString); iReqMemAllocated += 5; } if(NULL != pAddInfo1) { iReqMemAllocated += lstrlen(pAddInfo1); iReqMemAllocated += 5; } if(NULL != pAddInfo2) { iReqMemAllocated += lstrlen(pAddInfo2); iReqMemAllocated += 5; } if(NULL != pAddInfo3) { iReqMemAllocated += lstrlen(pAddInfo3); iReqMemAllocated += 5; } if(0 != lSystemCode) { //Chek out for any last error memory req FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, lSystemCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language (LPTSTR) &pMsgBuf, 0, NULL); if(NULL != pMsgBuf) { iReqMemAllocated += lstrlen((char*)pMsgBuf); iReqMemAllocated += 5; pchBackChar = strrchr((LPTSTR) pMsgBuf,'\n'); if(NULL != pchBackChar) { *pchBackChar = NULL; } pchBackChar = strrchr((LPTSTR) pMsgBuf,'\r'); if(NULL != pchBackChar) { *pchBackChar = NULL; } } } iReqMemAllocated += 151; pszFinalErrorString = new char[iReqMemAllocated]; if(NULL == pszFinalErrorString) { return 1; } memset(pszFinalErrorString,NULL,iReqMemAllocated); //Copy the whole strings lstrcat(pszFinalErrorString,szDateTime); lstrcat(pszFinalErrorString,g_szFieldDelimiter); lstrcat(pszFinalErrorString,szLineCode); lstrcat(pszFinalErrorString,g_szFieldDelimiter); if(NULL != szModuleCode) { lstrcat(pszFinalErrorString,szModuleCode); } lstrcat(pszFinalErrorString,g_szFieldDelimiter); lstrcat(pszFinalErrorString,szSystemCode); lstrcat(pszFinalErrorString,g_szFieldDelimiter); lstrcat(pszFinalErrorString,szMiscCode); lstrcat(pszFinalErrorString,g_szFieldDelimiter); if(NULL != pszModuleErrorString) { lstrcat(pszFinalErrorString,pszModuleErrorString); } lstrcat(pszFinalErrorString,g_szFieldDelimiter); if(NULL != pMsgBuf) { lstrcat(pszFinalErrorString,(char*)pMsgBuf); } lstrcat(pszFinalErrorString,g_szFieldDelimiter); if(NULL != pAddInfo1) { lstrcat(pszFinalErrorString,pAddInfo1); } lstrcat(pszFinalErrorString,g_szFieldDelimiter); if(NULL != pAddInfo2) { lstrcat(pszFinalErrorString,pAddInfo2); } lstrcat(pszFinalErrorString,g_szFieldDelimiter); if(NULL != pAddInfo3) { lstrcat(pszFinalErrorString,pAddInfo3); } lstrcat(pszFinalErrorString,g_szFieldDelimiter); lstrcat(pszFinalErrorString,g_szRecDelimiter); //Log the Error LogErrorToDisk(szFinalErrLogFile,pszFinalErrorString); } __except(EXCEPTION_EXECUTE_HANDLER) { return 1; } } __finally { delete [] pszFinalErrorString; pszFinalErrorString = NULL; if(NULL != pMsgBuf) { LocalFree(pMsgBuf); pMsgBuf = NULL; } } return 0; }
void DisplayErrorText(int param) { DWORD dwLastError; HMODULE hModule = NULL; // default to system source LPSTR MessageBuffer; DWORD dwBufferLength; DWORD dwFormatFlags = FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM ; // // If dwLastError is in the network range, // load the message source. // dwLastError = (DWORD)param; if(dwLastError >= NERR_BASE && dwLastError <= MAX_NERR) { hModule = LoadLibraryEx( TEXT("netmsg.dll"), NULL, LOAD_LIBRARY_AS_DATAFILE ); if(hModule != NULL) dwFormatFlags |= FORMAT_MESSAGE_FROM_HMODULE; } // // Call FormatMessage() to allow for message // text to be acquired from the system // or from the supplied module handle. // if(dwBufferLength = FormatMessageA( dwFormatFlags, hModule, // module to get message from (NULL == system) dwLastError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // default language (LPSTR) &MessageBuffer, 0, NULL )) { DWORD dwBytesWritten; // // Output message string on stderr. // WriteFile( GetStdHandle(STD_ERROR_HANDLE), MessageBuffer, dwBufferLength, &dwBytesWritten, NULL ); // // Free the buffer allocated by the system. // LocalFree(MessageBuffer); } // // If we loaded a message source, unload it. // if(hModule != NULL) FreeLibrary(hModule); }
/* {{{ php_dl */ PHPAPI int php_load_extension(char *filename, int type, int start_now TSRMLS_DC) /* {{{ */ { void *handle; char *libpath; zend_module_entry *module_entry; zend_module_entry *(*get_module)(void); int error_type; char *extension_dir; if (type == MODULE_PERSISTENT) { extension_dir = INI_STR("extension_dir"); } else { extension_dir = PG(extension_dir); } if (type == MODULE_TEMPORARY) { error_type = E_WARNING; } else { error_type = E_CORE_WARNING; } /* Check if passed filename contains directory separators */ if (strchr(filename, '/') != NULL || strchr(filename, DEFAULT_SLASH) != NULL) { /* Passing modules with full path is not supported for dynamically loaded extensions */ if (type == MODULE_TEMPORARY) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Temporary module name should contain only filename"); return FAILURE; } libpath = estrdup(filename); } else if (extension_dir && extension_dir[0]) { int extension_dir_len = strlen(extension_dir); if (IS_SLASH(extension_dir[extension_dir_len-1])) { spprintf(&libpath, 0, "%s%s", extension_dir, filename); /* SAFE */ } else { spprintf(&libpath, 0, "%s%c%s", extension_dir, DEFAULT_SLASH, filename); /* SAFE */ } } else { return FAILURE; /* Not full path given or extension_dir is not set */ } /* load dynamic symbol */ handle = DL_LOAD(libpath); if (!handle) { #if PHP_WIN32 char *err = GET_DL_ERROR(); if (err) { php_error_docref(NULL TSRMLS_CC, error_type, "Unable to load dynamic library '%s' - %s", libpath, err); LocalFree(err); } else { php_error_docref(NULL TSRMLS_CC, error_type, "Unable to load dynamic library '%s' - %s", libpath, "Unknown reason"); } #else php_error_docref(NULL TSRMLS_CC, error_type, "Unable to load dynamic library '%s' - %s", libpath, GET_DL_ERROR()); GET_DL_ERROR(); /* free the buffer storing the error */ #endif efree(libpath); return FAILURE; } efree(libpath); get_module = (zend_module_entry *(*)(void)) DL_FETCH_SYMBOL(handle, "get_module"); /* Some OS prepend _ to symbol names while their dynamic linker * does not do that automatically. Thus we check manually for * _get_module. */ if (!get_module) { get_module = (zend_module_entry *(*)(void)) DL_FETCH_SYMBOL(handle, "_get_module"); } if (!get_module) { DL_UNLOAD(handle); php_error_docref(NULL TSRMLS_CC, error_type, "Invalid library (maybe not a PHP library) '%s'", filename); return FAILURE; } module_entry = get_module(); if (module_entry->zend_api != ZEND_MODULE_API_NO) { /* Check for pre-4.1.0 module which has a slightly different module_entry structure :( */ struct pre_4_1_0_module_entry { char *name; zend_function_entry *functions; int (*module_startup_func)(INIT_FUNC_ARGS); int (*module_shutdown_func)(SHUTDOWN_FUNC_ARGS); int (*request_startup_func)(INIT_FUNC_ARGS); int (*request_shutdown_func)(SHUTDOWN_FUNC_ARGS); void (*info_func)(ZEND_MODULE_INFO_FUNC_ARGS); int (*global_startup_func)(void); int (*global_shutdown_func)(void); int globals_id; int module_started; unsigned char type; void *handle; int module_number; unsigned char zend_debug; unsigned char zts; unsigned int zend_api; }; const char *name; int zend_api; if ((((struct pre_4_1_0_module_entry *)module_entry)->zend_api > 20000000) && (((struct pre_4_1_0_module_entry *)module_entry)->zend_api < 20010901) ) { name = ((struct pre_4_1_0_module_entry *)module_entry)->name; zend_api = ((struct pre_4_1_0_module_entry *)module_entry)->zend_api; } else { name = module_entry->name; zend_api = module_entry->zend_api; } php_error_docref(NULL TSRMLS_CC, error_type, "%s: Unable to initialize module\n" "Module compiled with module API=%d\n" "PHP compiled with module API=%d\n" "These options need to match\n", name, zend_api, ZEND_MODULE_API_NO); DL_UNLOAD(handle); return FAILURE; } if(strcmp(module_entry->build_id, ZEND_MODULE_BUILD_ID)) { php_error_docref(NULL TSRMLS_CC, error_type, "%s: Unable to initialize module\n" "Module compiled with build ID=%s\n" "PHP compiled with build ID=%s\n" "These options need to match\n", module_entry->name, module_entry->build_id, ZEND_MODULE_BUILD_ID); DL_UNLOAD(handle); return FAILURE; } module_entry->type = type; module_entry->module_number = zend_next_free_module(); module_entry->handle = handle; if ((module_entry = zend_register_module_ex(module_entry TSRMLS_CC)) == NULL) { DL_UNLOAD(handle); return FAILURE; } if ((type == MODULE_TEMPORARY || start_now) && zend_startup_module_ex(module_entry TSRMLS_CC) == FAILURE) { DL_UNLOAD(handle); return FAILURE; } if ((type == MODULE_TEMPORARY || start_now) && module_entry->request_startup_func) { if (module_entry->request_startup_func(type, module_entry->module_number TSRMLS_CC) == FAILURE) { php_error_docref(NULL TSRMLS_CC, error_type, "Unable to initialize module '%s'", module_entry->name); DL_UNLOAD(handle); return FAILURE; } } return SUCCESS; }
int CALLBACK _tWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow ) { int argc = 0; LPWSTR * argv = CommandLineToArgvW( GetCommandLineW(), &argc ); if ( argv == NULL || argc != 3 ) return 1; wchar_t * end_char = 0; unsigned in_sum = wcstoul( argv[ 2 ], &end_char, 16 ); if ( end_char == argv[ 2 ] || *end_char ) return 2; unsigned test_sum = 0; end_char = argv[ 1 ]; while ( *end_char ) { test_sum += (TCHAR)( *end_char++ * 820109 ); } #ifdef NDEBUG if ( test_sum != in_sum ) return 3; #endif unsigned code = 0; HMODULE hDll = NULL; main_func pMain = NULL; AEffect * pEffect[3] = {0, 0, 0}; audioMasterData effectData[3] = { { 0 }, { 1 }, { 2 } }; std::vector<uint8_t> blState; uint32_t max_num_outputs = 2; uint32_t sample_rate = 44100; std::vector<uint8_t> chunk; std::vector<float> sample_buffer; null_file = CreateFile( _T("NUL"), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL ); pipe_in = GetStdHandle( STD_INPUT_HANDLE ); pipe_out = GetStdHandle( STD_OUTPUT_HANDLE ); SetStdHandle( STD_INPUT_HANDLE, null_file ); SetStdHandle( STD_OUTPUT_HANDLE, null_file ); { INITCOMMONCONTROLSEX icc; icc.dwSize = sizeof(icc); icc.dwICC = ICC_WIN95_CLASSES | ICC_COOL_CLASSES | ICC_STANDARD_CLASSES; if ( !InitCommonControlsEx( &icc ) ) return 4; } if ( FAILED( CoInitialize( NULL ) ) ) return 5; #ifndef _DEBUG SetUnhandledExceptionFilter( myExceptFilterProc ); #endif size_t dll_name_len = wcslen( argv[ 1 ] ); dll_dir = ( char * ) malloc( dll_name_len + 1 ); wcstombs( dll_dir, argv[ 1 ], dll_name_len ); dll_dir[ dll_name_len ] = '\0'; char * slash = strrchr( dll_dir, '\\' ); *slash = '\0'; hDll = LoadLibraryW( argv[ 1 ] ); if ( !hDll ) { code = 6; goto exit; } pMain = (main_func) GetProcAddress( hDll, "main" ); if ( !pMain ) { code = 7; goto exit; } #if 0 MessageBox( GetDesktopWindow(), argv[ 1 ], _T("HUUUURRRRRR"), 0 ); #endif pEffect[ 0 ] = pMain( &audioMaster ); if ( !pEffect[ 0 ] || pEffect[ 0 ]->magic != kEffectMagic ) { code = 8; goto exit; } pEffect[ 0 ]->user = &effectData[ 0 ]; pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effOpen, 0, 0, 0, 0 ); if ( pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effGetPlugCategory, 0, 0, 0, 0 ) != kPlugCategSynth || pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effCanDo, 0, 0, "sendVstMidiEvent", 0 ) == 0 ) { code = 9; goto exit; } max_num_outputs = min( pEffect[ 0 ]->numOutputs, 2 ); { char name_string[256] = { 0 }; char vendor_string[256] = { 0 }; char product_string[256] = { 0 }; uint32_t name_string_length; uint32_t vendor_string_length; uint32_t product_string_length; uint32_t vendor_version; uint32_t unique_id; pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effGetEffectName, 0, 0, &name_string, 0 ); pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effGetVendorString, 0, 0, &vendor_string, 0 ); pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effGetProductString, 0, 0, &product_string, 0 ); name_string_length = strlen( name_string ); vendor_string_length = strlen( vendor_string ); product_string_length = strlen( product_string ); vendor_version = pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effGetVendorVersion, 0, 0, 0, 0 ); unique_id = pEffect[ 0 ]->uniqueID; put_code( 0 ); put_code( name_string_length ); put_code( vendor_string_length ); put_code( product_string_length ); put_code( vendor_version ); put_code( unique_id ); put_code( max_num_outputs ); if ( name_string_length ) put_bytes( name_string, name_string_length ); if ( vendor_string_length ) put_bytes( vendor_string, vendor_string_length ); if ( product_string_length ) put_bytes( product_string, product_string_length ); } float ** float_list_in; float ** float_list_out; float * float_null; float * float_out; for (;;) { uint32_t command = get_code(); if ( !command ) break; switch ( command ) { case 1: // Get Chunk getChunk( pEffect[ 0 ], chunk ); put_code( 0 ); put_code( chunk.size() ); put_bytes( chunk.data(), chunk.size() ); break; case 2: // Set Chunk { uint32_t size = get_code(); chunk.resize( size ); if ( size ) get_bytes( chunk.data(), size ); setChunk( pEffect[ 0 ], chunk ); setChunk( pEffect[ 1 ], chunk ); setChunk( pEffect[ 2 ], chunk ); put_code( 0 ); } break; case 3: // Has Editor { uint32_t has_editor = ( pEffect[ 0 ]->flags & effFlagsHasEditor ) ? 1 : 0; put_code( 0 ); put_code( has_editor ); } break; case 4: // Display Editor Modal { if ( pEffect[ 0 ]->flags & effFlagsHasEditor ) { MyDLGTEMPLATE t; t.style = WS_POPUPWINDOW | WS_DLGFRAME | DS_MODALFRAME | DS_CENTER; DialogBoxIndirectParam ( 0, &t, GetDesktopWindow(), (DLGPROC)EditorProc, (LPARAM)( pEffect[ 0 ] ) ); getChunk( pEffect[ 0 ], chunk ); setChunk( pEffect[ 1 ], chunk ); setChunk( pEffect[ 2 ], chunk ); } put_code( 0 ); } break; case 5: // Set Sample Rate { uint32_t size = get_code(); if ( size != sizeof(sample_rate) ) { code = 10; goto exit; } sample_rate = get_code(); put_code( 0 ); } break; case 6: // Reset { if ( pEffect[ 2 ] ) { if ( blState.size() ) pEffect[ 2 ]->dispatcher( pEffect[ 2 ], effStopProcess, 0, 0, 0, 0 ); pEffect[ 2 ]->dispatcher( pEffect[ 2 ], effClose, 0, 0, 0, 0 ); pEffect[ 2 ] = NULL; } if ( pEffect[ 1 ] ) { if ( blState.size() ) pEffect[ 1 ]->dispatcher( pEffect[ 1 ], effStopProcess, 0, 0, 0, 0 ); pEffect[ 1 ]->dispatcher( pEffect[ 1 ], effClose, 0, 0, 0, 0 ); pEffect[ 1 ] = NULL; } if ( blState.size() ) pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effStopProcess, 0, 0, 0, 0 ); pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effClose, 0, 0, 0, 0 ); blState.resize( 0 ); freeChain(); pEffect[ 0 ] = pMain( &audioMaster ); if ( !pEffect[ 0 ] ) { code = 8; goto exit; } pEffect[ 0 ]->user = &effectData[ 0 ]; pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effOpen, 0, 0, 0, 0 ); setChunk( pEffect[ 0 ], chunk ); put_code( 0 ); } break; case 7: // Send MIDI Event { myVstEvent * ev = ( myVstEvent * ) calloc( sizeof( myVstEvent ), 1 ); if ( evTail ) evTail->next = ev; evTail = ev; if ( !evChain ) evChain = ev; uint32_t b = get_code(); ev->port = (b & 0x7F000000) >> 24; if (ev->port > 2) ev->port = 2; ev->ev.midiEvent.type = kVstMidiType; ev->ev.midiEvent.byteSize = sizeof(ev->ev.midiEvent); memcpy(&ev->ev.midiEvent.midiData, &b, 3); put_code( 0 ); } break; case 8: // Send System Exclusive Event { myVstEvent * ev = ( myVstEvent * ) calloc( sizeof( myVstEvent ), 1 ); if ( evTail ) evTail->next = ev; evTail = ev; if ( !evChain ) evChain = ev; uint32_t size = get_code(); uint32_t port = size >> 24; size &= 0xFFFFFF; ev->port = port; if (ev->port > 2) ev->port = 2; ev->ev.sysexEvent.type = kVstSysExType; ev->ev.sysexEvent.byteSize = sizeof(ev->ev.sysexEvent); ev->ev.sysexEvent.dumpBytes = size; ev->ev.sysexEvent.sysexDump = (char*) malloc( size ); get_bytes( ev->ev.sysexEvent.sysexDump, size ); put_code( 0 ); } break; case 9: // Render Samples { if ( !pEffect[ 1 ] ) { pEffect[ 1 ] = pMain( &audioMaster ); if ( !pEffect[ 1 ] ) { code = 11; goto exit; } pEffect[ 1 ]->user = &effectData[ 1 ]; pEffect[ 1 ]->dispatcher( pEffect[ 1 ], effOpen, 0, 0, 0, 0 ); setChunk( pEffect[ 1 ], chunk ); } if ( !pEffect[ 2 ] ) { pEffect[ 2 ] = pMain( &audioMaster ); if ( !pEffect[ 2 ] ) { code = 11; goto exit; } pEffect[ 2 ]->user = &effectData[ 2 ]; pEffect[ 2 ]->dispatcher( pEffect[ 2 ], effOpen, 0, 0, 0, 0 ); setChunk( pEffect[ 2 ], chunk ); } if ( !blState.size() ) { pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effSetSampleRate, 0, 0, 0, float(sample_rate) ); pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effSetBlockSize, 0, BUFFER_SIZE, 0, 0 ); pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effMainsChanged, 0, 1, 0, 0 ); pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effStartProcess, 0, 0, 0, 0 ); pEffect[ 1 ]->dispatcher( pEffect[ 1 ], effSetSampleRate, 0, 0, 0, float(sample_rate) ); pEffect[ 1 ]->dispatcher( pEffect[ 1 ], effSetBlockSize, 0, BUFFER_SIZE, 0, 0 ); pEffect[ 1 ]->dispatcher( pEffect[ 1 ], effMainsChanged, 0, 1, 0, 0 ); pEffect[ 1 ]->dispatcher( pEffect[ 1 ], effStartProcess, 0, 0, 0, 0 ); pEffect[ 2 ]->dispatcher( pEffect[ 2 ], effSetSampleRate, 0, 0, 0, float(sample_rate) ); pEffect[ 2 ]->dispatcher( pEffect[ 2 ], effSetBlockSize, 0, BUFFER_SIZE, 0, 0 ); pEffect[ 2 ]->dispatcher( pEffect[ 2 ], effMainsChanged, 0, 1, 0, 0 ); pEffect[ 2 ]->dispatcher( pEffect[ 2 ], effStartProcess, 0, 0, 0, 0 ); size_t buffer_size = sizeof(float*) * ( pEffect[ 0 ]->numInputs + pEffect[ 0 ]->numOutputs * 3 ); // float lists buffer_size += sizeof(float) * BUFFER_SIZE; // null input buffer_size += sizeof(float) * BUFFER_SIZE * pEffect[ 0 ]->numOutputs * 3; // outputs blState.resize( buffer_size ); float_list_in = (float**) blState.data(); float_list_out = float_list_in + pEffect[ 0 ]->numInputs; float_null = (float*) ( float_list_out + pEffect[ 0 ]->numOutputs * 3 ); float_out = float_null + BUFFER_SIZE; for ( unsigned i = 0; i < pEffect[ 0 ]->numInputs; ++i ) float_list_in [ i ] = float_null; for ( unsigned i = 0; i < pEffect[ 0 ]->numOutputs * 3; ++i ) float_list_out[ i ] = float_out + BUFFER_SIZE * i; memset( float_null, 0, sizeof(float) * BUFFER_SIZE ); sample_buffer.resize( BUFFER_SIZE * max_num_outputs ); } if ( need_idle ) { pEffect[ 0 ]->dispatcher( pEffect[ 0 ], DECLARE_VST_DEPRECATED (effIdle), 0, 0, 0, 0 ); pEffect[ 1 ]->dispatcher( pEffect[ 1 ], DECLARE_VST_DEPRECATED (effIdle), 0, 0, 0, 0 ); pEffect[ 2 ]->dispatcher( pEffect[ 2 ], DECLARE_VST_DEPRECATED (effIdle), 0, 0, 0, 0 ); if ( !idle_started ) { unsigned idle_run = BUFFER_SIZE * 128; while ( idle_run ) { unsigned count_to_do = min( idle_run, BUFFER_SIZE ); unsigned num_outputs = pEffect[ 0 ]->numOutputs; pEffect[ 0 ]->processReplacing( pEffect[ 0 ], float_list_in, float_list_out, count_to_do ); pEffect[ 1 ]->processReplacing( pEffect[ 1 ], float_list_in, float_list_out + num_outputs, count_to_do ); pEffect[ 2 ]->processReplacing( pEffect[ 2 ], float_list_in, float_list_out + num_outputs * 2, count_to_do ); pEffect[ 0 ]->dispatcher( pEffect[ 0 ], DECLARE_VST_DEPRECATED (effIdle), 0, 0, 0, 0 ); pEffect[ 1 ]->dispatcher( pEffect[ 1 ], DECLARE_VST_DEPRECATED (effIdle), 0, 0, 0, 0 ); pEffect[ 2 ]->dispatcher( pEffect[ 2 ], DECLARE_VST_DEPRECATED (effIdle), 0, 0, 0, 0 ); idle_run -= count_to_do; } } } VstEvents * events[ 3 ] = {0}; if ( evChain ) { unsigned event_count[ 3 ] = {0}; myVstEvent * ev = evChain; while ( ev ) { event_count[ ev->port ]++; ev = ev->next; } if ( event_count[ 0 ] ) { events[ 0 ] = ( VstEvents * ) malloc( sizeof(long) + sizeof(long) + sizeof(VstEvent*) * event_count[ 0 ] ); events[ 0 ]->numEvents = event_count[ 0 ]; events[ 0 ]->reserved = 0; ev = evChain; for ( unsigned i = 0; ev; ) { if ( !ev->port ) events[ 0 ]->events[ i++ ] = (VstEvent*) &ev->ev; ev = ev->next; } pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effProcessEvents, 0, 0, events[ 0 ], 0 ); } if ( event_count[ 1 ] ) { events[ 1 ] = ( VstEvents * ) malloc( sizeof(long) + sizeof(long) + sizeof(VstEvent*) * event_count[ 1 ] ); events[ 1 ]->numEvents = event_count[ 1 ]; events[ 1 ]->reserved = 0; ev = evChain; for ( unsigned i = 0; ev; ) { if ( ev->port == 1 ) events[ 1 ]->events[ i++ ] = (VstEvent*) &ev->ev; ev = ev->next; } pEffect[ 1 ]->dispatcher( pEffect[ 1 ], effProcessEvents, 0, 0, events[ 1 ], 0 ); } if ( event_count[ 2 ] ) { events[ 2 ] = ( VstEvents * ) malloc( sizeof(long) + sizeof(long) + sizeof(VstEvent*) * event_count[ 2 ] ); events[ 2 ]->numEvents = event_count[ 2 ]; events[ 2 ]->reserved = 0; ev = evChain; for ( unsigned i = 0; ev; ) { if ( ev->port == 2 ) events[ 2 ]->events[ i++ ] = (VstEvent*) &ev->ev; ev = ev->next; } pEffect[ 2 ]->dispatcher( pEffect[ 2 ], effProcessEvents, 0, 0, events[ 2 ], 0 ); } } if ( need_idle ) { pEffect[ 0 ]->dispatcher( pEffect[ 0 ], DECLARE_VST_DEPRECATED (effIdle), 0, 0, 0, 0 ); pEffect[ 1 ]->dispatcher( pEffect[ 1 ], DECLARE_VST_DEPRECATED (effIdle), 0, 0, 0, 0 ); pEffect[ 2 ]->dispatcher( pEffect[ 2 ], DECLARE_VST_DEPRECATED (effIdle), 0, 0, 0, 0 ); if ( !idle_started ) { if ( events[ 0 ] ) pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effProcessEvents, 0, 0, events[ 0 ], 0 ); if ( events[ 1 ] ) pEffect[ 1 ]->dispatcher( pEffect[ 1 ], effProcessEvents, 0, 0, events[ 1 ], 0 ); if ( events[ 2 ] ) pEffect[ 2 ]->dispatcher( pEffect[ 2 ], effProcessEvents, 0, 0, events[ 2 ], 0 ); idle_started = true; } } uint32_t count = get_code(); put_code( 0 ); while( count ) { unsigned count_to_do = min( count, BUFFER_SIZE ); unsigned num_outputs = pEffect[ 0 ]->numOutputs; pEffect[ 0 ]->processReplacing( pEffect[ 0 ], float_list_in, float_list_out, count_to_do ); pEffect[ 1 ]->processReplacing( pEffect[ 1 ], float_list_in, float_list_out + num_outputs, count_to_do ); pEffect[ 2 ]->processReplacing( pEffect[ 2 ], float_list_in, float_list_out + num_outputs * 2, count_to_do ); float * out = sample_buffer.data(); if ( max_num_outputs == 2 ) { for ( unsigned i = 0; i < count_to_do; ++i ) { float sample = ( float_out[ i ] + float_out[ i + BUFFER_SIZE * num_outputs ] + float_out[ i + BUFFER_SIZE * num_outputs * 2 ] ); out[ 0 ] = sample; sample = ( float_out[ i + BUFFER_SIZE ] + float_out[ i + BUFFER_SIZE + BUFFER_SIZE * num_outputs ] + float_out[ i + BUFFER_SIZE + BUFFER_SIZE * num_outputs * 2 ] ); out[ 1 ] = sample; out += 2; } } else { for ( unsigned i = 0; i < count_to_do; ++i ) { float sample = ( float_out[ i ] + float_out[ i + BUFFER_SIZE * num_outputs ] + float_out[ i + BUFFER_SIZE * num_outputs * 2 ] ); out[ 0 ] = sample; out++; } } put_bytes( sample_buffer.data(), sizeof(float) * count_to_do * max_num_outputs ); count -= count_to_do; } if ( events[ 0 ] ) free( events[ 0 ] ); if ( events[ 1 ] ) free( events[ 1 ] ); if ( events[ 2 ] ) free( events[ 2 ] ); freeChain(); } break; default: code = 12; goto exit; break; } } exit: if ( pEffect[ 2 ] ) { if ( blState.size() ) pEffect[ 2 ]->dispatcher( pEffect[ 2 ], effStopProcess, 0, 0, 0, 0 ); pEffect[ 2 ]->dispatcher( pEffect[ 2 ], effClose, 0, 0, 0, 0 ); } if ( pEffect[ 1 ] ) { if ( blState.size() ) pEffect[ 1 ]->dispatcher( pEffect[ 1 ], effStopProcess, 0, 0, 0, 0 ); pEffect[ 1 ]->dispatcher( pEffect[ 1 ], effClose, 0, 0, 0, 0 ); } if ( pEffect[ 0 ] ) { if ( blState.size() ) pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effStopProcess, 0, 0, 0, 0 ); pEffect[ 0 ]->dispatcher( pEffect[ 0 ], effClose, 0, 0, 0, 0 ); } freeChain(); if ( hDll ) FreeLibrary( hDll ); CoUninitialize(); if ( argv ) LocalFree( argv ); put_code( code ); if ( null_file ) { CloseHandle( null_file ); SetStdHandle( STD_INPUT_HANDLE, pipe_in ); SetStdHandle( STD_OUTPUT_HANDLE, pipe_out ); } return code; }
VOID DbgReportRop( IN CONST PVOID Address, IN CONST DWORD APINumber ) { PLDR_DATA_TABLE_ENTRY TableEntry; LPVOID lpAddress; LPVOID lpCodeSectionAddress; CHAR szAssciFullModuleName[MAX_MODULE_NAME32]; CHAR szAssciModuleName[MAX_MODULE_NAME32]; PCHAR szRopInst; DWORD dwCodeSectionSize; DWORD i; PXMLNODE XmlLogNode; PXMLNODE XmlIDLogNode;; XmlIDLogNode = CreateXmlElement( XmlShellcode, "row"); // type XmlLogNode = mxmlNewElement( XmlIDLogNode, "type"); mxmlNewText( XmlLogNode, 0, "0"); // data XmlLogNode = CreateXmlElement( XmlIDLogNode, "function"); SecureZeroMemory(szAssciFullModuleName, MAX_MODULE_NAME32); SecureZeroMemory(szAssciModuleName, MAX_MODULE_NAME32); szRopInst = (PCHAR)LocalAlloc(LMEM_ZEROINIT, 2048); lpAddress = Address; bRopDetected = TRUE; /* Get function name which reports rop */ switch (APINumber) { case CalleeVirtualAlloc: SetTextNode( XmlLogNode, 0, "VirtualAlloc"); break; case CalleeVirtualAllocEx: SetTextNode( XmlLogNode, 0, "VirtualAllocEx"); break; case CalleeVirtualProtect: SetTextNode( XmlLogNode, 0, "VirtualProtect"); break; case CalleeVirtualProtectEx: SetTextNode( XmlLogNode, 0, "VirtualProtectEx"); break; case CalleeMapViewOfFile: SetTextNode( XmlLogNode, 0, "MapViewOfFile"); break; case CalleeMapViewOfFileEx: SetTextNode( XmlLogNode, 0, "MapViewOfFileEx"); break; case CalleeNtAllocateVirtualMemory: SetTextNode(XmlLogNode, 0, "NtAllocateVirtualMemory"); break; case CalleeNtProtectVirtualMemory: SetTextNode(XmlLogNode, 0, "NtProtectVirtualMemory"); break; } /* Get the module that used for rop gadgets */ if ( DbgGetRopModule( lpAddress, szAssciFullModuleName, MAX_MODULE_NAME32) == MCEDP_STATUS_SUCCESS ) { XmlLogNode = CreateXmlElement( XmlIDLogNode, "module"); SetTextNode( XmlLogNode, 0, szAssciFullModuleName); SaveXml( XmlLog ); } /* Dump possible ROP gadgets */ if ( MCEDP_REGCONFIG.ROP.DUMP_ROP == TRUE ) { lpAddress = (PVOID)((DWORD_PTR)lpAddress - MCEDP_REGCONFIG.ROP.ROP_MEM_FAR); for ( i = 0 ; i <= MCEDP_REGCONFIG.ROP.MAX_ROP_MEM ; i++ , lpAddress = (LPVOID)((DWORD)lpAddress + 4) ) { if ( LdrFindEntryForAddress((PVOID)(*(DWORD *)lpAddress), &TableEntry) == MCEDP_STATUS_SUCCESS ) { /* get module name */ wcstombs( szAssciModuleName, TableEntry->FullDllName.Buffer, TableEntry->FullDllName.Length ); /* Get module .text section start address */ if ( ( lpCodeSectionAddress = PeGetCodeSectionAddress( TableEntry->DllBase ) ) == NULL ) { DEBUG_PRINTF(LROP, NULL, "[ 0x%p ]\t\t\t\tDB 0x%p [FAILD -- MODULE CODE SECTION ADDRESS NULL]\n", lpAddress, (*(ULONG_PTR *)lpAddress)); break; } /* Get module .text section size */ if ( ( dwCodeSectionSize = PeGetCodeSectionSize( TableEntry->DllBase ) ) == NULL ) { DEBUG_PRINTF(LROP, NULL, "[ 0x%p ]\t\t\t\tDB 0x%p [FAILD - MODULE CODE SECTION SIZE NULL]\n", lpAddress, (*(ULONG_PTR *)lpAddress)); break; } /* Check if instruction lies inside the .text section */ if ( (*(ULONG_PTR *)lpAddress) >= (ULONG_PTR)lpCodeSectionAddress && (*(ULONG_PTR *)lpAddress) < ( (ULONG_PTR)lpCodeSectionAddress + dwCodeSectionSize ) ) { if ( ShuDisassmbleRopInstructions( (PVOID)(*(ULONG_PTR *)lpAddress), szRopInst, MCEDP_REGCONFIG.ROP.MAX_ROP_INST ) == MCEDP_STATUS_SUCCESS ) { DEBUG_PRINTF(LROP, NULL, "[ 0x%p ] %s + 0x%p :\n", (*(ULONG_PTR *)lpAddress), szAssciModuleName, (*(ULONG_PTR *)lpAddress - (ULONG_PTR)TableEntry->DllBase)); DEBUG_PRINTF(LROP, NULL, "%s", szRopInst); } else { DEBUG_PRINTF(LROP, NULL, "[ 0x%p ]\t\t\t\tDB 0x%p [FAILD TO DISASSMBLE]\n", lpAddress, (*(ULONG_PTR *)lpAddress)); } SecureZeroMemory(szRopInst, 2048); } else DEBUG_PRINTF(LROP, NULL, "[ 0x%p ]\t\t\t\tDB 0x%p [OUT OF CODE SECTION]\n", lpAddress, (*(ULONG_PTR *)lpAddress)); } else DEBUG_PRINTF(LROP, NULL, "[ 0x%p ]\t\t\t\tDB 0x%p\n", lpAddress, (*(ULONG_PTR *)lpAddress)); } } LocalFree(szRopInst); }
static INT_PTR CALLBACK DialogProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { static activePage = 0; switch (msg) { /* init */ case WM_INITDIALOG: { LOCALDATA *data = LocalAlloc(LPTR, sizeof(LOCALDATA)); HINSTANCE inst = (HINSTANCE)lParam; TCITEM item; /* init */ SetWindowLong(hwnd, GWL_USERDATA, (LONG)data); data->htab = GetDlgItem(hwnd, IDC_TABS); data->hdlg = NULL; /* add pages */ item.mask = TCIF_TEXT; data->all[0] = CreateDialog(inst, MAKEINTRESOURCE(IDD_CONFIG_GENERAL), hwnd, GeneralProc); item.pszText = "General"; TabCtrl_InsertItem(data->htab, 0, &item); data->all[1] = CreateDialog(inst, MAKEINTRESOURCE(IDD_CONFIG_OUTPUT), hwnd, OutputProc); item.pszText = "Output"; TabCtrl_InsertItem(data->htab, 1, &item); /* get rect (after adding pages) */ GetWindowRect(data->htab, &data->r); ScreenToClientRect(hwnd, &data->r); TabCtrl_AdjustRect(data->htab, 0, &data->r); /* simulate item change */ TabCtrl_SetCurSel(data->htab, activePage); OnSelChange(hwnd); } return TRUE; /* destory */ case WM_DESTROY: { LOCALDATA *data = (LOCALDATA*)GetWindowLong(hwnd, GWL_USERDATA); int i; activePage = TabCtrl_GetCurSel(data->htab); for (i=0; i<NUM_PAGES; i++) DestroyWindow(data->all[i]); LocalFree(data); } break; /* commands */ case WM_COMMAND: switch (LOWORD(wParam)) { /* ok/cancel */ case IDOK: BroadcastCommand(hwnd, IDOK); /* fall through */ case IDCANCEL: EndDialog(hwnd, LOWORD(wParam)); return TRUE; case IDC_RESET: SendCommand(hwnd, IDC_RESET); break; } break; /* notification */ case WM_NOTIFY: if (LOWORD(wParam) == IDC_TABS) { NMHDR *hdr = (NMHDR*)lParam; switch (hdr->code) { case TCN_SELCHANGE: OnSelChange(hwnd); break; } } break; } return 0; }
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpCmdLine, int /*nCmdShow*/) { SetDllDirectory(L""); SetTaskIDPerUUID(); CRegStdDWORD loc = CRegStdDWORD(_T("Software\\TortoiseGit\\LanguageID"), 1033); long langId = loc; CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); CLangDll langDLL; hResource = langDLL.Init(_T("TortoiseIDiff"), langId); if (hResource == NULL) hResource = hInstance; CCmdLineParser parser(lpCmdLine); if (parser.HasKey(_T("?")) || parser.HasKey(_T("help"))) { TCHAR buf[1024] = { 0 }; LoadString(hResource, IDS_COMMANDLINEHELP, buf, _countof(buf)); MessageBox(NULL, buf, _T("TortoiseIDiff"), MB_ICONINFORMATION); langDLL.Close(); return 0; } MSG msg; hInst = hInstance; INITCOMMONCONTROLSEX used = { sizeof(INITCOMMONCONTROLSEX), ICC_STANDARD_CLASSES | ICC_BAR_CLASSES | ICC_WIN95_CLASSES }; InitCommonControlsEx(&used); // load the cursors we need curHand = (HCURSOR)LoadImage(hInst, MAKEINTRESOURCE(IDC_PANCUR), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE); curHandDown = (HCURSOR)LoadImage(hInst, MAKEINTRESOURCE(IDC_PANDOWNCUR), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE); std::unique_ptr<CMainWindow> mainWindow(new CMainWindow(hResource)); mainWindow->SetRegistryPath(_T("Software\\TortoiseGit\\TortoiseIDiffWindowPos")); std::wstring leftfile = parser.HasVal(_T("left")) ? parser.GetVal(_T("left")) : _T(""); std::wstring rightfile = parser.HasVal(_T("right")) ? parser.GetVal(_T("right")) : _T(""); if ((leftfile.empty()) && (lpCmdLine[0] != 0)) { int nArgs; LPWSTR * szArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs); if (szArglist) { if (nArgs == 3) { // Four parameters: // [0]: Program name // [1]: left file // [2]: right file if (PathFileExists(szArglist[1]) && PathFileExists(szArglist[2])) { leftfile = szArglist[1]; rightfile = szArglist[2]; } } } // Free memory allocated for CommandLineToArgvW arguments. LocalFree(szArglist); } mainWindow->SetLeft(leftfile.c_str(), parser.HasVal(_T("lefttitle")) ? parser.GetVal(_T("lefttitle")) : _T("")); mainWindow->SetRight(rightfile.c_str(), parser.HasVal(_T("righttitle")) ? parser.GetVal(_T("righttitle")) : _T("")); if (parser.HasVal(L"base")) mainWindow->SetSelectionImage(FileTypeBase, parser.GetVal(L"base"), parser.HasVal(L"basetitle") ? parser.GetVal(L"basetitle") : L""); if (parser.HasVal(L"mine")) mainWindow->SetSelectionImage(FileTypeMine, parser.GetVal(L"mine"), parser.HasVal(L"minetitle") ? parser.GetVal(L"minetitle") : L""); if (parser.HasVal(L"theirs")) mainWindow->SetSelectionImage(FileTypeTheirs, parser.GetVal(L"theirs"), parser.HasVal(L"theirstitle") ? parser.GetVal(L"theirstitle") : L""); if (parser.HasVal(L"result")) mainWindow->SetSelectionResult(parser.GetVal(L"result")); if (mainWindow->RegisterAndCreateWindow()) { HACCEL hAccelTable = LoadAccelerators(hResource, MAKEINTRESOURCE(IDR_TORTOISEIDIFF)); if (!parser.HasVal(L"left") && parser.HasVal(L"base") && !parser.HasVal(L"mine") && !parser.HasVal(L"theirs")) { PostMessage(*mainWindow, WM_COMMAND, ID_FILE_OPEN, 0); } if (parser.HasKey(_T("overlay"))) { PostMessage(*mainWindow, WM_COMMAND, ID_VIEW_OVERLAPIMAGES, 0); } if (parser.HasKey(_T("fit"))) { PostMessage(*mainWindow, WM_COMMAND, ID_VIEW_FITIMAGEHEIGHTS, 0); PostMessage(*mainWindow, WM_COMMAND, ID_VIEW_FITIMAGEWIDTHS, 0); } if (parser.HasKey(_T("fitwidth"))) { PostMessage(*mainWindow, WM_COMMAND, ID_VIEW_FITIMAGEWIDTHS, 0); } if (parser.HasKey(_T("fitheight"))) { PostMessage(*mainWindow, WM_COMMAND, ID_VIEW_FITIMAGEHEIGHTS, 0); } if (parser.HasKey(_T("showinfo"))) { PostMessage(*mainWindow, WM_COMMAND, ID_VIEW_IMAGEINFO, 0); } // Main message loop: while (GetMessage(&msg, NULL, 0, 0)) { if (!TranslateAccelerator(*mainWindow, hAccelTable, &msg)) { TranslateMessage(&msg); DispatchMessage(&msg); } } return (int) msg.wParam; } langDLL.Close(); DestroyCursor(curHand); DestroyCursor(curHandDown); CoUninitialize(); return 1; }
static void test_heap(void) { LPVOID mem; LPVOID msecond; DWORD res; UINT flags; HGLOBAL gbl; HGLOBAL hsecond; SIZE_T size, size2; const SIZE_T max_size = 1024, init_size = 10; /* Heap*() functions */ mem = HeapAlloc(GetProcessHeap(), 0, 0); ok(mem != NULL, "memory not allocated for size 0\n"); HeapFree(GetProcessHeap(), 0, mem); mem = HeapReAlloc(GetProcessHeap(), 0, NULL, 10); ok(mem == NULL, "memory allocated by HeapReAlloc\n"); for (size = 0; size <= 256; size++) { SIZE_T heap_size; mem = HeapAlloc(GetProcessHeap(), 0, size); heap_size = HeapSize(GetProcessHeap(), 0, mem); ok(heap_size == size || heap_size == resize_9x(size), "HeapSize returned %lu instead of %lu or %lu\n", heap_size, size, resize_9x(size)); HeapFree(GetProcessHeap(), 0, mem); } /* test some border cases of HeapAlloc and HeapReAlloc */ mem = HeapAlloc(GetProcessHeap(), 0, 0); ok(mem != NULL, "memory not allocated for size 0\n"); msecond = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mem, ~(SIZE_T)0 - 7); ok(msecond == NULL, "HeapReAlloc(~0 - 7) should have failed\n"); msecond = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mem, ~(SIZE_T)0); ok(msecond == NULL, "HeapReAlloc(~0) should have failed\n"); HeapFree(GetProcessHeap(), 0, mem); mem = HeapAlloc(GetProcessHeap(), 0, ~(SIZE_T)0); ok(mem == NULL, "memory allocated for size ~0\n"); /* large blocks must be 16-byte aligned */ mem = HeapAlloc(GetProcessHeap(), 0, 512 * 1024); ok( mem != NULL, "failed for size 512K\n" ); ok( (ULONG_PTR)mem % 16 == 0 || broken((ULONG_PTR)mem % 16) /* win9x */, "512K block not 16-byte aligned\n" ); HeapFree(GetProcessHeap(), 0, mem); /* Global*() functions */ gbl = GlobalAlloc(GMEM_MOVEABLE, 0); ok(gbl != NULL, "global memory not allocated for size 0\n"); gbl = GlobalReAlloc(gbl, 10, GMEM_MOVEABLE); ok(gbl != NULL, "Can't realloc global memory\n"); size = GlobalSize(gbl); ok(size >= 10 && size <= 16, "Memory not resized to size 10, instead size=%ld\n", size); gbl = GlobalReAlloc(gbl, 0, GMEM_MOVEABLE); ok(gbl != NULL, "GlobalReAlloc should not fail on size 0\n"); size = GlobalSize(gbl); ok(size == 0, "Memory not resized to size 0, instead size=%ld\n", size); ok(GlobalFree(gbl) == NULL, "Memory not freed\n"); size = GlobalSize(gbl); ok(size == 0, "Memory should have been freed, size=%ld\n", size); gbl = GlobalReAlloc(0, 10, GMEM_MOVEABLE); ok(gbl == NULL, "global realloc allocated memory\n"); /* GlobalLock / GlobalUnlock with a valid handle */ gbl = GlobalAlloc(GMEM_MOVEABLE, 256); SetLastError(MAGIC_DEAD); mem = GlobalLock(gbl); /* #1 */ ok(mem != NULL, "returned %p with %d (expected '!= NULL')\n", mem, GetLastError()); SetLastError(MAGIC_DEAD); flags = GlobalFlags(gbl); ok( flags == 1, "returned 0x%04x with %d (expected '0x0001')\n", flags, GetLastError()); SetLastError(MAGIC_DEAD); msecond = GlobalLock(gbl); /* #2 */ ok( msecond == mem, "returned %p with %d (expected '%p')\n", msecond, GetLastError(), mem); SetLastError(MAGIC_DEAD); flags = GlobalFlags(gbl); ok( flags == 2, "returned 0x%04x with %d (expected '0x0002')\n", flags, GetLastError()); SetLastError(MAGIC_DEAD); SetLastError(MAGIC_DEAD); res = GlobalUnlock(gbl); /* #1 */ ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError()); SetLastError(MAGIC_DEAD); flags = GlobalFlags(gbl); ok( flags , "returned 0x%04x with %d (expected '!= 0')\n", flags, GetLastError()); SetLastError(MAGIC_DEAD); res = GlobalUnlock(gbl); /* #0 */ /* NT: ERROR_SUCCESS (documented on MSDN), 9x: untouched */ ok(!res && ((GetLastError() == ERROR_SUCCESS) || (GetLastError() == MAGIC_DEAD)), "returned %d with %d (expected '0' with: ERROR_SUCCESS or " "MAGIC_DEAD)\n", res, GetLastError()); SetLastError(MAGIC_DEAD); flags = GlobalFlags(gbl); ok( !flags , "returned 0x%04x with %d (expected '0')\n", flags, GetLastError()); /* Unlock an already unlocked Handle */ SetLastError(MAGIC_DEAD); res = GlobalUnlock(gbl); /* NT: ERROR_NOT_LOCKED, 9x: untouched */ ok( !res && ((GetLastError() == ERROR_NOT_LOCKED) || (GetLastError() == MAGIC_DEAD)), "returned %d with %d (expected '0' with: ERROR_NOT_LOCKED or " "MAGIC_DEAD)\n", res, GetLastError()); GlobalFree(gbl); /* invalid handles are caught in windows: */ SetLastError(MAGIC_DEAD); hsecond = GlobalFree(gbl); /* invalid handle: free memory twice */ ok( (hsecond == gbl) && (GetLastError() == ERROR_INVALID_HANDLE), "returned %p with 0x%08x (expected %p with ERROR_INVALID_HANDLE)\n", hsecond, GetLastError(), gbl); SetLastError(MAGIC_DEAD); flags = GlobalFlags(gbl); ok( (flags == GMEM_INVALID_HANDLE) && (GetLastError() == ERROR_INVALID_HANDLE), "returned 0x%04x with 0x%08x (expected GMEM_INVALID_HANDLE with " "ERROR_INVALID_HANDLE)\n", flags, GetLastError()); SetLastError(MAGIC_DEAD); size = GlobalSize(gbl); ok( (size == 0) && (GetLastError() == ERROR_INVALID_HANDLE), "returned %ld with 0x%08x (expected '0' with ERROR_INVALID_HANDLE)\n", size, GetLastError()); SetLastError(MAGIC_DEAD); mem = GlobalLock(gbl); ok( (mem == NULL) && (GetLastError() == ERROR_INVALID_HANDLE), "returned %p with 0x%08x (expected NULL with ERROR_INVALID_HANDLE)\n", mem, GetLastError()); /* documented on MSDN: GlobalUnlock() return FALSE on failure. Win9x and wine return FALSE with ERROR_INVALID_HANDLE, but on NT 3.51 and XPsp2, TRUE with ERROR_INVALID_HANDLE is returned. The similar Test for LocalUnlock() works on all Systems */ SetLastError(MAGIC_DEAD); res = GlobalUnlock(gbl); ok(GetLastError() == ERROR_INVALID_HANDLE, "returned %d with %d (expected ERROR_INVALID_HANDLE)\n", res, GetLastError()); gbl = GlobalAlloc(GMEM_DDESHARE, 100); /* first free */ mem = GlobalFree(gbl); ok(mem == NULL, "Expected NULL, got %p\n", mem); /* invalid free */ if (sizeof(void *) != 8) /* crashes on 64-bit Vista */ { SetLastError(MAGIC_DEAD); mem = GlobalFree(gbl); ok(mem == gbl || broken(mem == NULL) /* nt4 */, "Expected gbl, got %p\n", mem); if (mem == gbl) ok(GetLastError() == ERROR_INVALID_HANDLE || GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */ "Expected ERROR_INVALID_HANDLE or ERROR_INVALID_PARAMETER, got %d\n", GetLastError()); } /* GMEM_FIXED block expands in place only without flags */ for (size = 1; size <= max_size; size <<= 1) { gbl = GlobalAlloc(GMEM_FIXED, init_size); SetLastError(MAGIC_DEAD); hsecond = GlobalReAlloc(gbl, size + init_size, 0); ok(hsecond == gbl || (hsecond == NULL && GetLastError() == ERROR_NOT_ENOUGH_MEMORY), "got %p with %x (expected %p or NULL) @%ld\n", hsecond, GetLastError(), gbl, size); GlobalFree(gbl); } /* GMEM_FIXED block can be relocated with GMEM_MOVEABLE */ for (size = 1; size <= max_size; size <<= 1) { gbl = GlobalAlloc(GMEM_FIXED, init_size); SetLastError(MAGIC_DEAD); hsecond = GlobalReAlloc(gbl, size + init_size, GMEM_MOVEABLE); ok(hsecond != NULL, "got %p with %x (expected non-NULL) @%ld\n", hsecond, GetLastError(), size); mem = GlobalLock(hsecond); ok(mem == hsecond, "got %p (expected %p) @%ld\n", mem, hsecond, size); GlobalFree(hsecond); } gbl = GlobalAlloc(GMEM_DDESHARE, 100); res = GlobalUnlock(gbl); ok(res == 1 || broken(res == 0), /* win9x */ "Expected 1 or 0, got %d\n", res); res = GlobalUnlock(gbl); ok(res == 1 || broken(res == 0), /* win9x */ "Expected 1 or 0, got %d\n", res); GlobalFree(gbl); gbl = GlobalAlloc(GMEM_FIXED, 100); SetLastError(0xdeadbeef); res = GlobalUnlock(gbl); ok(res == 1 || broken(res == 0), /* win9x */ "Expected 1 or 0, got %d\n", res); ok(GetLastError() == 0xdeadbeef, "got %d\n", GetLastError()); GlobalFree(gbl); /* GlobalSize on an invalid handle */ if (sizeof(void *) != 8) /* crashes on 64-bit Vista */ { SetLastError(MAGIC_DEAD); size = GlobalSize((HGLOBAL)0xc042); ok(size == 0, "Expected 0, got %ld\n", size); ok(GetLastError() == ERROR_INVALID_HANDLE || GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */ "Expected ERROR_INVALID_HANDLE or ERROR_INVALID_PARAMETER, got %d\n", GetLastError()); } /* ####################################### */ /* Local*() functions */ gbl = LocalAlloc(LMEM_MOVEABLE, 0); ok(gbl != NULL, "local memory not allocated for size 0\n"); gbl = LocalReAlloc(gbl, 10, LMEM_MOVEABLE); ok(gbl != NULL, "Can't realloc local memory\n"); size = LocalSize(gbl); ok(size >= 10 && size <= 16, "Memory not resized to size 10, instead size=%ld\n", size); gbl = LocalReAlloc(gbl, 0, LMEM_MOVEABLE); ok(gbl != NULL, "LocalReAlloc should not fail on size 0\n"); size = LocalSize(gbl); ok(size == 0, "Memory not resized to size 0, instead size=%ld\n", size); ok(LocalFree(gbl) == NULL, "Memory not freed\n"); size = LocalSize(gbl); ok(size == 0, "Memory should have been freed, size=%ld\n", size); gbl = LocalReAlloc(0, 10, LMEM_MOVEABLE); ok(gbl == NULL, "local realloc allocated memory\n"); /* LocalLock / LocalUnlock with a valid handle */ gbl = LocalAlloc(LMEM_MOVEABLE, 256); SetLastError(MAGIC_DEAD); mem = LocalLock(gbl); /* #1 */ ok(mem != NULL, "returned %p with %d (expected '!= NULL')\n", mem, GetLastError()); SetLastError(MAGIC_DEAD); flags = LocalFlags(gbl); ok( flags == 1, "returned 0x%04x with %d (expected '0x0001')\n", flags, GetLastError()); SetLastError(MAGIC_DEAD); msecond = LocalLock(gbl); /* #2 */ ok( msecond == mem, "returned %p with %d (expected '%p')\n", msecond, GetLastError(), mem); SetLastError(MAGIC_DEAD); flags = LocalFlags(gbl); ok( flags == 2, "returned 0x%04x with %d (expected '0x0002')\n", flags, GetLastError()); SetLastError(MAGIC_DEAD); SetLastError(MAGIC_DEAD); res = LocalUnlock(gbl); /* #1 */ ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError()); SetLastError(MAGIC_DEAD); flags = LocalFlags(gbl); ok( flags , "returned 0x%04x with %d (expected '!= 0')\n", flags, GetLastError()); SetLastError(MAGIC_DEAD); res = LocalUnlock(gbl); /* #0 */ /* NT: ERROR_SUCCESS (documented on MSDN), 9x: untouched */ ok(!res && ((GetLastError() == ERROR_SUCCESS) || (GetLastError() == MAGIC_DEAD)), "returned %d with %d (expected '0' with: ERROR_SUCCESS or " "MAGIC_DEAD)\n", res, GetLastError()); SetLastError(MAGIC_DEAD); flags = LocalFlags(gbl); ok( !flags , "returned 0x%04x with %d (expected '0')\n", flags, GetLastError()); /* Unlock an already unlocked Handle */ SetLastError(MAGIC_DEAD); res = LocalUnlock(gbl); /* NT: ERROR_NOT_LOCKED, 9x: untouched */ ok( !res && ((GetLastError() == ERROR_NOT_LOCKED) || (GetLastError() == MAGIC_DEAD)), "returned %d with %d (expected '0' with: ERROR_NOT_LOCKED or " "MAGIC_DEAD)\n", res, GetLastError()); LocalFree(gbl); /* invalid handles are caught in windows: */ SetLastError(MAGIC_DEAD); hsecond = LocalFree(gbl); /* invalid handle: free memory twice */ ok( (hsecond == gbl) && (GetLastError() == ERROR_INVALID_HANDLE), "returned %p with 0x%08x (expected %p with ERROR_INVALID_HANDLE)\n", hsecond, GetLastError(), gbl); SetLastError(MAGIC_DEAD); flags = LocalFlags(gbl); ok( (flags == LMEM_INVALID_HANDLE) && (GetLastError() == ERROR_INVALID_HANDLE), "returned 0x%04x with 0x%08x (expected LMEM_INVALID_HANDLE with " "ERROR_INVALID_HANDLE)\n", flags, GetLastError()); SetLastError(MAGIC_DEAD); size = LocalSize(gbl); ok( (size == 0) && (GetLastError() == ERROR_INVALID_HANDLE), "returned %ld with 0x%08x (expected '0' with ERROR_INVALID_HANDLE)\n", size, GetLastError()); SetLastError(MAGIC_DEAD); mem = LocalLock(gbl); ok( (mem == NULL) && (GetLastError() == ERROR_INVALID_HANDLE), "returned %p with 0x%08x (expected NULL with ERROR_INVALID_HANDLE)\n", mem, GetLastError()); /* This Test works the same on all Systems (GlobalUnlock() is different) */ SetLastError(MAGIC_DEAD); res = LocalUnlock(gbl); ok(!res && (GetLastError() == ERROR_INVALID_HANDLE), "returned %d with %d (expected '0' with ERROR_INVALID_HANDLE)\n", res, GetLastError()); /* LMEM_FIXED block expands in place only without flags */ for (size = 1; size <= max_size; size <<= 1) { gbl = LocalAlloc(LMEM_FIXED, init_size); SetLastError(MAGIC_DEAD); hsecond = LocalReAlloc(gbl, size + init_size, 0); ok(hsecond == gbl || (hsecond == NULL && GetLastError() == ERROR_NOT_ENOUGH_MEMORY), "got %p with %x (expected %p or NULL) @%ld\n", hsecond, GetLastError(), gbl, size); LocalFree(gbl); } /* LMEM_FIXED memory can be relocated with LMEM_MOVEABLE */ for (size = 1; size <= max_size; size <<= 1) { gbl = LocalAlloc(LMEM_FIXED, init_size); SetLastError(MAGIC_DEAD); hsecond = LocalReAlloc(gbl, size + init_size, LMEM_MOVEABLE); ok(hsecond != NULL, "got %p with %x (expected non-NULL) @%ld\n", hsecond, GetLastError(), size); mem = LocalLock(hsecond); ok(mem == hsecond, "got %p (expected %p) @%ld\n", mem, hsecond, size); LocalFree(hsecond); } /* trying to unlock pointer from LocalAlloc */ gbl = LocalAlloc(LMEM_FIXED, 100); SetLastError(0xdeadbeef); res = LocalUnlock(gbl); ok(res == 0, "Expected 0, got %d\n", res); ok(GetLastError() == ERROR_NOT_LOCKED || broken(GetLastError() == 0xdeadbeef) /* win9x */, "got %d\n", GetLastError()); LocalFree(gbl); /* trying to lock empty memory should give an error */ gbl = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,0); ok(gbl != NULL, "returned NULL\n"); SetLastError(MAGIC_DEAD); mem = GlobalLock(gbl); /* NT: ERROR_DISCARDED, 9x: untouched */ ok( (mem == NULL) && ((GetLastError() == ERROR_DISCARDED) || (GetLastError() == MAGIC_DEAD)), "returned %p with 0x%x/%d (expected 'NULL' with: ERROR_DISCARDED or " "MAGIC_DEAD)\n", mem, GetLastError(), GetLastError()); GlobalFree(gbl); /* trying to get size from data pointer (GMEM_MOVEABLE) */ gbl = GlobalAlloc(GMEM_MOVEABLE, 0x123); ok(gbl != NULL, "returned NULL\n"); mem = GlobalLock(gbl); ok(mem != NULL, "returned NULL.\n"); ok(gbl != mem, "unexpectedly equal.\n"); size = GlobalSize(gbl); size2 = GlobalSize(mem); ok(size == 0x123, "got %lu\n", size); ok(size2 == 0x123, "got %lu\n", size2); GlobalFree(gbl); /* trying to get size from data pointer (GMEM_FIXED) */ gbl = GlobalAlloc(GMEM_FIXED, 0x123); ok(gbl != NULL, "returned NULL\n"); mem = GlobalLock(gbl); ok(mem != NULL, "returned NULL.\n"); ok(gbl == mem, "got %p, %p.\n", gbl, mem); size = GlobalSize(gbl); ok(size == 0x123, "got %lu\n", size); GlobalFree(gbl); size = GlobalSize((void *)0xdeadbee0); ok(size == 0, "got %lu\n", size); }
BOOL WINAPI OpenDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, int nMode , int structure[3][3]) { // 指向源图像的指针 LPSTR lpSrc; // 指向缓存图像的指针 LPSTR lpDst; // 指向缓存DIB图像的指针 LPSTR lpNewDIBBits; HLOCAL hNewDIBBits; //循环变量 long i; long j; int n; int m; //像素值 unsigned char pixel; // 暂时分配内存,以保存新图像 hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight); if (hNewDIBBits == NULL) { // 分配内存失败 return FALSE; } // 锁定内存 lpNewDIBBits = (char * )LocalLock(hNewDIBBits); // 初始化新分配的内存,设定初始值为255 lpDst = (char *)lpNewDIBBits; memset(lpDst, (BYTE)255, lWidth * lHeight); if(nMode == 0) { //使用水平方向的结构元素进行腐蚀 for(j = 0; j <lHeight; j++) { for(i = 1;i <lWidth-1; i++) { //由于使用1×3的结构元素,为防止越界,所以不处理最左边和最右边的两列像素 // 指向源图像倒数第j行,第i个象素的指针 lpSrc = (char *)lpDIBBits + lWidth * j + i; // 指向目标图像倒数第j行,第i个象素的指针 lpDst = (char *)lpNewDIBBits + lWidth * j + i; //取得当前指针处的像素值,注意要转换为unsigned char型 pixel = (unsigned char)*lpSrc; //目标图像中含有0和255外的其它灰度值 if(pixel != 255 && *lpSrc != 0) return FALSE; //目标图像中的当前点先赋成黑色 *lpDst = (unsigned char)0; //如果源图像中当前点自身或者左右有一个点不是黑色, //则将目标图像中的当前点赋成白色 for (n = 0;n < 3;n++ ) { pixel = *(lpSrc+n-1); if (pixel == 255 ) { *lpDst = (unsigned char)255; break; } } } } } else if(nMode == 1) { //使用垂直方向的结构元素进行腐蚀 for(j = 1; j <lHeight-1; j++) { for(i = 0;i <lWidth; i++) { //由于使用1×3的结构元素,为防止越界,所以不处理最上边和最下边的两列像素 // 指向源图像倒数第j行,第i个象素的指针 lpSrc = (char *)lpDIBBits + lWidth * j + i; // 指向目标图像倒数第j行,第i个象素的指针 lpDst = (char *)lpNewDIBBits + lWidth * j + i; //取得当前指针处的像素值,注意要转换为unsigned char型 pixel = (unsigned char)*lpSrc; //目标图像中含有0和255外的其它灰度值 if(pixel != 255 && *lpSrc != 0) return FALSE; //目标图像中的当前点先赋成黑色 *lpDst = (unsigned char)0; //如果源图像中当前点自身或者上下有一个点不是黑色, //则将目标图像中的当前点赋成白色 for (n = 0;n < 3;n++ ) { pixel = *(lpSrc+(n-1)*lWidth); if (pixel == 255 ) { *lpDst = (unsigned char)255; break; } } } } } else { //使用自定义的结构元素进行腐蚀 for(j = 1; j <lHeight-1; j++) { for(i = 0;i <lWidth; i++) { //由于使用3×3的结构元素,为防止越界,所以不处理最左边和最右边的两列像素 //和最上边和最下边的两列像素 // 指向源图像倒数第j行,第i个象素的指针 lpSrc = (char *)lpDIBBits + lWidth * j + i; // 指向目标图像倒数第j行,第i个象素的指针 lpDst = (char *)lpNewDIBBits + lWidth * j + i; //取得当前指针处的像素值,注意要转换为unsigned char型 pixel = (unsigned char)*lpSrc; //目标图像中含有0和255外的其它灰度值 if(pixel != 255 && *lpSrc != 0) return FALSE; //目标图像中的当前点先赋成黑色 *lpDst = (unsigned char)0; //如果原图像中对应结构元素中为黑色的那些点中有一个不是黑色, //则将目标图像中的当前点赋成白色 //注意在DIB图像中内容是上下倒置的 for (m = 0;m < 3;m++ ) { for (n = 0;n < 3;n++) { if( structure[m][n] == -1) continue; pixel = *(lpSrc + ((2-m)-1)*lWidth + (n-1)); if (pixel == 255 ) { *lpDst = (unsigned char)255; break; } } } } } } // 复制腐蚀后的图像 memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight); // 重新初始化新分配的内存,设定初始值为255 //lpDst = (char *)lpNewDIBBits; //memset(lpDst, (BYTE)255, lWidth * lHeight); if(nMode == 0) { //使用水平方向的结构元素进行膨胀 for(j = 0; j <lHeight; j++) { for(i = 1;i <lWidth-1; i++) { //由于使用1×3的结构元素,为防止越界,所以不处理最左边和最右边的两列像素 // 指向源图像倒数第j行,第i个象素的指针 lpSrc = (char *)lpDIBBits + lWidth * j + i; // 指向目标图像倒数第j行,第i个象素的指针 lpDst = (char *)lpNewDIBBits + lWidth * j + i; //取得当前指针处的像素值,注意要转换为unsigned char型 pixel = (unsigned char)*lpSrc; //目标图像中含有0和255外的其它灰度值 if(pixel != 255 && *lpSrc != 0) return FALSE; //目标图像中的当前点先赋成白色 *lpDst = (unsigned char)255; //源图像中当前点自身或者左右只要有一个点是黑色, //则将目标图像中的当前点赋成黑色 for (n = 0;n < 3;n++ ) { pixel = *(lpSrc+n-1); if (pixel == 0 ) { *lpDst = (unsigned char)0; break; } } } } } else if(nMode == 1) { //使用垂直方向的结构元素进行膨胀 for(j = 1; j <lHeight-1; j++) { for(i = 0;i <lWidth; i++) { //由于使用1×3的结构元素,为防止越界,所以不处理最上边和最下边的两列像素 // 指向源图像倒数第j行,第i个象素的指针 lpSrc = (char *)lpDIBBits + lWidth * j + i; // 指向目标图像倒数第j行,第i个象素的指针 lpDst = (char *)lpNewDIBBits + lWidth * j + i; //取得当前指针处的像素值,注意要转换为unsigned char型 pixel = (unsigned char)*lpSrc; //目标图像中含有0和255外的其它灰度值 if(pixel != 255 && *lpSrc != 0) return FALSE; //目标图像中的当前点先赋成白色 *lpDst = (unsigned char)255; //源图像中当前点自身或者上下只要有一个点是黑色, //则将目标图像中的当前点赋成黑色 for (n = 0;n < 3;n++ ) { pixel = *(lpSrc+(n-1)*lWidth); if (pixel == 0 ) { *lpDst = (unsigned char)0; break; } } } } } else { //使用自定义的结构元素进行膨胀 for(j = 1; j <lHeight-1; j++) { for(i = 0;i <lWidth; i++) { //由于使用3×3的结构元素,为防止越界,所以不处理最左边和最右边的两列像素 //和最上边和最下边的两列像素 // 指向源图像倒数第j行,第i个象素的指针 lpSrc = (char *)lpDIBBits + lWidth * j + i; // 指向目标图像倒数第j行,第i个象素的指针 lpDst = (char *)lpNewDIBBits + lWidth * j + i; //取得当前指针处的像素值,注意要转换为unsigned char型 pixel = (unsigned char)*lpSrc; //目标图像中含有0和255外的其它灰度值 if(pixel != 255 && *lpSrc != 0) return FALSE; //目标图像中的当前点先赋成白色 *lpDst = (unsigned char)255; //原图像中对应结构元素中为黑色的那些点中只要有一个是黑色, //则将目标图像中的当前点赋成黑色 //注意在DIB图像中内容是上下倒置的 for (m = 0;m < 3;m++ ) { for (n = 0;n < 3;n++) { if( structure[m][n] == -1) continue; pixel = *(lpSrc + ((2-m)-1)*lWidth + (n-1)); if (pixel == 0 ) { *lpDst = (unsigned char)0; break; } } } } } } // 复制膨胀后的图像 memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight); // 释放内存 LocalUnlock(hNewDIBBits); LocalFree(hNewDIBBits); return TRUE; }
void WCMD_batch (WCHAR *file, WCHAR *command, BOOL called, WCHAR *startLabel, HANDLE pgmHandle) { HANDLE h = INVALID_HANDLE_VALUE; BATCH_CONTEXT *prev_context; if (startLabel == NULL) { h = CreateFileW (file, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (h == INVALID_HANDLE_VALUE) { SetLastError (ERROR_FILE_NOT_FOUND); WCMD_print_error (); return; } } else { DuplicateHandle(GetCurrentProcess(), pgmHandle, GetCurrentProcess(), &h, 0, FALSE, DUPLICATE_SAME_ACCESS); } /* * Create a context structure for this batch file. */ prev_context = context; context = LocalAlloc (LMEM_FIXED, sizeof (BATCH_CONTEXT)); context -> h = h; context->batchfileW = WCMD_strdupW(file); context -> command = command; memset(context -> shift_count, 0x00, sizeof(context -> shift_count)); context -> prev_context = prev_context; context -> skip_rest = FALSE; /* If processing a call :label, 'goto' the label in question */ if (startLabel) { strcpyW(param1, startLabel); WCMD_goto(NULL); } /* * Work through the file line by line. Specific batch commands are processed here, * the rest are handled by the main command processor. */ while (context -> skip_rest == FALSE) { CMD_LIST *toExecute = NULL; /* Commands left to be executed */ if (!WCMD_ReadAndParseLine(NULL, &toExecute, h)) break; /* Note: although this batch program itself may be called, we are not retrying the command as a result of a call failing to find a program, hence the retryCall parameter below is FALSE */ WCMD_process_commands(toExecute, FALSE, FALSE); WCMD_free_commands(toExecute); toExecute = NULL; } CloseHandle (h); /* * If there are outstanding setlocal's to the current context, unwind them. */ while (saved_environment && saved_environment->batchhandle == context->h) { WCMD_endlocal(); } /* * If invoked by a CALL, we return to the context of our caller. Otherwise return * to the caller's caller. */ HeapFree(GetProcessHeap(), 0, context->batchfileW); LocalFree (context); if ((prev_context != NULL) && (!called)) { WINE_TRACE("Batch completed, but was not 'called' so skipping outer batch too\n"); prev_context -> skip_rest = TRUE; context = prev_context; } context = prev_context; }
BOOL WINAPI ThiningDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight) { // 指向源图像的指针 LPSTR lpSrc; // 指向缓存图像的指针 LPSTR lpDst; // 指向缓存DIB图像的指针 LPSTR lpNewDIBBits; HLOCAL hNewDIBBits; //脏标记 BOOL bModified; //循环变量 long i; long j; int n; int m; //四个条件 BOOL bCondition1; BOOL bCondition2; BOOL bCondition3; BOOL bCondition4; //计数器 unsigned char nCount; //像素值 unsigned char pixel; //5×5相邻区域像素值 unsigned char neighbour[5][5]; // 暂时分配内存,以保存新图像 hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight); if (hNewDIBBits == NULL) { // 分配内存失败 return FALSE; } // 锁定内存 lpNewDIBBits = (char * )LocalLock(hNewDIBBits); // 初始化新分配的内存,设定初始值为255 lpDst = (char *)lpNewDIBBits; memset(lpDst, (BYTE)255, lWidth * lHeight); bModified=TRUE; while(bModified) { bModified = FALSE; // 初始化新分配的内存,设定初始值为255 lpDst = (char *)lpNewDIBBits; memset(lpDst, (BYTE)255, lWidth * lHeight); for(j = 2; j <lHeight-2; j++) { for(i = 2;i <lWidth-2; i++) { bCondition1 = FALSE; bCondition2 = FALSE; bCondition3 = FALSE; bCondition4 = FALSE; //由于使用5×5的结构元素,为防止越界,所以不处理外围的几行和几列像素 // 指向源图像倒数第j行,第i个象素的指针 lpSrc = (char *)lpDIBBits + lWidth * j + i; // 指向目标图像倒数第j行,第i个象素的指针 lpDst = (char *)lpNewDIBBits + lWidth * j + i; //取得当前指针处的像素值,注意要转换为unsigned char型 pixel = (unsigned char)*lpSrc; //目标图像中含有0和255外的其它灰度值 if(pixel != 255 && *lpSrc != 0) //return FALSE; continue; //如果源图像中当前点为白色,则跳过 else if(pixel == 255) continue; //获得当前点相邻的5×5区域内像素值,白色用0代表,黑色用1代表 for (m = 0;m < 5;m++ ) { for (n = 0;n < 5;n++) { neighbour[m][n] =(255 - (unsigned char)*(lpSrc + ((4 - m) - 2)*lWidth + n - 2 )) / 255; } } // neighbour[][] //逐个判断条件。 //判断2<=NZ(P1)<=6 nCount = neighbour[1][1] + neighbour[1][2] + neighbour[1][3] \ + neighbour[2][1] + neighbour[2][3] + \ + neighbour[3][1] + neighbour[3][2] + neighbour[3][3]; if ( nCount >= 2 && nCount <=6) bCondition1 = TRUE; //判断Z0(P1)=1 nCount = 0; if (neighbour[1][2] == 0 && neighbour[1][1] == 1) nCount++; if (neighbour[1][1] == 0 && neighbour[2][1] == 1) nCount++; if (neighbour[2][1] == 0 && neighbour[3][1] == 1) nCount++; if (neighbour[3][1] == 0 && neighbour[3][2] == 1) nCount++; if (neighbour[3][2] == 0 && neighbour[3][3] == 1) nCount++; if (neighbour[3][3] == 0 && neighbour[2][3] == 1) nCount++; if (neighbour[2][3] == 0 && neighbour[1][3] == 1) nCount++; if (neighbour[1][3] == 0 && neighbour[1][2] == 1) nCount++; if (nCount == 1) bCondition2 = TRUE; //判断P2*P4*P8=0 or Z0(p2)!=1 if (neighbour[1][2]*neighbour[2][1]*neighbour[2][3] == 0) bCondition3 = TRUE; else { nCount = 0; if (neighbour[0][2] == 0 && neighbour[0][1] == 1) nCount++; if (neighbour[0][1] == 0 && neighbour[1][1] == 1) nCount++; if (neighbour[1][1] == 0 && neighbour[2][1] == 1) nCount++; if (neighbour[2][1] == 0 && neighbour[2][2] == 1) nCount++; if (neighbour[2][2] == 0 && neighbour[2][3] == 1) nCount++; if (neighbour[2][3] == 0 && neighbour[1][3] == 1) nCount++; if (neighbour[1][3] == 0 && neighbour[0][3] == 1) nCount++; if (neighbour[0][3] == 0 && neighbour[0][2] == 1) nCount++; if (nCount != 1) bCondition3 = TRUE; } //判断P2*P4*P6=0 or Z0(p4)!=1 if (neighbour[1][2]*neighbour[2][1]*neighbour[3][2] == 0) bCondition4 = TRUE; else { nCount = 0; if (neighbour[1][1] == 0 && neighbour[1][0] == 1) nCount++; if (neighbour[1][0] == 0 && neighbour[2][0] == 1) nCount++; if (neighbour[2][0] == 0 && neighbour[3][0] == 1) nCount++; if (neighbour[3][0] == 0 && neighbour[3][1] == 1) nCount++; if (neighbour[3][1] == 0 && neighbour[3][2] == 1) nCount++; if (neighbour[3][2] == 0 && neighbour[2][2] == 1) nCount++; if (neighbour[2][2] == 0 && neighbour[1][2] == 1) nCount++; if (neighbour[1][2] == 0 && neighbour[1][1] == 1) nCount++; if (nCount != 1) bCondition4 = TRUE; } if(bCondition1 && bCondition2 && bCondition3 && bCondition4) { *lpDst = (unsigned char)255; bModified = TRUE; } else { *lpDst = (unsigned char)0; } } } // 复制腐蚀后的图像 memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight); } // 复制腐蚀后的图像 memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight); // 释放内存 LocalUnlock(hNewDIBBits); LocalFree(hNewDIBBits); // 返回 return TRUE; }
PyObject * PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject) { PyObject *v; char *s; int i = errno; #ifdef PLAN9 char errbuf[ERRMAX]; #endif #ifdef MS_WINDOWS char *s_buf = NULL; char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */ #endif #ifdef EINTR if (i == EINTR && PyErr_CheckSignals()) return NULL; #endif #ifdef PLAN9 rerrstr(errbuf, sizeof errbuf); s = errbuf; #else if (i == 0) s = "Error"; /* Sometimes errno didn't get set */ else #ifndef MS_WINDOWS s = strerror(i); #else { /* Note that the Win32 errors do not lineup with the errno error. So if the error is in the MSVC error table, we use it, otherwise we assume it really _is_ a Win32 error code */ if (i > 0 && i < _sys_nerr) { s = _sys_errlist[i]; } else { int len = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, /* no message source */ i, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */ (LPTSTR) &s_buf, 0, /* size not used */ NULL); /* no args */ if (len==0) { /* Only ever seen this in out-of-mem situations */ sprintf(s_small_buf, "Windows Error 0x%X", i); s = s_small_buf; s_buf = NULL; } else { s = s_buf; /* remove trailing cr/lf and dots */ while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.')) s[--len] = '\0'; } } } #endif /* Unix/Windows */ #endif /* PLAN 9*/ if (filenameObject != NULL) v = Py_BuildValue("(isO)", i, s, filenameObject); else v = Py_BuildValue("(is)", i, s); if (v != NULL) { PyErr_SetObject(exc, v); Py_DECREF(v); } #ifdef MS_WINDOWS LocalFree(s_buf); #endif return NULL; }
void RNS2_Berkley::RecvFromBlockingIPV4And6(RNS2RecvStruct *recvFromStruct) { #if RAKNET_SUPPORT_IPV6==1 sockaddr_storage their_addr; sockaddr* sockAddrPtr; socklen_t sockLen; socklen_t* socketlenPtr=(socklen_t*) &sockLen; memset(&their_addr,0,sizeof(their_addr)); int dataOutSize; const int flag=0; { sockLen=sizeof(their_addr); sockAddrPtr=(sockaddr*) &their_addr; } dataOutSize=MAXIMUM_MTU_SIZE; recvFromStruct->bytesRead = recvfrom__(rns2Socket, recvFromStruct->data, dataOutSize, flag, sockAddrPtr, socketlenPtr ); #if defined(_WIN32) && defined(_DEBUG) && !defined(WINDOWS_PHONE_8) if (recvFromStruct->bytesRead==-1) { DWORD dwIOError = GetLastError(); if (dwIoError != 10035) { LPVOID messageBuffer; FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dwIOError, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), // Default language ( LPTSTR ) & messageBuffer, 0, NULL ); // I see this hit on XP with IPV6 for some reason RAKNET_DEBUG_PRINTF( "Warning: recvfrom failed:Error code - %d\n%s", dwIOError, messageBuffer ); LocalFree( messageBuffer ); } } #endif if (recvFromStruct->bytesRead<=0) return; recvFromStruct->timeRead=RakNet::GetTimeUS(); { if (their_addr.ss_family==AF_INET) { memcpy(&recvFromStruct->systemAddress.address.addr4,(sockaddr_in *)&their_addr,sizeof(sockaddr_in)); recvFromStruct->systemAddress.debugPort=ntohs(recvFromStruct->systemAddress.address.addr4.sin_port); // systemAddressOut->address.addr4.sin_port=ntohs( systemAddressOut->address.addr4.sin_port ); } else { memcpy(&recvFromStruct->systemAddress.address.addr6,(sockaddr_in6 *)&their_addr,sizeof(sockaddr_in6)); recvFromStruct->systemAddress.debugPort=ntohs(recvFromStruct->systemAddress.address.addr6.sin6_port); // systemAddressOut->address.addr6.sin6_port=ntohs( systemAddressOut->address.addr6.sin6_port ); } } #else (void) recvFromStruct; #endif }