/* 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;
}