/* Initialize critical section */ void csinitialize (CRITICAL_SECTION *cs) { InitializeCriticalSection (cs); }
void qemu_mutex_init(QemuMutex *mutex) { mutex->owner = 0; InitializeCriticalSection(&mutex->lock); }
win_data::win_data() { InitializeCriticalSection(&m_cs); }
/* * Main entry point for syslogger process * argc/argv parameters are valid only in EXEC_BACKEND case. */ NON_EXEC_STATIC void SysLoggerMain(int argc, char *argv[]) { #ifndef WIN32 char logbuffer[READ_BUF_SIZE]; int bytes_in_logbuffer = 0; #endif char *currentLogDir; char *currentLogFilename; int currentLogRotationAge; IsUnderPostmaster = true; /* we are a postmaster subprocess now */ MyProcPid = getpid(); /* reset MyProcPid */ #ifdef EXEC_BACKEND syslogger_parseArgs(argc, argv); #endif /* EXEC_BACKEND */ am_syslogger = true; init_ps_display("logger process", "", "", ""); /* * If we restarted, our stderr is already redirected into our own input * pipe. This is of course pretty useless, not to mention that it * interferes with detecting pipe EOF. Point stderr to /dev/null. This * assumes that all interesting messages generated in the syslogger will * come through elog.c and will be sent to write_syslogger_file. */ if (redirection_done) { int fd = open(DEVNULL, O_WRONLY, 0); /* * The closes might look redundant, but they are not: we want to be * darn sure the pipe gets closed even if the open failed. We can * survive running with stderr pointing nowhere, but we can't afford * to have extra pipe input descriptors hanging around. */ close(fileno(stdout)); close(fileno(stderr)); if (fd != -1) { dup2(fd, fileno(stdout)); dup2(fd, fileno(stderr)); close(fd); } } /* Syslogger's own stderr can't be the syslogPipe, so set it back to * text mode if we didn't just close it. * (It was set to binary in SubPostmasterMain). */ #ifdef WIN32 else _setmode(_fileno(stderr),_O_TEXT); #endif /* * Also close our copy of the write end of the pipe. This is needed to * ensure we can detect pipe EOF correctly. (But note that in the restart * case, the postmaster already did this.) */ #ifndef WIN32 if (syslogPipe[1] >= 0) close(syslogPipe[1]); syslogPipe[1] = -1; #else if (syslogPipe[1]) CloseHandle(syslogPipe[1]); syslogPipe[1] = 0; #endif /* * If possible, make this process a group leader, so that the postmaster * can signal any child processes too. (syslogger probably never has * any child processes, but for consistency we make all postmaster * child processes do this.) */ #ifdef HAVE_SETSID if (setsid() < 0) elog(FATAL, "setsid() failed: %m"); #endif /* * Properly accept or ignore signals the postmaster might send us * * Note: we ignore all termination signals, and instead exit only when all * upstream processes are gone, to ensure we don't miss any dying gasps of * broken backends... */ pqsignal(SIGHUP, sigHupHandler); /* set flag to read config file */ pqsignal(SIGINT, SIG_IGN); pqsignal(SIGTERM, SIG_IGN); pqsignal(SIGQUIT, SIG_IGN); pqsignal(SIGALRM, SIG_IGN); pqsignal(SIGPIPE, SIG_IGN); pqsignal(SIGUSR1, sigUsr1Handler); /* request log rotation */ pqsignal(SIGUSR2, SIG_IGN); /* * Reset some signals that are accepted by postmaster but not here */ pqsignal(SIGCHLD, SIG_DFL); pqsignal(SIGTTIN, SIG_DFL); pqsignal(SIGTTOU, SIG_DFL); pqsignal(SIGCONT, SIG_DFL); pqsignal(SIGWINCH, SIG_DFL); PG_SETMASK(&UnBlockSig); #ifdef WIN32 /* Fire up separate data transfer thread */ InitializeCriticalSection(&sysloggerSection); EnterCriticalSection(&sysloggerSection); { unsigned int tid; threadHandle = (HANDLE) _beginthreadex(0, 0, pipeThread, 0, 0, &tid); } #endif /* WIN32 */ /* remember active logfile parameters */ currentLogDir = pstrdup(Log_directory); currentLogFilename = pstrdup(Log_filename); currentLogRotationAge = Log_RotationAge; /* set next planned rotation time */ set_next_rotation_time(); /* main worker loop */ for (;;) { bool time_based_rotation = false; #ifndef WIN32 int bytesRead; int rc; fd_set rfds; struct timeval timeout; #endif if (got_SIGHUP) { got_SIGHUP = false; ProcessConfigFile(PGC_SIGHUP); /* * Check if the log directory or filename pattern changed in * postgresql.conf. If so, force rotation to make sure we're * writing the logfiles in the right place. */ if (strcmp(Log_directory, currentLogDir) != 0) { pfree(currentLogDir); currentLogDir = pstrdup(Log_directory); rotation_requested = true; } if (strcmp(Log_filename, currentLogFilename) != 0) { pfree(currentLogFilename); currentLogFilename = pstrdup(Log_filename); rotation_requested = true; } /* * If rotation time parameter changed, reset next rotation time, * but don't immediately force a rotation. */ if (currentLogRotationAge != Log_RotationAge) { currentLogRotationAge = Log_RotationAge; set_next_rotation_time(); } } if (!rotation_requested && Log_RotationAge > 0) { /* Do a logfile rotation if it's time */ pg_time_t now = time(NULL); if (now >= next_rotation_time) rotation_requested = time_based_rotation = true; } if (!rotation_requested && Log_RotationSize > 0) { /* Do a rotation if file is too big */ if (ftell(syslogFile) >= Log_RotationSize * 1024L) rotation_requested = true; } if (rotation_requested) logfile_rotate(time_based_rotation); #ifndef WIN32 /* * Wait for some data, timing out after 1 second */ FD_ZERO(&rfds); FD_SET(syslogPipe[0], &rfds); timeout.tv_sec = 1; timeout.tv_usec = 0; rc = select(syslogPipe[0] + 1, &rfds, NULL, NULL, &timeout); if (rc < 0) { if (errno != EINTR) ereport(LOG, (errcode_for_socket_access(), errmsg("select() failed in logger process: %m"))); } else if (rc > 0 && FD_ISSET(syslogPipe[0], &rfds)) { bytesRead = piperead(syslogPipe[0], logbuffer + bytes_in_logbuffer, sizeof(logbuffer) - bytes_in_logbuffer); if (bytesRead < 0) { if (errno != EINTR) ereport(LOG, (errcode_for_socket_access(), errmsg("could not read from logger pipe: %m"))); } else if (bytesRead > 0) { bytes_in_logbuffer += bytesRead; process_pipe_input(logbuffer, &bytes_in_logbuffer); continue; } else { /* * Zero bytes read when select() is saying read-ready means * EOF on the pipe: that is, there are no longer any processes * with the pipe write end open. Therefore, the postmaster * and all backends are shut down, and we are done. */ pipe_eof_seen = true; /* if there's any data left then force it out now */ flush_pipe_input(logbuffer, &bytes_in_logbuffer); } } #else /* WIN32 */ /* * On Windows we leave it to a separate thread to transfer data and * detect pipe EOF. The main thread just wakes up once a second to * check for SIGHUP and rotation conditions. * * Server code isn't generally thread-safe, so we ensure that only * one of the threads is active at a time by entering the critical * section whenever we're not sleeping. */ LeaveCriticalSection(&sysloggerSection); pg_usleep(1000000L); EnterCriticalSection(&sysloggerSection); #endif /* WIN32 */ if (pipe_eof_seen) { ereport(LOG, (errmsg("logger shutting down"))); /* * Normal exit from the syslogger is here. Note that we * deliberately do not close syslogFile before exiting; this is to * allow for the possibility of elog messages being generated * inside proc_exit. Regular exit() will take care of flushing * and closing stdio channels. */ proc_exit(0); } } }
ChmThumbnailTask(ChmDoc *doc, HWND hwnd, SizeI size, const std::function<void(RenderedBitmap*)> saveThumbnail) : doc(doc), hwnd(hwnd), hw(nullptr), size(size), saveThumbnail(saveThumbnail) { InitializeCriticalSection(&docAccess); }
int main (int argc, char *argv[]) { int i = 0; CRITICAL_SECTION cs; old_mutex_t ox; pthread_mutexattr_init(&ma); printf( "=============================================================================\n"); printf( "\nLock plus unlock on an unlocked mutex.\n%ld iterations\n\n", ITERATIONS); printf( "%-45s %15s %15s\n", "Test", "Total(msec)", "average(usec)"); printf( "-----------------------------------------------------------------------------\n"); /* * Time the loop overhead so we can subtract it from the actual test times. */ TESTSTART assert(1 == one); assert(1 == one); TESTSTOP durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; overHeadMilliSecs = durationMilliSecs; TESTSTART assert((dummy_call(&i), 1) == one); assert((dummy_call(&i), 1) == one); TESTSTOP durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Dummy call x 2", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS); TESTSTART assert((interlocked_inc_with_conditionals(&i), 1) == one); assert((interlocked_dec_with_conditionals(&i), 1) == one); TESTSTOP durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Dummy call -> Interlocked with cond x 2", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS); TESTSTART assert((InterlockedIncrement((LPLONG)&i), 1) == (LONG)one); assert((InterlockedDecrement((LPLONG)&i), 1) == (LONG)one); TESTSTOP durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "InterlockedOp x 2", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS); InitializeCriticalSection(&cs); TESTSTART assert((EnterCriticalSection(&cs), 1) == one); assert((LeaveCriticalSection(&cs), 1) == one); TESTSTOP DeleteCriticalSection(&cs); durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Simple Critical Section", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS); old_mutex_use = OLD_WIN32CS; assert(old_mutex_init(&ox, NULL) == 0); TESTSTART assert(old_mutex_lock(&ox) == zero); assert(old_mutex_unlock(&ox) == zero); TESTSTOP assert(old_mutex_destroy(&ox) == 0); durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Old PT Mutex using a Critical Section (WNT)", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS); old_mutex_use = OLD_WIN32MUTEX; assert(old_mutex_init(&ox, NULL) == 0); TESTSTART assert(old_mutex_lock(&ox) == zero); assert(old_mutex_unlock(&ox) == zero); TESTSTOP assert(old_mutex_destroy(&ox) == 0); durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; printf( "%-45s %15ld %15.3f\n", "Old PT Mutex using a Win32 Mutex (W9x)", durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS); printf( ".............................................................................\n"); /* * Now we can start the actual tests */ #ifdef PTW32_MUTEX_TYPES runTest("PTHREAD_MUTEX_DEFAULT (W9x,WNT)", PTHREAD_MUTEX_DEFAULT); runTest("PTHREAD_MUTEX_NORMAL (W9x,WNT)", PTHREAD_MUTEX_NORMAL); runTest("PTHREAD_MUTEX_ERRORCHECK (W9x,WNT)", PTHREAD_MUTEX_ERRORCHECK); runTest("PTHREAD_MUTEX_RECURSIVE (W9x,WNT)", PTHREAD_MUTEX_RECURSIVE); #else runTest("Non-blocking lock", 0); #endif printf( "=============================================================================\n"); /* * End of tests. */ pthread_mutexattr_destroy(&ma); one = i; /* Dummy assignment to avoid 'variable unused' warning */ return 0; }
int CESDDevice::init(const char* acInitString) { InitializeCriticalSection(&m_csDevice); int i, iRetVal = 0; int txTimeOut = 0; char* pcToken; char acString[128]; if(m_bInitFlag) { warning("device already initialized"); m_iErrorState = ERRID_DEV_ISINITIALIZED; return m_iErrorState; } m_iDeviceId = -1; m_iErrorState = 0; strncpy(m_acInitString,acInitString,128); strncpy(acString,acInitString,128); pcToken = strtok( acString, ":" ); if( !pcToken ) { m_iErrorState = ERRID_DEV_BADINITSTRING; return m_iErrorState; } if( strcmp( pcToken, "ESD" ) != 0 ) { m_iErrorState = ERRID_DEV_BADINITSTRING; return m_iErrorState; } pcToken = strtok( NULL, "," ); if( !pcToken ) { m_iErrorState = ERRID_DEV_BADINITSTRING; return m_iErrorState; } m_iDeviceId = atoi(pcToken); pcToken = strtok( NULL, "," ); if( !pcToken ) { m_iErrorState = ERRID_DEV_BADINITSTRING; return m_iErrorState; } m_iBaudRate = atoi(pcToken); #if defined(__LINUX__) m_uiTimeOut = 6; #endif #if defined (_WIN32) switch( m_iBaudRate ) { case 125: case 250: m_uiTimeOut = 4; break; case 500: m_uiTimeOut = 3; break; case 1000: m_uiTimeOut = 2; break; default: m_uiTimeOut = 10; break; } #endif try { iRetVal = canOpen( m_iDeviceId, // Net 0, // Mode m_uiQueueSize, // TX Queue m_uiQueueSize, // RX Queue m_uiTimeOut, // Tx Timeout m_uiTimeOut, // Rx Timeout &m_hDevice); if(iRetVal != NTCAN_SUCCESS) { warning("can open failed Errorcode: %d", iRetVal); getDeviceError(iRetVal); m_iErrorState = ERRID_DEV_INITERROR; return m_iErrorState; } iRetVal = canOpen( m_iDeviceId, // Net 0, // Mode 1, // TX Queue 1, // RX Queue 600, // Tx Timeout 100, // Rx Timeout &m_hSyncDevice); if(iRetVal != NTCAN_SUCCESS) { warning("can open failed Errorcode: %d", iRetVal); getDeviceError(iRetVal); m_iErrorState = ERRID_DEV_INITERROR; return m_iErrorState; } } catch(...) { warning("init ESD device failed no library found"); m_iErrorState = ERRID_DEV_NOLIBRARY; return m_iErrorState; } for(i = 0; i <= m_iModuleCountMax; i++) { iRetVal = canIdAdd(m_hDevice, (MSGID_ACK + i)); if(iRetVal != NTCAN_SUCCESS) { warning("can add ID failed Errorcode: %d", iRetVal); getDeviceError(iRetVal); m_iErrorState = ERRID_DEV_INITERROR; return m_iErrorState; } iRetVal = canIdAdd(m_hDevice, (MSGID_STATE + i)); if(iRetVal != NTCAN_SUCCESS) { warning("can add ID failed Errorcode: %d", iRetVal); getDeviceError(iRetVal); m_iErrorState = ERRID_DEV_INITERROR; return m_iErrorState; } } for(i = 0; i <= MAX_MP55; i++ ) { iRetVal = canIdAdd(m_hDevice, (MSGID_MP55_RECV + i)); if(iRetVal != NTCAN_SUCCESS) { warning("can add ID failed Errorcode: %d", iRetVal); getDeviceError(iRetVal); m_iErrorState = ERRID_DEV_INITERROR; return m_iErrorState; } iRetVal = canIdAdd(m_hDevice, (0x180 + i)); if(iRetVal != NTCAN_SUCCESS) { warning("can add ID failed Errorcode: %d", iRetVal); getDeviceError(iRetVal); m_iErrorState = ERRID_DEV_INITERROR; return m_iErrorState; } iRetVal = canIdAdd(m_hDevice, (0x600 + i)); if(iRetVal != NTCAN_SUCCESS) { warning("can add ID failed Errorcode: %d", iRetVal); getDeviceError(iRetVal); m_iErrorState = ERRID_DEV_INITERROR; return m_iErrorState; } } for(i = 0; i < MAX_SCHUNK; i++ ) { iRetVal = canIdAdd(m_hDevice, (MSGID_SCHUNK_RECV + i)); if(iRetVal != NTCAN_SUCCESS) { warning("can add ID failed Errorcode: %d", iRetVal); getDeviceError(iRetVal); m_iErrorState = ERRID_DEV_INITERROR; return m_iErrorState; } } iRetVal = canIdAdd(m_hSyncDevice, MSGID_ALL); if(iRetVal != NTCAN_SUCCESS) { warning("can add ID failed Errorcode: %d", iRetVal); getDeviceError(iRetVal); m_iErrorState = ERRID_DEV_INITERROR; return m_iErrorState; } m_iErrorState = setBaudRate(); if(m_iErrorState != 0) return m_iErrorState; m_iErrorState = clearReadQueue(); if(m_iErrorState != 0) return m_iErrorState; if(m_iErrorState == 0) m_bInitFlag = true; updateModuleIdMap(); return m_iErrorState; }
//----------------------------------------------------------------------------------------- // This function does the following steps: // // 1. Initialize XACT by calling pEngine->Initialize // 2. Register for the XACT notification desired // 3. Create the in memory XACT wave bank(s) you want to use // 4. Create the streaming XACT wave bank(s) you want to use // 5. Create the XACT sound bank(s) you want to use // 6. Store indices to the XACT cue(s) your game uses //----------------------------------------------------------------------------------------- HRESULT PrepareXACT() { HRESULT hr; WCHAR str[MAX_PATH]; HANDLE hFile; DWORD dwFileSize; DWORD dwBytesRead; HANDLE hMapFile; // Clear struct ZeroMemory( &g_audioState, sizeof( AUDIO_STATE ) ); InitializeCriticalSection( &g_audioState.cs ); hr = CoInitializeEx( NULL, COINIT_MULTITHREADED ); // COINIT_APARTMENTTHREADED will work too if( SUCCEEDED( hr ) ) { // Switch to auditioning mode based on command line. Change if desired bool bAuditionMode = DoesCommandLineContainAuditionSwitch(); bool bDebugMode = false; DWORD dwCreationFlags = 0; if( bAuditionMode ) dwCreationFlags |= XACT_FLAG_API_AUDITION_MODE; if( bDebugMode ) dwCreationFlags |= XACT_FLAG_API_DEBUG_MODE; hr = XACT3CreateEngine( dwCreationFlags, &g_audioState.pEngine ); } if( FAILED( hr ) || g_audioState.pEngine == NULL ) return E_FAIL; // Initialize & create the XACT runtime XACT_RUNTIME_PARAMETERS xrParams = {0}; xrParams.lookAheadTime = XACT_ENGINE_LOOKAHEAD_DEFAULT; xrParams.fnNotificationCallback = XACTNotificationCallback; hr = g_audioState.pEngine->Initialize( &xrParams ); if( FAILED( hr ) ) return hr; //----------------------------------------------------------------------------------------- // Register for XACT notifications //----------------------------------------------------------------------------------------- // The "wave bank prepared" notification will let the app know when it is save to use // play cues that reference streaming wave data. XACT_NOTIFICATION_DESCRIPTION desc = {0}; desc.flags = XACT_FLAG_NOTIFICATION_PERSIST; desc.type = XACTNOTIFICATIONTYPE_WAVEBANKPREPARED; g_audioState.pEngine->RegisterNotification( &desc ); // The "sound bank destroyed" notification will let the app know when it is save to use // play cues that reference streaming wave data. desc.flags = XACT_FLAG_NOTIFICATION_PERSIST; desc.type = XACTNOTIFICATIONTYPE_SOUNDBANKDESTROYED; g_audioState.pEngine->RegisterNotification( &desc ); // The "cue stop" notification will let the app know when it a song stops so a new one // can be played desc.flags = XACT_FLAG_NOTIFICATION_PERSIST; desc.type = XACTNOTIFICATIONTYPE_CUESTOP; desc.cueIndex = XACTINDEX_INVALID; g_audioState.pEngine->RegisterNotification( &desc ); // The "cue prepared" notification will let the app know when it a a cue that uses // streaming data has been prepared so it is ready to be used for zero latency streaming desc.flags = XACT_FLAG_NOTIFICATION_PERSIST; desc.type = XACTNOTIFICATIONTYPE_CUEPREPARED; desc.cueIndex = XACTINDEX_INVALID; g_audioState.pEngine->RegisterNotification( &desc ); if( FAILED( hr = FindMediaFileCch( str, MAX_PATH, L"InMemoryWaveBank.xwb" ) ) ) return hr; // Create an "in memory" XACT wave bank file using memory mapped file IO hr = E_FAIL; // assume failure hFile = CreateFile( str, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL ); if( hFile != INVALID_HANDLE_VALUE ) { dwFileSize = GetFileSize( hFile, NULL ); if( dwFileSize != -1 ) { hMapFile = CreateFileMapping( hFile, NULL, PAGE_READONLY, 0, dwFileSize, NULL ); if( hMapFile ) { g_audioState.pbInMemoryWaveBank = MapViewOfFile( hMapFile, FILE_MAP_READ, 0, 0, 0 ); if( g_audioState.pbInMemoryWaveBank ) { hr = g_audioState.pEngine->CreateInMemoryWaveBank( g_audioState.pbInMemoryWaveBank, dwFileSize, 0, 0, &g_audioState.pInMemoryWaveBank ); } CloseHandle( hMapFile ); // pbInMemoryWaveBank maintains a handle on the file so close this unneeded handle } } CloseHandle( hFile ); // pbInMemoryWaveBank maintains a handle on the file so close this unneeded handle } if( FAILED( hr ) ) return E_FAIL; // CleanupXACT() will cleanup state before exiting //----------------------------------------------------------------------------------------- // Create a streaming XACT wave bank file. // Take note of the following: // 1) This wave bank in the XACT project file must marked as a streaming wave bank // This is set inside the XACT authoring tool) // 2) Use FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING flags when opening the file // 3) To use cues that reference this streaming wave bank, you must wait for the // wave bank to prepared first or the playing the cue will fail //----------------------------------------------------------------------------------------- if( FAILED( hr = FindMediaFileCch( str, MAX_PATH, L"StreamingWaveBank.xwb" ) ) ) return hr; hr = E_FAIL; // assume failure g_audioState.hStreamingWaveBankFile = CreateFile( str, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING, NULL ); if( g_audioState.hStreamingWaveBankFile != INVALID_HANDLE_VALUE ) { XACT_WAVEBANK_STREAMING_PARAMETERS wsParams; ZeroMemory( &wsParams, sizeof( XACT_WAVEBANK_STREAMING_PARAMETERS ) ); wsParams.file = g_audioState.hStreamingWaveBankFile; wsParams.offset = 0; // 64 means to allocate a 64 * 2k buffer for streaming. // This is a good size for DVD streaming and takes good advantage of the read ahead cache wsParams.packetSize = 64; hr = g_audioState.pEngine->CreateStreamingWaveBank( &wsParams, &g_audioState.pStreamingWaveBank ); } if( FAILED( hr ) ) return E_FAIL; // CleanupXACT() will cleanup state before exiting // Create the XACT sound bank file with using memory mapped file IO if( FAILED( hr = FindMediaFileCch( str, MAX_PATH, L"sounds.xsb" ) ) ) return hr; hr = E_FAIL; // assume failure hFile = CreateFile( str, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL ); if( hFile != INVALID_HANDLE_VALUE ) { dwFileSize = GetFileSize( hFile, NULL ); if( dwFileSize != -1 ) { // Allocate the data here and free the data when recieving the sound bank destroyed notification g_audioState.pbSoundBank = new BYTE[dwFileSize]; if( g_audioState.pbSoundBank ) { if( 0 != ReadFile( hFile, g_audioState.pbSoundBank, dwFileSize, &dwBytesRead, NULL ) ) { hr = g_audioState.pEngine->CreateSoundBank( g_audioState.pbSoundBank, dwFileSize, 0, 0, &g_audioState.pSoundBank ); } } } CloseHandle( hFile ); // pbInMemoryWaveBank maintains a handle on the file so close this unneeded handle } if( FAILED( hr ) ) return E_FAIL; // CleanupXACT() will cleanup state before exiting // Get the cue indices from the sound bank g_audioState.iZap = g_audioState.pSoundBank->GetCueIndex( "zap" ); g_audioState.iRev = g_audioState.pSoundBank->GetCueIndex( "rev" ); for( int i = 0; i < 3; i++ ) { CHAR sz[256]; StringCchPrintfA( sz, 256, "song%d", i + 1 ); g_audioState.iSong[i] = g_audioState.pSoundBank->GetCueIndex( sz ); } return S_OK; }
DWORD InitSerivce() { DWORD ret; DWORD i; char ip[20] = {0}; int port; WSADATA wsaData; SOCKADDR_IN inAddr; char configFile[MAX_PATH] = {0}; char *q; FILE *f; GetModuleFileName(NULL, configFile, sizeof(configFile)); q = strrchr(configFile, '\\'); if(q == NULL) { return 10; } q++; *q = '\0'; strcat(configFile, CONFIG_FILE); ret = GetPrivateProfileString("music", "dir", "", dir, sizeof(dir), configFile); if (ret == 0) { return 1; } ret = GetPrivateProfileString("network", "ip", "", ip, sizeof(ip), configFile); if (ret == 0) { return 1; } port = GetPrivateProfileInt("network", "port", 0, configFile); if(port == 0) { return 1; } _snprintf(glob_file, sizeof(glob_file), "%s\\*.mp3", dir); ret = mpg123_init(); if(ret != MPG123_OK) { return 2; } mh = mpg123_new(NULL, &ret); if(mh == NULL) { return 3; } for(i = 0; i < HEAD_NUM; i++) { p[i] = (LPSTR)malloc(SOUND_BUFFER_LEN); pHeader[i] = (LPWAVEHDR)malloc(sizeof(WAVEHDR)); if(p[i] == NULL || pHeader[i] == NULL) { return 4; } } ret = WSAStartup(0x0202, &wsaData); if(ret != 0) { return 5; } sock = socket(AF_INET, SOCK_STREAM, 0); if(sock == INVALID_SOCKET) { return 6; } inAddr.sin_family = AF_INET; inAddr.sin_addr.s_addr = inet_addr(ip); inAddr.sin_port = htons(port); ret = bind(sock, (const struct sockaddr *)&inAddr, sizeof(inAddr)); if(ret == SOCKET_ERROR) { return 7; } ret = listen(sock, 1); if(ret == SOCKET_ERROR) { return 8; } if(!PathFileExists(dir)) { return 9; } InitializeCriticalSection(&cs); return 0; }
SpewRetval_t CmdLib_SpewOutputFunc( SpewType_t type, char const *pMsg ) { // Hopefully two threads won't call this simultaneously right at the start! if ( !g_bSpewCSInitted ) { InitializeCriticalSection( &g_SpewCS ); g_bSpewCSInitted = true; } WORD old; SpewRetval_t retVal; EnterCriticalSection( &g_SpewCS ); { if (( type == SPEW_MESSAGE ) || (type == SPEW_LOG )) { Color c = GetSpewOutputColor(); if ( c.r() != 255 || c.g() != 255 || c.b() != 255 ) { // custom color old = SetConsoleTextColor( c.r(), c.g(), c.b(), c.a() ); } else { old = SetConsoleTextColor( 1, 1, 1, 0 ); } retVal = SPEW_CONTINUE; } else if( type == SPEW_WARNING ) { old = SetConsoleTextColor( 1, 1, 0, 1 ); retVal = SPEW_CONTINUE; } else if( type == SPEW_ASSERT ) { old = SetConsoleTextColor( 1, 0, 0, 1 ); retVal = SPEW_DEBUGGER; #ifdef MPI // VMPI workers don't want to bring up dialogs and suchlike. // They need to have a special function installed to handle // the exceptions and write the minidumps. // Install the function after VMPI_Init with a call: // SetupToolsMinidumpHandler( VMPI_ExceptionFilter ); if ( g_bUseMPI && !g_bMPIMaster && !Plat_IsInDebugSession() ) { // Generating an exception and letting the // installed handler handle it ::RaiseException ( 0, // dwExceptionCode EXCEPTION_NONCONTINUABLE, // dwExceptionFlags 0, // nNumberOfArguments, NULL // const ULONG_PTR* lpArguments ); // Never get here (non-continuable exception) VMPI_HandleCrash( pMsg, NULL, true ); exit( 0 ); } #endif } else if( type == SPEW_ERROR ) { old = SetConsoleTextColor( 1, 0, 0, 1 ); retVal = SPEW_ABORT; // doesn't matter.. we exit below so we can return an errorlevel (which dbg.dll doesn't do). } else { old = SetConsoleTextColor( 1, 1, 1, 1 ); retVal = SPEW_CONTINUE; } if ( !g_bSuppressPrintfOutput || type == SPEW_ERROR ) printf( "%s", pMsg ); OutputDebugString( pMsg ); if ( type == SPEW_ERROR ) { printf( "\n" ); OutputDebugString( "\n" ); } if( g_pLogFile ) { CmdLib_FPrintf( g_pLogFile, "%s", pMsg ); g_pFileSystem->Flush( g_pLogFile ); } // Dispatch to other spew hooks. FOR_EACH_LL( g_ExtraSpewHooks, i ) g_ExtraSpewHooks[i]( pMsg ); RestoreConsoleTextColor( old ); } LeaveCriticalSection( &g_SpewCS ); if ( type == SPEW_ERROR ) { CmdLib_Exit( 1 ); } return retVal; }
BOOL netconn_init( netconn_t *conn, BOOL secure ) { #if defined(SONAME_LIBSSL) && defined(SONAME_LIBCRYPTO) int i; #endif conn->socket = -1; if (!secure) return TRUE; #if defined(SONAME_LIBSSL) && defined(SONAME_LIBCRYPTO) EnterCriticalSection( &init_ssl_cs ); if (libssl_handle) { LeaveCriticalSection( &init_ssl_cs ); return TRUE; } if (!(libssl_handle = wine_dlopen( SONAME_LIBSSL, RTLD_NOW, NULL, 0 ))) { ERR("Trying to use SSL but couldn't load %s. Expect trouble.\n", SONAME_LIBSSL); set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); LeaveCriticalSection( &init_ssl_cs ); return FALSE; } if (!(libcrypto_handle = wine_dlopen( SONAME_LIBCRYPTO, RTLD_NOW, NULL, 0 ))) { ERR("Trying to use SSL but couldn't load %s. Expect trouble.\n", SONAME_LIBCRYPTO); set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); LeaveCriticalSection( &init_ssl_cs ); return FALSE; } #define LOAD_FUNCPTR(x) \ if (!(p##x = wine_dlsym( libssl_handle, #x, NULL, 0 ))) \ { \ ERR("Failed to load symbol %s\n", #x); \ set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); \ LeaveCriticalSection( &init_ssl_cs ); \ return FALSE; \ } LOAD_FUNCPTR( SSL_library_init ); LOAD_FUNCPTR( SSL_load_error_strings ); LOAD_FUNCPTR( SSLv23_method ); LOAD_FUNCPTR( SSL_CTX_free ); LOAD_FUNCPTR( SSL_CTX_new ); LOAD_FUNCPTR( SSL_new ); LOAD_FUNCPTR( SSL_free ); LOAD_FUNCPTR( SSL_set_fd ); LOAD_FUNCPTR( SSL_connect ); LOAD_FUNCPTR( SSL_shutdown ); LOAD_FUNCPTR( SSL_write ); LOAD_FUNCPTR( SSL_read ); LOAD_FUNCPTR( SSL_get_error ); LOAD_FUNCPTR( SSL_get_ex_new_index ); LOAD_FUNCPTR( SSL_get_ex_data ); LOAD_FUNCPTR( SSL_set_ex_data ); LOAD_FUNCPTR( SSL_get_ex_data_X509_STORE_CTX_idx ); LOAD_FUNCPTR( SSL_get_verify_result ); LOAD_FUNCPTR( SSL_get_peer_certificate ); LOAD_FUNCPTR( SSL_CTX_set_default_verify_paths ); LOAD_FUNCPTR( SSL_CTX_set_verify ); #undef LOAD_FUNCPTR #define LOAD_FUNCPTR(x) \ if (!(p##x = wine_dlsym( libcrypto_handle, #x, NULL, 0 ))) \ { \ ERR("Failed to load symbol %s\n", #x); \ set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); \ LeaveCriticalSection( &init_ssl_cs ); \ return FALSE; \ } LOAD_FUNCPTR( CRYPTO_num_locks ); LOAD_FUNCPTR( CRYPTO_set_id_callback ); LOAD_FUNCPTR( CRYPTO_set_locking_callback ); LOAD_FUNCPTR( ERR_free_strings ); LOAD_FUNCPTR( ERR_get_error ); LOAD_FUNCPTR( ERR_error_string ); LOAD_FUNCPTR( X509_STORE_CTX_get_ex_data ); LOAD_FUNCPTR( i2d_X509 ); LOAD_FUNCPTR( sk_value ); LOAD_FUNCPTR( sk_num ); #undef LOAD_FUNCPTR pSSL_library_init(); pSSL_load_error_strings(); method = pSSLv23_method(); ctx = pSSL_CTX_new( method ); if (!pSSL_CTX_set_default_verify_paths( ctx )) { ERR("SSL_CTX_set_default_verify_paths failed: %s\n", pERR_error_string( pERR_get_error(), 0 )); set_last_error( ERROR_OUTOFMEMORY ); LeaveCriticalSection( &init_ssl_cs ); return FALSE; } hostname_idx = pSSL_get_ex_new_index( 0, (void *)"hostname index", NULL, NULL, NULL ); if (hostname_idx == -1) { ERR("SSL_get_ex_new_index failed: %s\n", pERR_error_string( pERR_get_error(), 0 )); set_last_error( ERROR_OUTOFMEMORY ); LeaveCriticalSection( &init_ssl_cs ); return FALSE; } error_idx = pSSL_get_ex_new_index( 0, (void *)"error index", NULL, NULL, NULL ); if (error_idx == -1) { ERR("SSL_get_ex_new_index failed: %s\n", pERR_error_string( pERR_get_error(), 0 )); set_last_error( ERROR_OUTOFMEMORY ); LeaveCriticalSection( &init_ssl_cs ); return FALSE; } conn_idx = pSSL_get_ex_new_index( 0, (void *)"netconn index", NULL, NULL, NULL ); if (conn_idx == -1) { ERR("SSL_get_ex_new_index failed: %s\n", pERR_error_string( pERR_get_error(), 0 )); set_last_error( ERROR_OUTOFMEMORY ); LeaveCriticalSection( &init_ssl_cs ); return FALSE; } pSSL_CTX_set_verify( ctx, SSL_VERIFY_PEER, netconn_secure_verify ); pCRYPTO_set_id_callback(ssl_thread_id); num_ssl_locks = pCRYPTO_num_locks(); ssl_locks = HeapAlloc(GetProcessHeap(), 0, num_ssl_locks * sizeof(CRITICAL_SECTION)); if (!ssl_locks) { set_last_error( ERROR_OUTOFMEMORY ); LeaveCriticalSection( &init_ssl_cs ); return FALSE; } for (i = 0; i < num_ssl_locks; i++) InitializeCriticalSection( &ssl_locks[i] ); pCRYPTO_set_locking_callback(ssl_lock_callback); LeaveCriticalSection( &init_ssl_cs ); #else WARN("SSL support not compiled in.\n"); set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); return FALSE; #endif return TRUE; }
/* Windows Critical Section Implementation */ Mutex::Mutex() { InitializeCriticalSection(&cs); }
inline CriticalSection() { InitializeCriticalSection(this); }
static HRESULT JpfsvsCreateContext( __in DWORD ProcessId, __in_opt PCWSTR UserSearchPath, __out PJPFSV_CONTEXT *Context ) { BOOL AutoLoadModules; HRESULT Hr = E_UNEXPECTED; HANDLE ProcessHandle = NULL; BOOL SymInitialized = FALSE; PJPFSV_CONTEXT TempContext; BOOL TraceTabInitialized = FALSE; if ( ! ProcessId || ! Context ) { return E_INVALIDARG; } if ( ProcessId == JPFSV_KERNEL ) { // // Use a pseudo-handle. // ProcessHandle = JPFSV_KERNEL_PSEUDO_HANDLE; AutoLoadModules = FALSE; } else { // // Use the process handle for dbghelp, that makes life easier. // // N.B. Handle is closed in JpfsvsDeleteContext. // ProcessHandle = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, ProcessId ); if ( ! ProcessHandle ) { DWORD Err = GetLastError(); return HRESULT_FROM_WIN32( Err ); } AutoLoadModules = TRUE; } // // Create and initialize object. // TempContext = ( PJPFSV_CONTEXT ) malloc( sizeof( JPFSV_CONTEXT ) ); if ( ! TempContext ) { Hr = E_OUTOFMEMORY; goto Cleanup; } TempContext->Signature = JPFSV_CONTEXT_SIGNATURE; TempContext->u.ProcessId = ProcessId; TempContext->ProcessHandle = ProcessHandle; TempContext->ReferenceCount = 0; InitializeCriticalSection( &TempContext->ProtectedMembers.Lock ); TempContext->ProtectedMembers.TraceSession = NULL; TempContext->ProtectedMembers.TraceStarted = FALSE; TempContext->ProtectedMembers.EventProcessor = FALSE; Hr = JpfsvpInitializeTracepointTable( &TempContext->ProtectedMembers.Tracepoints ); if ( SUCCEEDED( Hr ) ) { TraceTabInitialized = TRUE; } else { goto Cleanup; } // // Load dbghelp stuff. // EnterCriticalSection( &JpfsvpDbghelpLock ); if ( ! SymInitialize( ProcessHandle, UserSearchPath, AutoLoadModules ) ) { DWORD Err = GetLastError(); if ( ERROR_INVALID_DATA == ( Err & 0xFFFF ) ) { // // Most likely a 32bit vs. 64 bit mismatch. // Hr = JPFSV_E_ARCH_MISMATCH; } else { Hr = HRESULT_FROM_WIN32( Err ); } } else { DWORD AdditionalOptions = SYMOPT_DEFERRED_LOADS | SYMOPT_CASE_INSENSITIVE | SYMOPT_UNDNAME; #if DBG AdditionalOptions |= SYMOPT_DEBUG; #endif SymSetOptions( SymGetOptions() | AdditionalOptions ); SymInitialized = TRUE; Hr = S_OK; } if ( SUCCEEDED( Hr ) && ! AutoLoadModules ) { // // Manually load kernel modules/symbols. // BOOL Wow64; if ( IsWow64Process( GetCurrentProcess(), &Wow64 ) && Wow64 ) { // // Futile on WOW64. // Hr = JPFSV_E_UNSUP_ON_WOW64; } else { Hr = JpfsvsLoadKernelModules( TempContext ); } } LeaveCriticalSection( &JpfsvpDbghelpLock ); Cleanup: if ( SUCCEEDED( Hr ) ) { *Context = TempContext; } else { if ( ProcessHandle ) { if ( SymInitialized ) { SymCleanup( ProcessHandle ); } if ( ProcessHandle != JPFSV_KERNEL_PSEUDO_HANDLE ) { CloseHandle( ProcessHandle ); } } if ( TempContext ) { if ( TraceTabInitialized ) { VERIFY( S_OK == JpfsvpDeleteTracepointTable( &TempContext->ProtectedMembers.Tracepoints ) ); } DeleteCriticalSection( &TempContext->ProtectedMembers.Lock ); free( TempContext ); } } return Hr; }
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { HANDLE hPipe; #ifdef _DEBUG RECT r; HDC hDC; #endif switch(message) { case WM_CREATE: #ifdef _DEBUG GetClientRect(hWnd, &r); hwndEdit = CreateWindowW(L"EDIT", L"", WS_CHILD | WS_VISIBLE | WS_VSCROLL | ES_LEFT | ES_MULTILINE | ES_READONLY, 0, 0, r.right, r.bottom, hWnd, NULL, hInst, NULL); hDC = GetDC(hwndEdit); hFont = CreateFontW(-MulDiv(10, GetDeviceCaps(hDC, LOGPIXELSY), 72), 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, SHIFTJIS_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, PROOF_QUALITY, DEFAULT_PITCH, L"Meiryo"); SendMessageW(hwndEdit, WM_SETFONT, (WPARAM)hFont, 0); ReleaseDC(hwndEdit, hDC); #endif InitializeCriticalSection(&csUserDataSave); bUserDicChg = FALSE; LoadSKKUserDic(); bSrvThreadExit = FALSE; hThreadSrv = SrvStart(); if(hThreadSrv == NULL) { DestroyWindow(hWnd); } break; #ifdef _DEBUG case WM_SIZE: GetClientRect(hWnd, &r); MoveWindow(hwndEdit, 0, 0, r.right, r.bottom, TRUE); break; #endif case WM_POWERBROADCAST: if(wParam == PBT_APMSUSPEND) { StartSaveSKKUserDic(FALSE); BackUpSKKUserDic(); } break; case WM_DESTROY: case WM_ENDSESSION: #ifdef _DEBUG DeleteObject(hFont); #endif bSrvThreadExit = TRUE; hPipe = CreateFileW(mgrpipename, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, SECURITY_SQOS_PRESENT | SECURITY_EFFECTIVE_ONLY | SECURITY_IDENTIFICATION, NULL); if(hPipe != INVALID_HANDLE_VALUE) { CloseHandle(hPipe); WaitForSingleObject(hThreadSrv, INFINITE); } CloseHandle(hThreadSrv); StartSaveSKKUserDic(FALSE); if(message == WM_ENDSESSION) { BackUpSKKUserDic(); } DeleteCriticalSection(&csUserDataSave); ReleaseMutex(hMutex); CloseHandle(hMutex); PostQuitMessage(0); break; default: return DefWindowProcW(hWnd, message, wParam, lParam); break; } return 0; }
ThreadSafeOutput::ThreadSafeOutput() { //set up critical section for below InitializeCriticalSection(&ourCritSection); }
BOOL CPwSafeApp::InitInstance() { #if (_MFC_VER < 0x0500) #ifdef _AFXDLL Enable3dControls(); #else Enable3dControlsStatic(); #endif #endif AU_EnsureInitialized(); if(ProcessControlCommands() == TRUE) { this->_App_CleanUp(); return FALSE; } // Create application's mutex object to make our presence public m_pAppMutex = new CMutex(FALSE, MTXNAME_LOCAL, NULL); ASSERT(m_pAppMutex != NULL); m_hGlobalMutex = CPwSafeApp::CreateGlobalMutex(); ASSERT(m_hGlobalMutex != NULL); VERIFY(AfxOleInit()); AfxEnableControlContainer(); #ifndef _UNICODE AfxInitRichEdit(); #else AfxInitRichEditEx(); #endif InitCommonControls(); // SetDialogBkColor(NewGUI_GetBgColor(), CR_FRONT); // Setup the "new" dialog look ASSERT(TRUE == 1); ASSERT(FALSE == 0); g_uThreadACP = GetACP(); OSVERSIONINFO osvi; ZeroMemory(&osvi, sizeof(OSVERSIONINFO)); osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); GetVersionEx(&osvi); if((osvi.dwMajorVersion == 5) && (osvi.dwMinorVersion == 0)) // Windows 2000 g_bForceSimpleAsterisks = TRUE; if((osvi.dwMajorVersion <= 4) || ((osvi.dwMajorVersion == 5) && (osvi.dwMinorVersion == 0))) // Restore old banner style if running on < XP NewGUI_SetWin32Banner(); NewGUI_InitGDIPlus(); CPwSafeDlg dlg; m_pMainWnd = &dlg; CPrivateConfigEx* pc = new CPrivateConfigEx(FALSE); if(pc != NULL) { pc->LoadStaticConfigFileOverrides(); dlg.m_bCheckForInstance = pc->GetBool(PWMKEY_SINGLEINSTANCE, FALSE); CMemoryProtectionEx::SetEnabledAtStart(pc->GetBool(PWMKEY_USEDPAPIFORMEMPROT, TRUE)); *CKeyTransformBCrypt::GetEnabledPtr() = pc->GetBool(PWMKEY_USECNGBCRYPTFORKEYT, TRUE); delete pc; pc = NULL; } else { ASSERT(FALSE); } if(dlg.m_bCheckForInstance == TRUE) { dlg.m_instanceChecker.ActivateChecker(); if(dlg.m_instanceChecker.PreviousInstanceRunning()) { /* CString strFile; LPCTSTR lpPassword = NULL; LPCTSTR lpKeyFile = NULL; LPCTSTR lpPreSelectPath = NULL; DWORD dwData = 0; ParseCurrentCommandLine(&strFile, &lpPassword, &lpKeyFile, &lpPreSelectPath); if(strFile.GetLength() != 0) { if(lpPassword != NULL) { dwData |= (DWORD)_tcslen(lpPassword) << 16; strFile = CString(lpPassword) + strFile; } if(lpKeyFile != NULL) { dwData |= (DWORD)_tcslen(lpKeyFile); strFile = CString(lpKeyFile) + strFile; } dlg.m_instanceChecker.ActivatePreviousInstance((LPCTSTR)strFile, dwData); } else dlg.m_instanceChecker.ActivatePreviousInstance(_T(""), 0xF0FFFFF0); */ const FullPathName& database = CmdArgs::instance().getDatabase(); if(database.getState() == FullPathName::PATH_AND_FILENAME) { std_string strData(database.getFullPathName()); DWORD dwData = 0; if(!CmdArgs::instance().getPassword().empty()) { dwData |= ((DWORD)CmdArgs::instance().getPassword().length() << 16); strData = CmdArgs::instance().getPassword() + strData; } else if(CmdArgs::instance().pwStdInIsInEffect()) { std_string strPw = WU_StdInReadPassword(); dwData |= ((DWORD)strPw.length() << 16); strData = strPw + strData; } const FullPathName& keyfile = CmdArgs::instance().getKeyfile(); enum {PATH_EXISTS = FullPathName::PATH_ONLY | FullPathName::PATH_AND_FILENAME}; if(keyfile.getState() & PATH_EXISTS && !CmdArgs::instance().preselectIsInEffect()) { dwData |= (DWORD)keyfile.getFullPathName().length(); strData = keyfile.getFullPathName() + strData; } dlg.m_instanceChecker.ActivatePreviousInstance(strData.c_str(), dwData); } else dlg.m_instanceChecker.ActivatePreviousInstance(_T(""), 0xF0FFFFF0); m_pMainWnd = NULL; this->_App_CleanUp(); return FALSE; } } InitializeCriticalSection(&g_csLockTimer); NSCAPI_Initialize(); // Initialize natural string comparison API CTaskbarListEx::Initialize(); dlg.DoModal(); // IDOK, IDCANCEL; not NewGUI_DoModal CPluginManager::Instance().UnloadAllPlugins(FALSE); KP_ASSERT_REFS(CKpApiImpl::Instance(), 1); KP_ASSERT_REFS(CKpDatabaseImpl::Instance(), 1); KP_ASSERT_REFS(CKpUtilitiesImpl::Instance(), 1); KP_ASSERT_REFS(CKpCommandLineImpl::Instance(), 1); dlg._AssertDisplayCounts(0, 0); CTaskbarListEx::Release(false); NSCAPI_Exit(); // Clean up natural string comparison API DeleteCriticalSection(&g_csLockTimer); this->_App_CleanUp(); return FALSE; }
bool CWAbsMutex::AMutexInit(thread_mutex mutext) { InitializeCriticalSection((LPCRITICAL_SECTION)mutext); return (true); }
static ssize_t ofi_nd_ep_readv(struct fid_ep *pep, const struct iovec *iov, void **desc, size_t count, fi_addr_t src_addr, uint64_t addr, uint64_t key, void *context) { struct fi_rma_iov rma_iov = { .addr = addr, .len = iov[0].iov_len, .key = key }; struct fi_msg_rma msg = { .msg_iov = iov, .desc = desc, .iov_count = count, .addr = src_addr, .rma_iov = &rma_iov, .rma_iov_count = 1, .context = context, .data = 0 }; assert(pep->fid.fclass == FI_CLASS_EP); if (pep->fid.fclass != FI_CLASS_EP) return -FI_EINVAL; struct nd_ep *ep = container_of(pep, struct nd_ep, fid); return ofi_nd_ep_readmsg(pep, &msg, ep->info->rx_attr->op_flags); } static ssize_t ofi_nd_ep_readmsg(struct fid_ep *pep, const struct fi_msg_rma *msg, uint64_t flags) { assert(pep->fid.fclass == FI_CLASS_EP); assert(msg); if (pep->fid.fclass != FI_CLASS_EP) return -FI_EINVAL; size_t msg_len = 0, rma_len = 0, i; HRESULT hr; struct nd_ep *ep = container_of(pep, struct nd_ep, fid); if (!ep->qp) return -FI_EOPBADSTATE; for (i = 0; i < msg->iov_count; i++) { if (msg->msg_iov[i].iov_len && !msg->msg_iov[i].iov_base) return -FI_EINVAL; msg_len += msg->msg_iov[i].iov_len; } for (i = 0; i < msg->rma_iov_count; i++) { if (msg->rma_iov[i].len && !msg->rma_iov[i].addr) return -FI_EINVAL; rma_len += msg->rma_iov[i].len; } /* Check the following: */ if ((msg_len != rma_len) || /* - msg and rma len are correlated */ /* - iov counts are less or equal than supported */ (msg->iov_count > ND_MSG_IOV_LIMIT || msg->rma_iov_count > ND_MSG_IOV_LIMIT) || /* - transmitted length is less or equal than max possible */ (msg_len > ep->domain->info->ep_attr->max_msg_size)) return -FI_EINVAL; struct nd_cq_entry *main_entry = ofi_nd_buf_alloc_nd_cq_entry(); if (!main_entry) return -FI_ENOMEM; memset(main_entry, 0, sizeof(*main_entry)); main_entry->data = msg->data; main_entry->flags = flags; main_entry->domain = ep->domain; main_entry->context = msg->context; main_entry->seq = InterlockedAdd64(&ep->domain->msg_cnt, 1); /* since write operation can't be canceled, set NULL into * the 1st byte of internal data of context */ if (msg->context) ND_FI_CONTEXT(msg->context) = 0; struct fi_rma_iov rma_iovecs[ND_MSG_INTERNAL_IOV_LIMIT]; size_t rma_count = 0; size_t from_split_map[ND_MSG_INTERNAL_IOV_LIMIT]; size_t to_split_map[ND_MSG_INTERNAL_IOV_LIMIT]; uint64_t remote_addr[ND_MSG_INTERNAL_IOV_LIMIT]; ofi_nd_split_msg_iov_2_rma_iov(msg->rma_iov, msg->rma_iov_count, msg->msg_iov, msg->iov_count, rma_iovecs, &rma_count, from_split_map, to_split_map, remote_addr); assert(rma_count <= ND_MSG_INTERNAL_IOV_LIMIT); main_entry->wait_completion.comp_count = 0; main_entry->wait_completion.total_count = rma_count; InitializeCriticalSection(&main_entry->wait_completion.comp_lock); struct nd_cq_entry *entries[ND_MSG_IOV_LIMIT]; for (i = 0; i < rma_count; i++) { entries[i] = ofi_nd_buf_alloc_nd_cq_entry(); if (!entries[i]) goto fn_fail; memset(entries[i], 0, sizeof(*entries[i])); entries[i]->data = msg->data; entries[i]->flags = flags; entries[i]->domain = ep->domain; entries[i]->context = msg->context; entries[i]->seq = main_entry->seq; entries[i]->aux_entry = main_entry; hr = ep->domain->adapter->lpVtbl->CreateMemoryRegion( ep->domain->adapter, &IID_IND2MemoryRegion, ep->domain->adapter_file, (void**)&entries[i]->mr[0]); if (FAILED(hr)) goto fn_fail; entries[i]->mr_count = 1; hr = ofi_nd_util_register_mr( entries[i]->mr[0], (const void *)remote_addr[i], rma_iovecs[i].len, ND_MR_FLAG_ALLOW_LOCAL_WRITE | ND_MR_FLAG_ALLOW_REMOTE_READ | ND_MR_FLAG_ALLOW_REMOTE_WRITE); if (FAILED(hr)) goto fn_fail; ND2_SGE sge = { .Buffer = (void *)remote_addr[i], .BufferLength = (ULONG)rma_iovecs[i].len, .MemoryRegionToken = (UINT32)(uintptr_t)msg->desc[to_split_map[i]] }; hr = ep->qp->lpVtbl->Read(ep->qp, entries[i], &sge, 1, (UINT64)rma_iovecs[i].addr, (UINT32)rma_iovecs[i].key, 0); if (FAILED(hr)) goto fn_fail; } return FI_SUCCESS; fn_fail: while (i-- > 0) ofi_nd_free_cq_entry(entries[i]); ND_LOG_WARN(FI_LOG_EP_DATA, ofi_nd_strerror((DWORD)hr, NULL)); return H2F(hr); } static ssize_t ofi_nd_ep_write(struct fid_ep *ep, const void *buf, size_t len, void *desc, fi_addr_t dest_addr, uint64_t addr, uint64_t key, void *context) { struct iovec iov = { .iov_base = (void*)buf, .iov_len = len }; return ofi_nd_ep_writev(ep, &iov, &desc, 1, dest_addr, addr, key, context); } static ssize_t ofi_nd_ep_writev(struct fid_ep *pep, const struct iovec *iov, void **desc, size_t count, fi_addr_t dest_addr, uint64_t addr, uint64_t key, void *context) { struct fi_rma_iov rma_iov = { .addr = addr, .len = iov[0].iov_len, .key = key }; struct fi_msg_rma msg = { .msg_iov = iov, .desc = desc, .iov_count = count, .addr = dest_addr, .rma_iov = &rma_iov, .rma_iov_count = 1, .context = context, .data = 0 }; assert(pep->fid.fclass == FI_CLASS_EP); if (pep->fid.fclass != FI_CLASS_EP) return -FI_EINVAL; struct nd_ep *ep = container_of(pep, struct nd_ep, fid); return ofi_nd_ep_writemsg(pep, &msg, ep->info->tx_attr->op_flags); } static ssize_t ofi_nd_ep_writemsg(struct fid_ep *pep, const struct fi_msg_rma *msg, uint64_t flags) { assert(pep->fid.fclass == FI_CLASS_EP); assert(msg); if (pep->fid.fclass != FI_CLASS_EP) return -FI_EINVAL; size_t msg_len = 0, rma_len = 0, i; HRESULT hr; struct nd_cq_entry *entries[ND_MSG_IOV_LIMIT]; struct nd_ep *ep = container_of(pep, struct nd_ep, fid); if (!ep->qp) return -FI_EOPBADSTATE; for (i = 0; i < msg->iov_count; i++) { if (msg->msg_iov[i].iov_len && !msg->msg_iov[i].iov_base) return -FI_EINVAL; msg_len += msg->msg_iov[i].iov_len; } if ((msg_len > ep->domain->info->ep_attr->max_msg_size) && (flags & FI_INJECT)) return -FI_EINVAL; for (i = 0; i < msg->rma_iov_count; i++) { if (msg->rma_iov[i].len && !msg->rma_iov[i].addr) return -FI_EINVAL; rma_len += msg->rma_iov[i].len; } /* Check the following: */ if ((msg_len != rma_len) || /* - msg and rma len are correlated */ /* - iov counts are less or equal than supported */ ((msg->iov_count > ND_MSG_IOV_LIMIT || msg->rma_iov_count > ND_MSG_IOV_LIMIT)) || /* - transmitted length is less or equal than max possible */ (msg_len > ep->domain->info->ep_attr->max_msg_size) || /* - if INJECT, data should be inlined */ ((flags & FI_INJECT) && (msg_len > ep->domain->info->tx_attr->inject_size))) return -FI_EINVAL; struct nd_cq_entry *main_entry = ofi_nd_buf_alloc_nd_cq_entry(); if (!main_entry) return -FI_ENOMEM; memset(main_entry, 0, sizeof(*main_entry)); main_entry->data = msg->data; main_entry->flags = flags; main_entry->domain = ep->domain; main_entry->context = msg->context; main_entry->seq = InterlockedAdd64(&ep->domain->msg_cnt, 1); /* since write operation can't be canceled, set NULL into * the 1st byte of internal data of context */ if (msg->context) ND_FI_CONTEXT(msg->context) = 0; /* TODO */ if (msg_len > (size_t)gl_data.inline_thr) { struct fi_rma_iov rma_iovecs[ND_MSG_INTERNAL_IOV_LIMIT]; size_t rma_count = 0; size_t from_split_map[ND_MSG_INTERNAL_IOV_LIMIT]; size_t to_split_map[ND_MSG_INTERNAL_IOV_LIMIT]; uint64_t remote_addr[ND_MSG_INTERNAL_IOV_LIMIT]; ofi_nd_split_msg_iov_2_rma_iov(msg->rma_iov, msg->rma_iov_count, msg->msg_iov, msg->iov_count, rma_iovecs, &rma_count, from_split_map, to_split_map, remote_addr); assert(rma_count <= ND_MSG_INTERNAL_IOV_LIMIT); main_entry->wait_completion.comp_count = 0; main_entry->wait_completion.total_count = rma_count; InitializeCriticalSection(&main_entry->wait_completion.comp_lock); for (i = 0; i < rma_count; i++) { entries[i] = ofi_nd_buf_alloc_nd_cq_entry(); if (!entries[i]) goto fn_fail; memset(entries[i], 0, sizeof(*entries[i])); entries[i]->data = msg->data; entries[i]->flags = flags; entries[i]->domain = ep->domain; entries[i]->context = msg->context; entries[i]->seq = main_entry->seq; entries[i]->aux_entry = main_entry; ND2_SGE sge = { .Buffer = (void *)remote_addr[i], .BufferLength = (ULONG)rma_iovecs[i].len, .MemoryRegionToken = (UINT32)(uintptr_t)msg->desc[to_split_map[i]] }; hr = ep->qp->lpVtbl->Write(ep->qp, entries[i], &sge, 1, (UINT64)rma_iovecs[i].addr, (UINT32)rma_iovecs[i].key, 0); if (FAILED(hr)) goto fn_fail; } return FI_SUCCESS; } else { if (msg_len) { main_entry->inline_buf = __ofi_nd_buf_alloc_nd_inlinebuf(&ep->domain->inlinebuf); if (!main_entry->inline_buf) return -FI_ENOMEM; char *buf = (char*)main_entry->inline_buf->buffer; for (i = 0; i < msg->iov_count; i++) { memcpy(buf, msg->msg_iov[i].iov_base, msg->msg_iov[i].iov_len); buf += msg->msg_iov[i].iov_len; } } for (i = 0; i < msg->rma_iov_count; i++) { char *buf = (char *)main_entry->inline_buf->buffer; entries[i] = ofi_nd_buf_alloc_nd_cq_entry(); if (!entries[i]) goto fn_fail; memset(entries[i], 0, sizeof(*entries[i])); entries[i]->data = msg->data; entries[i]->flags = flags; entries[i]->domain = ep->domain; entries[i]->context = msg->context; entries[i]->seq = main_entry->seq; entries[i]->aux_entry = main_entry; ND2_SGE sge = { .Buffer = (void *)(buf + msg->rma_iov[i].len), .BufferLength = (ULONG)msg->rma_iov[i].len, .MemoryRegionToken = main_entry->inline_buf->token }; hr = ep->qp->lpVtbl->Write(ep->qp, entries[i], &sge, 1, (UINT64)msg->rma_iov[i].addr, (UINT32)msg->rma_iov[i].key, 0); if (FAILED(hr)) goto fn_fail; } return FI_SUCCESS; } fn_fail: while (i-- > 0) ofi_nd_free_cq_entry(entries[i]); ND_LOG_WARN(FI_LOG_EP_DATA, ofi_nd_strerror((DWORD)hr, NULL)); return H2F(hr); } static ssize_t ofi_nd_ep_inject(struct fid_ep *pep, const void *buf, size_t len, fi_addr_t dest_addr, uint64_t addr, uint64_t key) { struct iovec iov = { .iov_base = (void*)buf, .iov_len = len }; struct fi_rma_iov rma_iov = { .addr = addr, .len = len, .key = key }; struct fi_msg_rma msg = { .msg_iov = &iov, .desc = 0, .iov_count = 1, .addr = dest_addr, .rma_iov = &rma_iov, .rma_iov_count = 1, .context = 0, .data = 0 }; return ofi_nd_ep_writemsg(pep, &msg, FI_INJECT); } static ssize_t ofi_nd_ep_writedata(struct fid_ep *pep, const void *buf, size_t len, void *desc, uint64_t data, fi_addr_t dest_addr, uint64_t addr, uint64_t key, void *context) { struct iovec iov = { .iov_base = (void*)buf, .iov_len = len }; struct fi_rma_iov rma_iov = { .addr = addr, .len = len, .key = key }; struct fi_msg_rma msg = { .msg_iov = &iov, .desc = &desc, .iov_count = 1, .addr = dest_addr, .rma_iov = &rma_iov, .rma_iov_count = 1, .context = context, .data = data }; assert(pep->fid.fclass == FI_CLASS_EP); if (pep->fid.fclass != FI_CLASS_EP) return -FI_EINVAL; struct nd_ep *ep = container_of(pep, struct nd_ep, fid); return ofi_nd_ep_writemsg(pep, &msg, ep->info->tx_attr->op_flags | FI_REMOTE_CQ_DATA); } static ssize_t ofi_nd_ep_writeinjectdata(struct fid_ep *ep, const void *buf, size_t len, uint64_t data, fi_addr_t dest_addr, uint64_t addr, uint64_t key) { struct iovec iov = { .iov_base = (void*)buf, .iov_len = len }; struct fi_rma_iov rma_iov = { .addr = addr, .len = len, .key = key }; struct fi_msg_rma msg = { .msg_iov = &iov, .desc = 0, .iov_count = 1, .addr = dest_addr, .rma_iov = &rma_iov, .rma_iov_count = 1, .context = 0, .data = data }; return ofi_nd_ep_writemsg(ep, &msg, FI_INJECT | FI_REMOTE_CQ_DATA); } void ofi_nd_read_event(ND2_RESULT *result) { assert(result); assert(result->RequestType == Nd2RequestTypeRead); nd_cq_entry *entry = (nd_cq_entry*)result->RequestContext; assert(entry); ND_LOG_EVENT_INFO(entry); /* Check whether the operation is complex, i.e. read operation * may consists from several subtasks of read */ if (entry->aux_entry) { EnterCriticalSection(&entry->aux_entry->wait_completion.comp_lock); entry->aux_entry->wait_completion.comp_count++; ND_LOG_DEBUG(FI_LOG_EP_DATA, "READ Event comp_count = %d, total_count = %d\n", entry->aux_entry->wait_completion.comp_count, entry->aux_entry->wait_completion.total_count); if (entry->aux_entry->wait_completion.comp_count < entry->aux_entry->wait_completion.total_count) { /* Should wait some remaining completion events about read operation */ LeaveCriticalSection(&entry->aux_entry->wait_completion.comp_lock); entry->aux_entry = NULL; ofi_nd_free_cq_entry(entry); return; } LeaveCriticalSection(&entry->aux_entry->wait_completion.comp_lock); } /*TODO: Handle erroneous case "result->Status != S_OK" */ ofi_nd_dispatch_cq_event(entry->state == LARGE_MSG_RECV_REQ ? LARGE_MSG_REQ : NORMAL_EVENT, entry, result); } void ofi_nd_write_event(ND2_RESULT *result) { assert(result); assert(result->RequestType == Nd2RequestTypeWrite); nd_cq_entry *entry = (nd_cq_entry*)result->RequestContext; assert(entry); struct nd_ep *ep = (struct nd_ep*)result->QueuePairContext; assert(ep); assert(ep->fid.fid.fclass == FI_CLASS_EP); ND_LOG_EVENT_INFO(entry); /* Check whether the operation is complex, i.e. write operation * may consist from several subtasks of write */ if (entry->aux_entry) { EnterCriticalSection(&entry->aux_entry->wait_completion.comp_lock); entry->aux_entry->wait_completion.comp_count++; if (entry->aux_entry->wait_completion.comp_count < entry->aux_entry->wait_completion.total_count) { /* Should wait some remaining completion events about write operation */ LeaveCriticalSection(&entry->aux_entry->wait_completion.comp_lock); entry->aux_entry = NULL; ofi_nd_free_cq_entry(entry); return; } LeaveCriticalSection(&entry->aux_entry->wait_completion.comp_lock); } if (!entry->context) { /* This means that this write was an internal event, * just release it */ ofi_nd_free_cq_entry(entry); return; } if (entry->flags & FI_REMOTE_CQ_DATA) { if (ofi_nd_ep_injectdata( &ep->fid, 0, 0, entry->data, FI_ADDR_UNSPEC) != FI_SUCCESS) ND_LOG_WARN(FI_LOG_CQ, "failed to write-inject"); } if (ep->cntr_write) { if (result->Status != S_OK) { InterlockedIncrement64(&ep->cntr_write->err); } InterlockedIncrement64(&ep->cntr_write->counter); WakeByAddressAll((void*)&ep->cntr_write->counter); } int notify = ofi_nd_util_completion_blackmagic( ep->info->tx_attr->op_flags, ep->send_flags, entry->flags) || result->Status != S_OK; if (notify) { PostQueuedCompletionStatus( entry->result.Status == S_OK ? ep->cq_send->iocp : ep->cq_send->err, 0, 0, &entry->base.ov); InterlockedIncrement(&ep->cq_send->count); WakeByAddressAll((void*)&ep->cq_send->count); } else { /* if notification is not requested - just free entry */ ofi_nd_free_cq_entry(entry); } } void ofi_nd_split_msg_iov_2_rma_iov(const struct fi_rma_iov *rma_iovecs, const size_t rma_count, const struct iovec *msg_iovecs, const size_t msg_count, struct fi_rma_iov res_iovecs[ND_MSG_INTERNAL_IOV_LIMIT], size_t *res_count, size_t from_split_map[ND_MSG_INTERNAL_IOV_LIMIT], size_t to_split_map[ND_MSG_INTERNAL_IOV_LIMIT], uint64_t remote_addr[ND_MSG_INTERNAL_IOV_LIMIT]) { size_t i; struct iovec from_rma_iovecs[ND_MSG_IOV_LIMIT]; size_t from_rma_count = rma_count; struct iovec res_msg_iovecs[ND_MSG_IOV_LIMIT]; size_t res_msg_count = 0; /* Convert RMA iovecs to MSG iovecs to be able to reuse * them in @ofi_nd_repack_iovecs */ for (i = 0; i < rma_count; i++) { from_rma_iovecs[i].iov_base = (void *)rma_iovecs[i].addr; from_rma_iovecs[i].iov_len = rma_iovecs[i].len; } ofi_nd_repack_iovecs(from_rma_iovecs, from_rma_count, msg_iovecs, msg_count, res_msg_iovecs, &res_msg_count, from_split_map, to_split_map, remote_addr); /* Extract MSG iov to RMA iovecs and returns them */ for (i = 0; i < res_msg_count; i++) { res_iovecs[i].addr = remote_addr[i]; res_iovecs[i].len = res_msg_iovecs[i].iov_len; res_iovecs[i].key = rma_iovecs[from_split_map[i]].key; remote_addr[i] = (uint64_t)res_msg_iovecs[i].iov_base; } *res_count = res_msg_count; }
void mono_debugger_initialize () { InitializeCriticalSection (&debugger_lock_mutex); initialized = 1; }
CriticalSection::CriticalSection() { InitializeCriticalSection(&cSec); }
TSync::TSync() { this->m_nLock=0; InitializeCriticalSection(&this->m_cs); }
int pthread_mutex_init (pthread_mutex_t *mp, pthread_mutexattr_t *attr) { InitializeCriticalSection (mp); return 0; };
MutexImpl::MutexImpl() { InitializeCriticalSection(&myMutex); }
ChmModel::ChmModel(ControllerCallback *cb) : Controller(cb), doc(nullptr), htmlWindow(nullptr), htmlWindowCb(nullptr), tocTrace(nullptr), currentPageNo(1), initZoom(INVALID_ZOOM) { InitializeCriticalSection(&docAccess); }
int __declspec(dllexport) Load(PLUGINLINK *link) { PROTOCOLDESCRIPTOR pd; HANDLE hContact; char text[_MAX_PATH]; char *p, *q; char *szProto; CLISTMENUITEM mi, clmi; DBVARIANT dbv; GetModuleFileName(hInst, text, sizeof(text)); p = strrchr(text, '\\'); p++; q = strrchr(p, '.'); *q = '\0'; jabberProtoName = _strdup(p); _strupr(jabberProtoName); jabberModuleName = _strdup(jabberProtoName); _strlwr(jabberModuleName); jabberModuleName[0] = toupper(jabberModuleName[0]); JabberLog("Setting protocol/module name to '%s/%s'", jabberProtoName, jabberModuleName); pluginLink = link; DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &hMainThread, THREAD_SET_CONTEXT, FALSE, 0); jabberMainThreadId = GetCurrentThreadId(); //hLibSSL = NULL; // hWndListGcLog = (HANDLE) CallService(MS_UTILS_ALLOCWINDOWLIST, 0, 0); HookEvent(ME_OPT_INITIALISE, TlenOptInit); HookEvent(ME_SYSTEM_MODULESLOADED, ModulesLoaded); HookEvent(ME_SYSTEM_PRESHUTDOWN, PreShutdown); // Register protocol module ZeroMemory(&pd, sizeof(PROTOCOLDESCRIPTOR)); pd.cbSize = sizeof(PROTOCOLDESCRIPTOR); pd.szName = jabberProtoName; pd.type = PROTOTYPE_PROTOCOL; CallService(MS_PROTO_REGISTERMODULE, 0, (LPARAM) &pd); memset(&mi, 0, sizeof(CLISTMENUITEM)); mi.cbSize = sizeof(CLISTMENUITEM); memset(&clmi, 0, sizeof(CLISTMENUITEM)); clmi.cbSize = sizeof(CLISTMENUITEM); clmi.flags = CMIM_FLAGS | CMIF_GRAYED; mi.pszPopupName = jabberModuleName; mi.popupPosition = 500090000; // "Multi-User Conference" wsprintf(text, "%s/MainMenuMUC", jabberModuleName); CreateServiceFunction(text, TlenMUCMenuHandleMUC); mi.pszName = Translate("Multi-User Conference"); mi.position = 2000050001; mi.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_TLEN)); mi.pszService = text; hMenuMUC = (HANDLE) CallService(MS_CLIST_ADDMAINMENUITEM, 0, (LPARAM) &mi); CallService(MS_CLIST_MODIFYMENUITEM, (WPARAM) hMenuMUC, (LPARAM) &clmi); wsprintf(text, "%s/MainMenuChats", jabberModuleName); CreateServiceFunction(text, TlenMUCMenuHandleChats); mi.pszName = Translate("Tlen Chats..."); mi.position = 2000050002; mi.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_TLEN)); mi.pszService = text; hMenuChats = (HANDLE) CallService(MS_CLIST_ADDMAINMENUITEM, 0, (LPARAM) &mi); CallService(MS_CLIST_MODIFYMENUITEM, (WPARAM) hMenuChats, (LPARAM) &clmi); // "Invite to MUC" sprintf(text, "%s/ContactMenuMUC", jabberModuleName); CreateServiceFunction(text, TlenMUCContactMenuHandleMUC); mi.pszName = Translate("Multi-User Conference"); mi.position = -2000020000; mi.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_MUC)); mi.pszService = text; mi.pszContactOwner = jabberProtoName; hMenuContactMUC = (HANDLE) CallService(MS_CLIST_ADDCONTACTMENUITEM, 0, (LPARAM) &mi); // "Invite to voice chat" sprintf(text, "%s/ContactMenuVoice", jabberModuleName); CreateServiceFunction(text, TlenVoiceContactMenuHandleVoice); mi.pszName = Translate("Voice Chat"); mi.position = -2000018000; mi.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_MICROPHONE)); mi.pszService = text; mi.pszContactOwner = jabberProtoName; hMenuContactVoice = (HANDLE) CallService(MS_CLIST_ADDCONTACTMENUITEM, 0, (LPARAM) &mi); // "Request authorization" sprintf(text, "%s/RequestAuth", jabberModuleName); CreateServiceFunction(text, TlenContactMenuHandleRequestAuth); mi.pszName = Translate("Request authorization"); mi.position = -2000001001; mi.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_REQUEST)); mi.pszService = text; mi.pszContactOwner = jabberProtoName; hMenuContactRequestAuth = (HANDLE) CallService(MS_CLIST_ADDCONTACTMENUITEM, 0, (LPARAM) &mi); // "Grant authorization" sprintf(text, "%s/GrantAuth", jabberModuleName); CreateServiceFunction(text, TlenContactMenuHandleGrantAuth); mi.pszName = Translate("Grant authorization"); mi.position = -2000001000; mi.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_GRANT)); mi.pszService = text; mi.pszContactOwner = jabberProtoName; hMenuContactGrantAuth = (HANDLE) CallService(MS_CLIST_ADDCONTACTMENUITEM, 0, (LPARAM) &mi); HookEvent(ME_CLIST_PREBUILDCONTACTMENU, TlenPrebuildContactMenu); if (!DBGetContactSetting(NULL, jabberProtoName, "LoginServer", &dbv)) { DBFreeVariant(&dbv); } else { DBWriteContactSettingString(NULL, jabberProtoName, "LoginServer", "tlen.pl"); } if (!DBGetContactSetting(NULL, jabberProtoName, "ManualHost", &dbv)) { DBFreeVariant(&dbv); } else { DBWriteContactSettingString(NULL, jabberProtoName, "ManualHost", "s1.tlen.pl"); } // Set all contacts to offline hContact = (HANDLE) CallService(MS_DB_CONTACT_FINDFIRST, 0, 0); while (hContact != NULL) { szProto = (char *) CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM) hContact, 0); if(szProto!=NULL && !strcmp(szProto, jabberProtoName)) { if (DBGetContactSettingWord(hContact, jabberProtoName, "Status", ID_STATUS_OFFLINE) != ID_STATUS_OFFLINE) { DBWriteContactSettingWord(hContact, jabberProtoName, "Status", ID_STATUS_OFFLINE); } } hContact = (HANDLE) CallService(MS_DB_CONTACT_FINDNEXT, (WPARAM) hContact, 0); } streamId = NULL; jabberThreadInfo = NULL; jabberConnected = FALSE; jabberOnline = FALSE; jabberStatus = ID_STATUS_OFFLINE; jabberVcardPhotoFileName = NULL; jabberVcardPhotoType = NULL; memset((char *) &modeMsgs, 0, sizeof(JABBER_MODEMSGS)); //jabberModeMsg = NULL; jabberCodePage = CP_ACP; InitializeCriticalSection(&mutex); InitializeCriticalSection(&modeMsgMutex); TlenIconInit(); srand((unsigned) time(NULL)); JabberSerialInit(); JabberIqInit(); JabberListInit(); JabberSvcInit(); return 0; }
// // Function: FindLspEntries // // Description: // This function searches the Winsock catalog and builds an array of the // WSAPROTOCOL_INFOW structures which belong to the LSP. This includes // all layered protocol chains as well as the LSP dummy (hidden) entry. // The function first finds the dummy entry using 'gProviderGuid' which // is the global GUID of the dummy entry. From there, the catalog is // searched for all entries whose first entry in the protocol chain // matches the dummy entry's catalog ID. // BOOL FindLspEntries( PROVIDER **lspProviders, int *lspProviderCount, int *lpErrno ) { PROVIDER *Providers = NULL; LPWSAPROTOCOL_INFOW ProtocolInfo = NULL; DWORD DummyLspId = 0; int ProtocolCount = 0, LayerCount = 0, idx, i, j; *lspProviderCount = 0; *lspProviders = NULL; // Enumerate the catalog ProtocolInfo = EnumerateProviders( LspCatalogBoth, &ProtocolCount ); if ( NULL == ProtocolInfo ) { dbgprint("FindLspEntries; EnumerateProviders failed!"); goto cleanup; } // Find our dummy LSP entry ID DummyLspId = 0; for(i=0; i < ProtocolCount ;i++) { if ( 0 == memcmp( &ProtocolInfo[ i ].ProviderId, &gProviderGuid, sizeof( gProviderGuid ) ) ) { DummyLspId = ProtocolInfo[ i ].dwCatalogEntryId; break; } } ASSERT( 0 != DummyLspId ); // Count how many LSP layered entries are present LayerCount = 0; for(i=0; i < ProtocolCount ;i++) { if ( ( ProtocolInfo[ i ].ProtocolChain.ChainLen > 1 ) && ( DummyLspId == ProtocolInfo[ i ].ProtocolChain.ChainEntries[ 0 ] ) ) { LayerCount++; } } ASSERT( 0 != LayerCount ); // Allocate space for the layered providers Providers = (PROVIDER *) LspAlloc( sizeof(PROVIDER) * LayerCount, lpErrno ); if ( NULL == Providers ) { dbgprint("FindLspEntries: LspAlloc failed: %d", *lpErrno ); goto cleanup; } idx = 0; // Save the LSP layered entries for(i=0; i < ProtocolCount ;i++) { // The layered protocol entries for this LSP will always reference the // dummy entry ID as its first entry in the chain array. Also make // sure to check only LSP entries (since a base provider's chain length // is 1 but the chain array entries can be garbage) if ( ( ProtocolInfo[ i ].ProtocolChain.ChainLen > 1 ) && ( DummyLspId == ProtocolInfo[ i ].ProtocolChain.ChainEntries[ 0 ] ) ) { // Copy the new entry to the head memcpy( &Providers[ idx ].LayerProvider, &ProtocolInfo[ i ], sizeof(WSAPROTOCOL_INFOW) ); Providers[ idx ].LayerProvider.szProtocol[ WSAPROTOCOL_LEN ] = '\0'; // Copy the provider underneath this entry for(j=0; j < ProtocolCount ;j++) { // The next provider can either be a base, a dummy, or another layered // protocol chain. If a dummy or layer then both providers will have // the same DLL to load. if ( ProtocolInfo[ i ].ProtocolChain.ChainEntries[ 1 ] == ProtocolInfo[ j ].dwCatalogEntryId ) { memcpy( &Providers[ idx ].NextProvider, &ProtocolInfo[ j ], sizeof( WSAPROTOCOL_INFOW ) ); Providers[ idx ].NextProvider.szProtocol[ WSAPROTOCOL_LEN ] = '\0'; break; } } // Verify we copied the lower layer ASSERT( j < ProtocolCount ); InitializeCriticalSection( &Providers[ idx ].ProviderCritSec ); InitializeListHead( &Providers[ idx ].SocketList ); Providers[ idx ].LspDummyId = DummyLspId; idx++; } } ASSERT( idx == LayerCount ); if ( NULL != ProtocolInfo ) FreeProviders( ProtocolInfo ); *lspProviders = Providers; *lspProviderCount = LayerCount; return TRUE; cleanup: if ( NULL != ProtocolInfo ) FreeProviders( ProtocolInfo ); if ( NULL != Providers ) LspFree( Providers ); return FALSE; }
void vlc_mutex_init_recursive( vlc_mutex_t *p_mutex ) { InitializeCriticalSection( &p_mutex->mutex ); p_mutex->dynamic = true; }
static JoystickImpl *alloc_device(REFGUID rguid, const void *jvt, IDirectInputImpl *dinput, unsigned short index) { JoystickImpl* newDevice; LPDIDATAFORMAT df = NULL; int i, idx = 0; char buffer[MAX_PATH+16]; HKEY hkey, appkey; LONG def_deadzone = 0; newDevice = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(JoystickImpl)); if (!newDevice) return NULL; newDevice->base.lpVtbl = jvt; newDevice->base.ref = 1; newDevice->base.guid = *rguid; newDevice->base.dinput = dinput; newDevice->joyfd = -1; newDevice->joydev = &joydevs[index]; #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION newDevice->ff_state = FF_STATUS_STOPPED; #endif InitializeCriticalSection(&newDevice->base.crit); newDevice->base.crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": JoystickImpl*->base.crit"); /* get options */ get_app_key(&hkey, &appkey); if (!get_config_key(hkey, appkey, "DefaultDeadZone", buffer, MAX_PATH)) { def_deadzone = atoi(buffer); TRACE("setting default deadzone to: %d\n", def_deadzone); } if (appkey) RegCloseKey(appkey); if (hkey) RegCloseKey(hkey); /* Create copy of default data format */ if (!(df = HeapAlloc(GetProcessHeap(), 0, c_dfDIJoystick2.dwSize))) goto failed; memcpy(df, &c_dfDIJoystick2, c_dfDIJoystick2.dwSize); if (!(df->rgodf = HeapAlloc(GetProcessHeap(), 0, df->dwNumObjs * df->dwObjSize))) goto failed; /* Supported Axis & POVs should map 1-to-1 */ for (i = 0; i < WINE_JOYSTICK_MAX_AXES; i++) { if (!test_bit(newDevice->joydev->absbits, i)) { newDevice->axes[i] = -1; continue; } memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i], df->dwObjSize); newDevice->axes[i] = idx; newDevice->props[idx].lDevMin = newDevice->joydev->axes[i].minimum; newDevice->props[idx].lDevMax = newDevice->joydev->axes[i].maximum; newDevice->props[idx].lMin = 0; newDevice->props[idx].lMax = 0xffff; newDevice->props[idx].lSaturation = 0; newDevice->props[idx].lDeadZone = def_deadzone; df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numAxes++) | DIDFT_ABSAXIS; } for (i = 0; i < WINE_JOYSTICK_MAX_POVS; i++) { if (!test_bit(newDevice->joydev->absbits, ABS_HAT0X + i * 2) || !test_bit(newDevice->joydev->absbits, ABS_HAT0Y + i * 2)) { newDevice->axes[ABS_HAT0X + i * 2] = newDevice->axes[ABS_HAT0Y + i * 2] = -1; continue; } memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i + WINE_JOYSTICK_MAX_AXES], df->dwObjSize); newDevice->axes[ABS_HAT0X + i * 2] = newDevice->axes[ABS_HAT0Y + i * 2] = i; df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numPOVs++) | DIDFT_POV; } /* Buttons can be anywhere, so check all */ for (i = 0; i < KEY_MAX && newDevice->numButtons < WINE_JOYSTICK_MAX_BUTTONS; i++) { if (!test_bit(newDevice->joydev->keybits, i)) continue; memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[newDevice->numButtons + WINE_JOYSTICK_MAX_AXES + WINE_JOYSTICK_MAX_POVS], df->dwObjSize); newDevice->buttons[i] = 0x80 | newDevice->numButtons; df->rgodf[idx ].pguid = &GUID_Button; df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numButtons++) | DIDFT_PSHBUTTON; } df->dwNumObjs = idx; fake_current_js_state(newDevice); newDevice->base.data_format.wine_df = df; IDirectInput_AddRef((LPDIRECTINPUTDEVICE8A)newDevice->base.dinput); return newDevice; failed: if (df) HeapFree(GetProcessHeap(), 0, df->rgodf); HeapFree(GetProcessHeap(), 0, df); HeapFree(GetProcessHeap(), 0, newDevice); return NULL; }
static void *dsound_init(const char *device, unsigned rate, unsigned latency) { WAVEFORMATEX wfx = {0}; DSBUFFERDESC bufdesc = {0}; struct dsound_dev dev = {0}; dsound_t *ds = (dsound_t*)calloc(1, sizeof(*ds)); if (!ds) goto error; InitializeCriticalSection(&ds->crit); if (device) dev.device = strtoul(device, NULL, 0); RARCH_LOG("DirectSound devices:\n"); DirectSoundEnumerate(enumerate_cb, &dev); if (DirectSoundCreate(dev.guid, &ds->ds, NULL) != DS_OK) goto error; if (IDirectSound_SetCooperativeLevel(ds->ds, GetDesktopWindow(), DSSCL_PRIORITY) != DS_OK) goto error; wfx.wFormatTag = WAVE_FORMAT_PCM; wfx.nChannels = 2; wfx.nSamplesPerSec = rate; wfx.wBitsPerSample = 16; wfx.nBlockAlign = 2 * sizeof(int16_t); wfx.nAvgBytesPerSec = rate * 2 * sizeof(int16_t); ds->buffer_size = (latency * wfx.nAvgBytesPerSec) / 1000; ds->buffer_size /= CHUNK_SIZE; ds->buffer_size *= CHUNK_SIZE; if (ds->buffer_size < 4 * CHUNK_SIZE) ds->buffer_size = 4 * CHUNK_SIZE; RARCH_LOG("[DirectSound]: Setting buffer size of %u bytes\n", ds->buffer_size); RARCH_LOG("[DirectSound]: Latency = %u ms\n", (unsigned)((1000 * ds->buffer_size) / wfx.nAvgBytesPerSec)); bufdesc.dwSize = sizeof(DSBUFFERDESC); bufdesc.dwFlags = DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_GLOBALFOCUS; bufdesc.dwBufferBytes = ds->buffer_size; bufdesc.lpwfxFormat = &wfx; ds->event = CreateEvent(NULL, false, false, NULL); if (!ds->event) goto error; ds->buffer = fifo_new(4 * 1024); if (!ds->buffer) goto error; if (IDirectSound_CreateSoundBuffer(ds->ds, &bufdesc, &ds->dsb, 0) != DS_OK) goto error; IDirectSoundBuffer_SetCurrentPosition(ds->dsb, 0); dsound_clear_buffer(ds); if (IDirectSoundBuffer_Play(ds->dsb, 0, 0, DSBPLAY_LOOPING) != DS_OK) goto error; if (!dsound_start_thread(ds)) goto error; return ds; error: RARCH_ERR("[DirectSound] Error occured in init.\n"); dsound_free(ds); return NULL; }