Pimpl (String name, const int timeOutMillisecs)
: handle (0), refCount (1)
{
name = name.replaceCharacter ('\\', '/');
handle = CreateMutexW (0, TRUE, ("Global\\" + name).toWideCharPointer());
// Not 100% sure why a global mutex sometimes can't be allocated, but if it fails, fall back to
// a local one. (A local one also sometimes fails on other machines so neither type appears to be
// universally reliable)
if (handle == 0)
handle = CreateMutexW (0, TRUE, ("Local\\" + name).toWideCharPointer());
if (handle != 0 && GetLastError() == ERROR_ALREADY_EXISTS)
{
if (timeOutMillisecs == 0)
{
close();
return;
}
switch (WaitForSingleObject (handle, timeOutMillisecs < 0 ? INFINITE : timeOutMillisecs))
{
case WAIT_OBJECT_0:
case WAIT_ABANDONED:
break;
case WAIT_TIMEOUT:
default:
close();
break;
}
}
}
static BOOL winpidgin_set_running(BOOL fail_if_running) {
HANDLE h;
if ((h = CreateMutexW(NULL, FALSE, L"pidgin_is_running"))) {
DWORD err = GetLastError();
if (err == ERROR_ALREADY_EXISTS) {
if (fail_if_running) {
HWND msg_win;
printf("An instance of Pidgin is already running.\n");
if((msg_win = FindWindowExW(NULL, NULL, L"WinpidginMsgWinCls", NULL)))
if(SendMessage(msg_win, PIDGIN_WM_FOCUS_REQUEST, (WPARAM) NULL, (LPARAM) NULL))
return FALSE;
/* If we get here, the focus request wasn't successful */
MessageBoxW(NULL,
L"An instance of Pidgin is already running",
NULL, MB_OK | MB_TOPMOST);
return FALSE;
}
} else if (err != ERROR_SUCCESS)
printf("Error (%u) accessing \"pidgin_is_running\" mutex.\n", (UINT) err);
}
return TRUE;
}
void CWE253_Incorrect_Check_of_Function_Return_Value__wchar_t_w32CreateMutex_15_bad()
{
switch(6)
{
case 6:
{
HANDLE hMutex = NULL;
hMutex = CreateMutexW(NULL, FALSE, NULL);
/* FLAW: If CreateMutexW() failed, the return value will be NULL,
but we are checking to see if the return value is INVALID_HANDLE_VALUE */
if (hMutex == INVALID_HANDLE_VALUE)
{
exit(1);
}
/* We'll leave out most of the implementation since it has nothing to do with the CWE
* and since the checkers are looking for certain function calls anyway */
CloseHandle(hMutex);
}
break;
default:
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
printLine("Benign, fixed string");
break;
}
}
/******************************************************************
* CreateAssemblyCache (FUSION.@)
*/
HRESULT WINAPI CreateAssemblyCache(IAssemblyCache **ppAsmCache, DWORD dwReserved)
{
IAssemblyCacheImpl *cache;
TRACE("(%p, %d)\n", ppAsmCache, dwReserved);
if (!ppAsmCache)
return E_INVALIDARG;
*ppAsmCache = NULL;
cache = HeapAlloc(GetProcessHeap(), 0, sizeof(IAssemblyCacheImpl));
if (!cache)
return E_OUTOFMEMORY;
cache->IAssemblyCache_iface.lpVtbl = &AssemblyCacheVtbl;
cache->ref = 1;
cache->lock = CreateMutexW( NULL, FALSE, cache_mutex_nameW );
if (!cache->lock)
{
HeapFree( GetProcessHeap(), 0, cache );
return HRESULT_FROM_WIN32( GetLastError() );
}
*ppAsmCache = &cache->IAssemblyCache_iface;
return S_OK;
}
void apply_emet(HMODULE pHandle, int a2)
{
// has this point
if ( setting_heapspray )
heapspray_apply();
if ( setting_bottomuprand )
bottomuprand_apply();
if ( setting_nullpage )
nullpage_apply();
if ( setting_dep )
enableDEP();
if ( setting_sehop ){
getModuleHandleEx(pHandle);
set_sehop_ceh_handler();
enable_sehop = 1;
}
if ( setting_eaf ){
hook_eat(L"kernel32.dll");
hook_eat(L"ntdll.dll");
HMODULE handle;
getModuleHandleEx(handle);
set_ceh_handler();
HANDLE thread_lock = CreateMutexW(0, 1, 0);
thread_count = 0;
ReleaseMutex(thread_lock);
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)StartAddress, 0, 0, 0);
has_new_thread = true;
save_current_threadid();
}
}
int APIENTRY WinMain(HINSTANCE hInstance
,HINSTANCE /*hPrevInstance*/
,LPSTR /*lpCmdLine*/
,int /*nCmdShow*/) {
auto exh = std::make_unique<google_breakpad::ExceptionHandler>( L".", nullptr, nullptr, nullptr, google_breakpad::ExceptionHandler::HANDLER_ALL, MiniDumpWithFullMemory, (const wchar_t*)nullptr, nullptr );
//int arg_c;
//auto arg_v = CommandLineToArgvW(GetCommandLine(), &arg_c);
auto hMutex = CreateMutexW(nullptr, TRUE, L"swtor_log_analizer_unique");
//WaitForSingleObject(hMutex, INFINITE);
/*
auto wnd = CreateDialogParamW(hInstance, MAKEINTRESOURCEW(IDD_MAIN_WINDOW), nullptr, DialogProc, 5);
ShowWindow(wnd,SW_NORMAL);
MSG msg
{};
while ( GetMessageW(&msg, wnd, 0, 0) ) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
DestroyWindow(wnd);*/
try {
app { APP_CATION, CONFIG_PATH }();
} catch ( const std::exception& e ) {
MessageBoxA(nullptr, e.what(), "Crash!", 0);
} catch ( ... ) {
MessageBoxA(nullptr, "Very bad crash", "Crash!", 0);
}
CloseHandle(hMutex);
}
int main(int argc, char* argv[])
{
DWORD dwError;
DWORD id1,id2;
AllocConsole();
InputHandle = GetStdHandle(STD_INPUT_HANDLE);
OutputHandle = GetStdHandle(STD_OUTPUT_HANDLE);
dprintf("Calling CreateMutex()\n");
hMutex = CreateMutexW(NULL, FALSE, L"TestMutex");
if (hMutex == INVALID_HANDLE_VALUE)
{
dprintf("CreateMutex() failed! Error: %lu\n", GetLastError());
return 0;
}
dprintf("CreateMutex() succeeded!\n");
hThread[0] = CreateThread(0, 0, thread1, 0, 0, &id1);
hThread[1] = CreateThread(0, 0, thread2, 0, 0, &id2);
dprintf("Calling WaitForMultipleObject()\n");
dwError = WaitForMultipleObjects(2, hThread, TRUE, INFINITE);
dprintf("WaitForMultipleObject() Error: %lu\n", dwError);
CloseHandle(hThread[0]);
CloseHandle(hThread[1]);
CloseHandle(hMutex);
dprintf("Main thread done!\n");
return 0;
}
/* Lock a spawning process. The caller needs to provide the address
of a variable to store the lock information and the name or the
process. */
gpg_error_t
gpgol_lock_spawning (lock_spawn_t *lock)
{
int waitrc;
int timeout = 5;
*lock = CreateMutexW (NULL, FALSE, L"spawn_gnupg_uiserver_sentinel");
if (!*lock)
{
log_error ("failed to create the spawn mutex: rc=%ld", GetLastError ());
return gpg_error (GPG_ERR_GENERAL);
}
retry:
waitrc = WaitForSingleObject (*lock, 1000);
if (waitrc == WAIT_OBJECT_0)
return 0;
if (waitrc == WAIT_TIMEOUT && timeout)
{
timeout--;
goto retry;
}
if (waitrc == WAIT_TIMEOUT)
log_error ("error waiting for the spawn mutex: timeout");
else
log_error ("error waiting for the spawn mutex: (code=%d) rc=%ld",
waitrc, GetLastError ());
return gpg_error (GPG_ERR_GENERAL);
}
SystemWideMutex::MutexData::MutexData(const wchar_t *mutex_name)
: m_acquired(0)
{
static const wchar_t prefix[] = L"csr_mutex_";
// this call previously used _alloca. It is probably better to do so,
// but I'm a coward when it comes to new things... this string gets
// deleted at the end of the function.
#ifdef MUTEX_LOG
enable_logging_ = (wcscmp(mutex_name, L"spi_app_mutex" ) == 0);
#endif
wchar_t * string = new wchar_t [ wcslen(mutex_name) + wcslen(prefix) + 1 ];
wcscpy(string, prefix);
wcscat(string, mutex_name);
wchar_t *sp = string;
while (*sp)
{
if (wcschr(L".\\/\"*", *sp))
*sp = L'-';
sp++;
}
handle = CreateMutexW(NULL, 0, string);
OUTPUT_HANDLE_CREATE(handle);
// OutputDebugString("Mutex created:");
// OutputDebugString(string);
// OutputDebugString("\n");
// int lasterr = GetLastError();
// assert(handle);
delete string;
}
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow)
{
HANDLE hMutex;
INITCOMMONCONTROLSEX icex;
_wsetlocale(LC_ALL, L"JPN");
hInst = hInstance;
CreateConfigPath();
hMutex = CreateMutexW(NULL, FALSE, cnfmutexname);
if(hMutex == NULL || GetLastError() == ERROR_ALREADY_EXISTS)
{
return 0;
}
icex.dwSize = sizeof(icex);
icex.dwICC = ICC_LISTVIEW_CLASSES | ICC_TAB_CLASSES | ICC_PROGRESS_CLASS;
InitCommonControlsEx(&icex);
CreateProperty();
return 0;
}
MutexImpl::MutexImpl(MutexTypeImpl type)
: _lockCount(0)
, _recursive(type == MUTEX_RECURSIVE_IMPL)
{
_mutex = CreateMutexW(NULL, FALSE, NULL);
if (!_mutex) throw SystemException("cannot create mutex");
}
BOOL DoStartStartupItems(ITrayWindow *Tray)
{
DWORD dwWait;
if (!bExplorerIsShell)
return FALSE;
if (!s_hStartupMutex)
{
// Accidentally, there is possibility that the system starts multiple Explorers
// before startup of shell. We use a mutex to match the timing of shell initialization.
s_hStartupMutex = CreateMutexW(NULL, FALSE, L"ExplorerIsShellMutex");
if (s_hStartupMutex == NULL)
return FALSE;
}
dwWait = WaitForSingleObject(s_hStartupMutex, INFINITE);
TRACE("dwWait: 0x%08lX\n", dwWait);
if (dwWait != WAIT_OBJECT_0)
{
TRACE("LastError: %ld\n", GetLastError());
DoFinishStartupItems();
return FALSE;
}
const DWORD dwWaitTotal = 3000; // in milliseconds
DWORD dwTick = GetTickCount();
while (GetShellWindow() == NULL && GetTickCount() - dwTick < dwWaitTotal)
{
TrayProcessMessages(Tray);
}
if (GetShellWindow() == NULL)
{
DoFinishStartupItems();
return FALSE;
}
// Check the volatile "StartupHasBeenRun" key
HKEY hSessionKey, hKey;
HRESULT hr = SHCreateSessionKey(KEY_WRITE, &hSessionKey);
if (SUCCEEDED(hr))
{
ASSERT(hSessionKey);
DWORD dwDisp;
LONG Error = RegCreateKeyExW(hSessionKey, L"StartupHasBeenRun", 0, NULL,
REG_OPTION_VOLATILE, KEY_WRITE, NULL, &hKey, &dwDisp);
RegCloseKey(hSessionKey);
RegCloseKey(hKey);
if (Error == ERROR_SUCCESS && dwDisp == REG_OPENED_EXISTING_KEY)
{
return FALSE; // Startup programs has already been run
}
}
return TRUE;
}
NamedMutexImpl::NamedMutexImpl(const std::string& name):
_name(name)
{
UnicodeConverter::toUTF16(_name, _uname);
_mutex = CreateMutexW(NULL, FALSE, _uname.c_str());
if (!_mutex)
throw SystemException("cannot create named mutex", _name);
}
static int socket_open(int domain, int type, int protocol)
{
/* Translation constants to their Windows counterparts */
int win32_af = translate_address_family(domain);
if (win32_af < 0)
return win32_af;
int win32_type;
switch (type & LINUX_SOCK_TYPE_MASK)
{
case LINUX_SOCK_DGRAM: win32_type = SOCK_DGRAM; break;
case LINUX_SOCK_STREAM: win32_type = SOCK_STREAM; break;
case LINUX_SOCK_RAW: win32_type = SOCK_RAW; break;
case LINUX_SOCK_RDM: win32_type = SOCK_RDM; break;
case LINUX_SOCK_SEQPACKET: win32_type = SOCK_SEQPACKET; break;
default:
log_error("Unknown type: %d", type & LINUX_SOCK_TYPE_MASK);
return -L_EPROTONOSUPPORT;
}
socket_ensure_initialized();
SOCKET sock = socket(win32_af, win32_type, protocol);
if (sock == INVALID_SOCKET)
{
log_warning("socket() failed, error code: %d", WSAGetLastError());
return translate_socket_error(WSAGetLastError());
}
HANDLE event_handle = init_socket_event(sock);
if (!event_handle)
{
closesocket(sock);
log_error("init_socket_event() failed.");
return -L_ENFILE;
}
HANDLE mutex;
SECURITY_ATTRIBUTES attr;
attr.nLength = sizeof(SECURITY_ATTRIBUTES);
attr.lpSecurityDescriptor = NULL;
attr.bInheritHandle = TRUE;
mutex = CreateMutexW(&attr, FALSE, NULL);
struct socket_file *f = (struct socket_file *) kmalloc(sizeof(struct socket_file));
file_init(&f->base_file, &socket_ops, O_RDWR);
f->socket = sock;
f->event_handle = event_handle;
f->mutex = mutex;
f->shared = (struct socket_file_shared *)kmalloc_shared(sizeof(struct socket_file_shared));
f->shared->af = domain;
f->shared->type = (type & LINUX_SOCK_TYPE_MASK);
f->shared->events = 0;
f->shared->connect_error = 0;
if ((type & O_NONBLOCK))
f->base_file.flags |= O_NONBLOCK;
int fd = vfs_store_file((struct file *)f, (type & O_CLOEXEC) > 0);
if (fd < 0)
vfs_release((struct file *)f);
return fd;
}
HANDLE
XCECreateMutexW(LPSECURITY_ATTRIBUTES sa, BOOL io, LPTSTR name)
{
HANDLE hnd;
hnd = CreateMutexW(sa, io, name);
WCETRACE(WCE_SYNCH, "cmw: %p", hnd);
return(hnd);
}
static int winfs_open(struct file_system *fs, const char *pathname, int flags, int mode, struct file **fp, char *target, int buflen)
{
/* TODO: mode */
DWORD desired_access, create_disposition;
HANDLE handle;
if (flags & O_PATH)
desired_access = 0;
else if (flags & O_RDWR)
desired_access = GENERIC_READ | GENERIC_WRITE;
else if (flags & O_WRONLY)
desired_access = GENERIC_WRITE;
else
desired_access = GENERIC_READ;
if (flags & __O_DELETE)
desired_access |= DELETE;
if (flags & O_EXCL)
create_disposition = FILE_CREATE;
else if (flags & O_CREAT)
create_disposition = FILE_OPEN_IF;
else
create_disposition = FILE_OPEN;
int r = open_file(&handle, pathname, desired_access, create_disposition, flags, fp != NULL, target, buflen);
if (r < 0 || r == 1)
return r;
if ((flags & O_TRUNC) && ((flags & O_WRONLY) || (flags & O_RDWR)))
{
/* Truncate the file */
FILE_END_OF_FILE_INFORMATION info;
info.EndOfFile.QuadPart = 0;
IO_STATUS_BLOCK status_block;
NTSTATUS status = NtSetInformationFile(handle, &status_block, &info, sizeof(info), FileEndOfFileInformation);
if (!NT_SUCCESS(status))
log_error("NtSetInformationFile() failed, status: %x", status);
}
if (fp)
{
int pathlen = strlen(pathname);
struct winfs_file *file = (struct winfs_file *)kmalloc(sizeof(struct winfs_file) + pathlen);
file_init(&file->base_file, &winfs_ops, flags);
file->handle = handle;
SECURITY_ATTRIBUTES attr;
attr.nLength = sizeof(SECURITY_ATTRIBUTES);
attr.bInheritHandle = TRUE;
attr.lpSecurityDescriptor = NULL;
/* TODO: Don't need this mutex for directory or symlink */
file->fp_mutex = CreateMutexW(&attr, FALSE, NULL);
file->restart_scan = 1;
file->pathlen = pathlen;
memcpy(file->pathname, pathname, pathlen);
*fp = (struct file *)file;
}
else
CloseHandle(handle);
return 0;
}
DWORD service_start(struct service_entry *service, DWORD service_argc, LPCWSTR *service_argv)
{
DWORD err;
LPWSTR name;
HANDLE process_handle = NULL;
err = scmdatabase_lock_startup(service->db);
if (err != ERROR_SUCCESS)
return err;
if (WaitForSingleObject(service->process, 0) == WAIT_TIMEOUT)
{
scmdatabase_unlock_startup(service->db);
return ERROR_SERVICE_ALREADY_RUNNING;
}
CloseHandle(service->control_pipe);
service->control_mutex = CreateMutexW(NULL, TRUE, NULL);
if (!service->status_changed_event)
service->status_changed_event = CreateEventW(NULL, FALSE, FALSE, NULL);
if (!service->overlapped_event)
service->overlapped_event = CreateEventW(NULL, TRUE, FALSE, NULL);
name = service_get_pipe_name();
service->control_pipe = CreateNamedPipeW(name, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
PIPE_TYPE_BYTE|PIPE_WAIT, 1, 256, 256, 10000, NULL );
HeapFree(GetProcessHeap(), 0, name);
if (service->control_pipe==INVALID_HANDLE_VALUE)
{
WINE_ERR("failed to create pipe for %s, error = %d\n",
wine_dbgstr_w(service->name), GetLastError());
err = GetLastError();
}
else
{
err = service_start_process(service, &process_handle);
if (err == ERROR_SUCCESS)
{
if (!service_send_start_message(service, process_handle, service_argv, service_argc))
err = ERROR_SERVICE_REQUEST_TIMEOUT;
}
if (err == ERROR_SUCCESS)
err = service_wait_for_startup(service, process_handle);
}
if (err == ERROR_SUCCESS)
ReleaseMutex(service->control_mutex);
else
service_terminate(service);
scmdatabase_unlock_startup(service->db);
WINE_TRACE("returning %d\n", err);
return err;
}
HOOKFUNC HANDLE WINAPI MyCreateMutexW(LPSECURITY_ATTRIBUTES lpMutexWttributes, BOOL bInitialOwner, LPCSTR lpName)
{
HANDLE rv = CreateMutexW(lpMutexWttributes, bInitialOwner, lpName);
debuglog(LCF_SYNCOBJ, __FUNCTION__ " returned 0x%X.\n", rv);
EnterCriticalSection(&s_handleCS);
std::set<HANDLE>& handles = s_threadIdHandles[GetCurrentThreadId()];
handles.insert(rv);
LeaveCriticalSection(&s_handleCS);
return rv;
}
int __cdecl main( int argc, char **argv)
{
HANDLE Mutex;
HANDLE hThread = 0;
DWORD dwThreadId = 0;
int ret;
if (0 != (PAL_Initialize(argc, argv)))
{
return FAIL;
}
Mutex = CreateMutexW(NULL, FALSE, NULL);
if (Mutex == NULL)
{
Fail("Unable to create the mutex. GetLastError returned %d\n",
GetLastError());
}
hThread = CreateThread( NULL,
0,
(LPTHREAD_START_ROUTINE)AcquiringProc,
(LPVOID) Mutex,
0,
&dwThreadId);
if (hThread == NULL)
{
Fail("ERROR: Was not able to create the thread to test!\n"
"GetLastError returned %d\n", GetLastError());
}
Sleep(ParentDelayTime);
ret = WaitForMultipleObjectsEx(1, &Mutex, FALSE, INFINITE, FALSE);
if (ret != WAIT_OBJECT_0)
{
Fail("Expected WaitForMultipleObjectsEx to return WAIT_OBJECT_0\n"
"Got %d\n", ret);
}
if (!CloseHandle(Mutex))
{
Fail("CloseHandle on the mutex failed!\n");
}
if (!CloseHandle(hThread))
{
Fail("CloseHandle on the thread failed!\n");
}
PAL_Terminate();
return PASS;
}
//----------------------------------------------------------------------------------------
amf_handle AMF_CDECL_CALL amf_create_mutex(amf_bool bInitiallyOwned, const wchar_t* pName)
{
#if defined(METRO_APP)
DWORD flags = (bInitiallyOwned) ? CREATE_MUTEX_INITIAL_OWNER : 0;
return CreateMutexEx(NULL, pName, flags, STANDARD_RIGHTS_ALL);
#else
return CreateMutexW(NULL, bInitiallyOwned == true, pName);
#endif
}
HOOKFUNC HANDLE WINAPI MyCreateMutexW(LPSECURITY_ATTRIBUTES lpMutexWttributes, BOOL bInitialOwner, LPCSTR lpName)
{
ENTER();
HANDLE rv = CreateMutexW(lpMutexWttributes, bInitialOwner, lpName);
LEAVE(rv);
EnterCriticalSection(&s_handleCS);
std::set<HANDLE>& handles = s_threadIdHandles[GetCurrentThreadId()];
handles.insert(rv);
LeaveCriticalSection(&s_handleCS);
return rv;
}
void CWE252_Unchecked_Return_Value__wchar_t_w32CreateMutex_18_bad()
{
goto sink;
sink:
{
HANDLE hMutex = NULL;
hMutex = CreateMutexW(NULL, FALSE, NULL);
/* FLAW: Do not check the return value */
/* We'll leave out most of the implementation since it has nothing to do with the CWE
* and since the checkers are looking for certain function calls anyway */
CloseHandle(hMutex);
}
}
int __cdecl main( int argc, char **argv )
{
HANDLE hMutex;
WCHAR wszMutexName[] = { 'T','E','S','T','1','1','\0' };
DWORD dwRet;
int i;
/* initialize the PAL */
if( PAL_Initialize(argc, argv) != 0 )
{
return( FAIL );
}
/* open a mutex to synchronize with the parent process */
hMutex = CreateMutexW( NULL, FALSE, wszMutexName );
if( hMutex == NULL )
{
Fail( "ERROR:%lu:CreateMutex() call failed\r\n", GetLastError() );
}
/* acquire the mutex lock */
dwRet = WaitForSingleObject( hMutex, 10000 );
if( dwRet != WAIT_OBJECT_0 )
{
Trace( "ERROR:WaitForSingleObject() returned %lu, "
"expected WAIT_OBJECT_0",
dwRet );
if( ! CloseHandle( hMutex ) )
{
Trace( "ERROR:%lu:CloseHandle() call failed\n", GetLastError() );
}
Fail( "test failed\n" );
}
/* simulate some activity */
for( i=0; i<50000; i++ )
;
/* close our mutex handle */
if( ! CloseHandle( hMutex ) )
{
Fail( "ERROR:%lu:CloseHandle() call failed\n", GetLastError() );
}
/* terminate the PAL */
PAL_Terminate();
/* return the predefined exit code */
return TEST_EXIT_CODE;
}
RWLockImpl::RWLockImpl(): _readers(0), _writersWaiting(0), _writers(0)
{
_mutex = CreateMutexW(NULL, FALSE, NULL);
if (_mutex == NULL)
throw SystemException("cannot create reader/writer lock");
_readEvent = CreateEventW(NULL, TRUE, TRUE, NULL);
if (_readEvent == NULL)
throw SystemException("cannot create reader/writer lock");
_writeEvent = CreateEventW(NULL, TRUE, TRUE, NULL);
if (_writeEvent == NULL)
throw SystemException("cannot create reader/writer lock");
}
Qt::HANDLE QtLockedFile::getMutexHandle(int idx, bool doCreate)
{
if (mutexname.isEmpty()) {
QFileInfo fi(*this);
mutexname = QString::fromLatin1(MUTEX_PREFIX)
+ fi.absoluteFilePath().toLower();
}
QString mname(mutexname);
if (idx >= 0)
mname += QString::number(idx);
Qt::HANDLE mutex;
if (doCreate) {
QT_WA( { mutex = CreateMutexW(NULL, FALSE, (TCHAR*)mname.utf16()); },
{ mutex = CreateMutexA(NULL, FALSE, mname.toLocal8Bit().constData()); } );
/*********************************************************
设定运行标志
*********************************************************/
LIBUTILS_API int UTILS_API set_runningW(const wchar_t * szProgramName)
{
HANDLE hMutex;
hMutex=CreateMutexW(0,TRUE,szProgramName);
if(!hMutex)
{
return -1;
}
if(ERROR_ALREADY_EXISTS == GetLastError())
{
CloseHandle(hMutex);
return 1;
}
return 0;
}
APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
const char *fname,
apr_lockmech_e mech,
apr_pool_t *pool)
{
HANDLE hMutex;
void *mutexkey;
if (mech != APR_LOCK_DEFAULT) {
return APR_ENOTIMPL;
}
/* res_name_from_filename turns fname into a pseduo-name
* without slashes or backslashes, and prepends the \global
* prefix on Win2K and later
*/
if (fname) {
mutexkey = res_name_from_filename(fname, 1, pool);
}
else {
mutexkey = NULL;
}
#if APR_HAS_UNICODE_FS
IF_WIN_OS_IS_UNICODE
{
hMutex = CreateMutexW(NULL, FALSE, mutexkey);
}
#endif
#if APR_HAS_ANSI_FS
ELSE_WIN_OS_IS_ANSI
{
hMutex = CreateMutexA(NULL, FALSE, mutexkey);
}
#endif
if (!hMutex) {
return apr_get_os_error();
}
*mutex = (apr_proc_mutex_t *)apr_palloc(pool, sizeof(apr_proc_mutex_t));
(*mutex)->pool = pool;
(*mutex)->handle = hMutex;
(*mutex)->fname = fname;
apr_pool_cleanup_register((*mutex)->pool, *mutex,
proc_mutex_cleanup, apr_pool_cleanup_null);
return APR_SUCCESS;
}
int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
AutoHandle mutex(CreateMutexW(0, false, L"AdblockPlusEngine"));
if (!mutex)
{
DebugLastError("CreateMutex failed");
return 1;
}
if (GetLastError() == ERROR_ALREADY_EXISTS)
{
DebugLastError("Named pipe exists, another engine instance appears to be running");
return 1;
}
int argc;
LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
std::wstring locale(argc >= 2 ? argv[1] : L"");
Communication::browserSID = argc >= 3 ? argv[2] : L"";
LocalFree(argv);
Dictionary::Create(locale);
filterEngine = CreateFilterEngine(locale);
updater.reset(new Updater(filterEngine->GetJsEngine()));
for (;;)
{
try
{
Communication::Pipe* pipe = new Communication::Pipe(Communication::pipeName,
Communication::Pipe::MODE_CREATE);
AutoHandle thread(CreateThread(0, 0, ClientThread, static_cast<LPVOID>(pipe), 0, 0));
if (!thread)
{
delete pipe;
DebugLastError("CreateThread failed");
return 1;
}
}
catch (std::runtime_error e)
{
DebugException(e);
return 1;
}
}
return 0;
}
/* good1() reverses the blocks on the goto statement */
static void good1()
{
goto sink;
sink:
{
HANDLE hMutex = NULL;
hMutex = CreateMutexW(NULL, FALSE, NULL);
/* FIX: Check the return value of CreateMutex() for NULL */
if (hMutex == NULL)
{
exit(1);
}
/* We'll leave out most of the implementation since it has nothing to do with the CWE
* and since the checkers are looking for certain function calls anyway */
CloseHandle(hMutex);
}
}
HANDLE
APIENTRY
CreateMutexA(
LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL bInitialOwner,
LPCSTR lpName
)
/*++
Routine Description:
ANSI thunk to CreateMutexW
--*/
{
PUNICODE_STRING Unicode;
ANSI_STRING AnsiString;
NTSTATUS Status;
LPCWSTR NameBuffer;
NameBuffer = NULL;
if ( ARGUMENT_PRESENT(lpName) ) {
Unicode = &NtCurrentTeb()->StaticUnicodeString;
RtlInitAnsiString(&AnsiString,lpName);
Status = RtlAnsiStringToUnicodeString(Unicode,&AnsiString,FALSE);
if ( !NT_SUCCESS(Status) ) {
if ( Status == STATUS_BUFFER_OVERFLOW ) {
SetLastError(ERROR_FILENAME_EXCED_RANGE);
}
else {
BaseSetLastNTError(Status);
}
return NULL;
}
NameBuffer = (LPCWSTR)Unicode->Buffer;
}
return CreateMutexW(
lpMutexAttributes,
bInitialOwner,
NameBuffer
);
}
