char *BatchLink( char *name )
{
if( name == NULL ) name = DEFAULT_NAME;
SemReadUp = OpenSemaphore( SEMAPHORE_ALL_ACCESS, FALSE, READUP_NAME );
SemReadDone = OpenSemaphore( SEMAPHORE_ALL_ACCESS, FALSE, READDONE_NAME );
SemWritten = OpenSemaphore( SEMAPHORE_ALL_ACCESS, FALSE, WRITTEN_NAME );
MemHdl = OpenFileMapping( FILE_MAP_WRITE, FALSE, SHARED_MEM_NAME );
if( MemHdl == NULL || SemReadUp == NULL || SemWritten == NULL ) {
return( "can not connect to batcher spawn server" );
}
SharedMem = MapViewOfFile( MemHdl, FILE_MAP_WRITE, 0, 0, 0 );
return( NULL );
}
bool SockPool::Create(CString user)
{
Wsemaphore = CreateSemaphore(NULL, 1, 100, user + _T("NetProtocolWsemaphore"));//创建信号量P
Rsemaphore = CreateSemaphore(NULL, 0, 100, user + _T("NetProtocolRsemaphore"));//创建信号量C
Dsemaphore = CreateSemaphore(NULL, 0, 100, user + _T("NetProtocolDsemaphore"));//创建信号量S
MFile = CreateFileMapping(HANDLE(0xFFFFFFFF), NULL, PAGE_READWRITE, 0, sizeof(regstruct), user + _T("NetProtocolListen"));///<创建注册文件
//if (MFile == NULL)
//AfxMessageBox(user + _T("NetProtocolListen") + _T(" failed"));
//AfxMessageBox(user + _T("NetProtocolListen") + _T(" success"));
SH = OpenProcess(PROCESS_ALL_ACCESS, FALSE, _getpid());///<获取本机IP
CString soc;
int len = user.GetLength();
soc = user.Mid(len - 6, len);
if (soc.Compare(_T("server"))==0){
HANDLE Success = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, user + _T("NetProtocolCreate"));
if (Success == NULL){
AfxMessageBox(_T("参数传递失败!"));
exit(0);
return false;
}
ReleaseSemaphore(Success, 1, NULL);
}
preg = (regstruct *)MapViewOfFile(MFile, FILE_MAP_WRITE, 0, 0, sizeof(regstruct)); ///<映射注册文件
CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)NewConnThread, (LPVOID) this, NULL, NULL);
return true;
}
FWindowsPlatformProcess::FSemaphore * FWindowsPlatformProcess::NewInterprocessSynchObject(const FString & Name, bool bCreate, uint32 MaxLocks)
{
HANDLE Semaphore = NULL;
if (bCreate)
{
Semaphore = CreateSemaphore(NULL, MaxLocks, MaxLocks, *Name);
if (NULL == Semaphore)
{
DWORD ErrNo = GetLastError();
UE_LOG(LogHAL, Warning, TEXT("CreateSemaphore(Attrs=NULL, InitialValue=%d, MaxValue=%d, Name='%s') failed with LastError = %d"),
MaxLocks, MaxLocks,
*Name,
ErrNo);
return NULL;
}
}
else
{
DWORD AccessRights = SYNCHRONIZE | SEMAPHORE_MODIFY_STATE;
Semaphore = OpenSemaphore(AccessRights, false, *Name);
if (NULL == Semaphore)
{
DWORD ErrNo = GetLastError();
UE_LOG(LogHAL, Warning, TEXT("OpenSemaphore(AccessRights=0x%08x, bInherit=false, Name='%s') failed with LastError = %d"),
AccessRights,
*Name,
ErrNo);
return NULL;
}
}
check(Semaphore);
return new FWindowsSemaphore(Name, Semaphore);
}
/**
* @author ACM2012
* @note 监听线程注册，若有线程注册，创建读写队列并初始化，创建线程对队列进行读写
*/
void SockPool::Connect()
{
while (state){
WaitForSingleObject(Dsemaphore, INFINITE);//等待应用程序请求连接
PM pReadQueue, pWriteQueue;
HANDLE CH,ReadQueue, WriteQueue;
HANDLE CDestory, SDestory;
struct Para rPara, wPara;
AllocResource(preg->SockMark);///<为套接字分配资源
ReadQueue = OpenFileMapping(FILE_MAP_WRITE, FALSE, preg->WriteQueueName);
InitalReadQueue(ReadQueue,pReadQueue,CH);///<初始化读队列
CDestory = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, preg->CDestoryName);
WriteQueue = CreateFileMapping(HANDLE(0xFFFFFFFF), NULL, PAGE_READWRITE, 0, sizeof(Manager), preg->ReadQueueName);
InitalWriteQueue(WriteQueue, pWriteQueue);///<初始化写队列
SDestory = CreateSemaphore(NULL, 0, 100, preg->SDestoryName);
InitalThreadPara(rPara, CH, ReadQueue, pReadQueue, preg->SockMark,CDestory);
CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)NewReadThread, (LPVOID)&rPara, NULL, NULL);
InitalThreadPara(wPara, CH, WriteQueue, pWriteQueue, preg->SockMark,SDestory);
CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)NewWriteThread, (LPVOID)&wPara, NULL, NULL);
ReleaseSemaphore(Rsemaphore, 1, NULL);///<释放读信号量
sockconnum++;
//AfxMessageBox(preg->CDestoryName);
//AfxMessageBox(preg->SDestoryName);
//AfxMessageBox(preg->ReadQueueName);
//AfxMessageBox(preg->WriteQueueName);
CString pid;
pid.Format(_T("%d"), preg->SockMark);
//AfxMessageBox(pid);
}
}
THREAD_RETURN WINAPI bgThread4SemTest( LPVOID dum )
{ unsigned long ret;
double tEnd;
HANDLE hh;
MSEmul_UseSharedMemory(true);
hh = OpenSemaphore( DELETE|SYNCHRONIZE|SEMAPHORE_MODIFY_STATE, false, (char*)"cseSem");
if( hh ){
#if defined(__windows__)
fprintf( stderr, "##%lx bgThread4SemTest starting to wait for semaphore (0x%p) release at t=%g\n",
GetCurrentThreadId(), hh, HRTime_Time() - tStart );
#else
fprintf( stderr, "##%lx bgThread4SemTest starting to wait for semaphore (0x%p,%s,%p) release at t=%g\n",
GetCurrentThreadId(), hh, hh->d.s.name, hh->d.s.sem, HRTime_Time() - tStart );
#endif
ret = WaitForSingleObject( hh, INFINITE ); tEnd = HRTime_Time();
fprintf( stderr, "##%lx WaitForSingleObject( hh, INFINITE ) = %lu at t=%g; sleep(1ms) and ReleaseSemaphore(hh,1,NULL)\n",
GetCurrentThreadId(), ret, tEnd - tStart );
Sleep(1);
fprintf( stderr, "##%lx t=%g ReleaseSemaphore(hh,1,NULL) = %d\n",
GetCurrentThreadId(), HRTime_Time() - tStart, ReleaseSemaphore(hh, 1, NULL) );
CloseHandle(hh);
}
else{
fprintf( stderr, "##%lx bgThread4SemTest() couldn't obtain semaphore '%s', will exit\n", GetCurrentThreadId(), "cseSem" );
}
return (THREAD_RETURN)3;
}
BOOL APIENTRY DllMain( HINSTANCE hModule,
DWORD ul_reason_for_call,
LPVOID /*lpReserved*/
)
{
hMod = hModule;
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
hSem = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE,
"WinPenguins-DeskPaintSem");
if (hSem == NULL) {
hSem = CreateSemaphore(NULL, 1, 1,
"WinPenguins-DeskPaintSem");
assert(hSem != NULL);
}
break;
case DLL_PROCESS_DETACH:
DeleteObject(hSem);
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
break;
}
return TRUE;
}
int main(int argc, char **argv)
{
HANDLE ThreadH[2];
int iloop;
gsem = CreateSemaphore(NULL, 1, 1, "TestSem");
if (gsem == NULL)
{
printf("Error %d\n", GetLastError());
return 1;
}
if (OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, "TestSem") == NULL)
{
printf("Semaphore Open Error %d\n", GetLastError());
return 1;
}
for (iloop = 0; iloop < MAX_THREAD; iloop++)
{
printf("Create Thread %d\n", iloop);
ThreadH[iloop] = CreateThread(NULL, 0, myThread, (void *)&iloop, 0, NULL);
Sleep(500);
}
WaitForMultipleObjects(MAX_THREAD, ThreadH, TRUE, INFINITE);
CloseHandle(gsem);
return 0;
}
PRSem *_PR_MD_OPEN_SEMAPHORE(
const char *osname, PRIntn flags, PRIntn mode, PRUintn value)
{
PRSem *sem;
SECURITY_ATTRIBUTES sa;
LPSECURITY_ATTRIBUTES lpSA = NULL;
PSECURITY_DESCRIPTOR pSD = NULL;
PACL pACL = NULL;
sem = PR_NEW(PRSem);
if (sem == NULL) {
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return NULL;
}
if (flags & PR_SEM_CREATE) {
if (_PR_NT_MakeSecurityDescriptorACL(mode, semAccessTable,
&pSD, &pACL) == PR_SUCCESS) {
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = pSD;
sa.bInheritHandle = FALSE;
lpSA = &sa;
}
sem->sem = CreateSemaphore(lpSA, value, 0x7fffffff, osname);
if (lpSA != NULL) {
_PR_NT_FreeSecurityDescriptorACL(pSD, pACL);
}
if (sem->sem == NULL) {
_PR_MD_MAP_DEFAULT_ERROR(GetLastError());
PR_DELETE(sem);
return NULL;
}
if ((flags & PR_SEM_EXCL) && (GetLastError() == ERROR_ALREADY_EXISTS)) {
PR_SetError(PR_FILE_EXISTS_ERROR, ERROR_ALREADY_EXISTS);
CloseHandle(sem->sem);
PR_DELETE(sem);
return NULL;
}
} else {
sem->sem = OpenSemaphore(
SEMAPHORE_MODIFY_STATE|SYNCHRONIZE, FALSE, osname);
if (sem->sem == NULL) {
DWORD err = GetLastError();
/*
* If we open a nonexistent named semaphore, NT
* returns ERROR_FILE_NOT_FOUND, while Win95
* returns ERROR_INVALID_NAME
*/
if (err == ERROR_INVALID_NAME) {
PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
} else {
_PR_MD_MAP_DEFAULT_ERROR(GetLastError());
}
PR_DELETE(sem);
return NULL;
}
}
return sem;
}
//---------------------------------------------------------------------------
void __fastcall TThdSend::NewTask(TQueItf *QueItf)
{
FQueSend->push(QueItf);
HANDLE mx=OpenSemaphore(SEMAPHORE_ALL_ACCESS,true,TRjlFunc::ThrSendMutex.c_str());
ReleaseSemaphore(mx,1,NULL);
CloseHandle(mx);
}
server::server(char *path)
{
ZeroMemory(&StartupInfo, sizeof(StartupInfo));
StartupInfo.cb = sizeof(StartupInfo);
ZeroMemory(&ChildProcessInfo, sizeof(ChildProcessInfo));
size_of_buffer = sizeof(buffer);
Semaphore_client[0] = CreateSemaphore(NULL, 0, 1, "SEMAPHORE_CLIENT_START_PRINT");
Semaphore_client[1] = CreateSemaphore(NULL, 0, 1, "SEMAPHORE_CLIENT_END_PRINT");
Semaphore_client[2] = CreateSemaphore(NULL, 0, 1, "SEMAPHORE_CLIENT_PRINT_EXIT");
Semaphore_client[3] = CreateSemaphore(NULL, 0, 1, "SEMAPHORE_CLIENT_SEND");
Semaphore_client[4] = CreateSemaphore(NULL, 0, 1, "SEMAPHORE_CLIENT_SEND_EXIT");
cout << "Client started..." << endl << endl;
hNamedPipe = CreateNamedPipe("\\\\.\\pipe\\Pipe",
PIPE_ACCESS_DUPLEX,
PIPE_TYPE_MESSAGE | PIPE_WAIT, // Synchronous messaging
PIPE_UNLIMITED_INSTANCES, // The maximum numberber of channels copies
0, // The size of the output bufferer
0,
INFINITE,
(LPSECURITY_ATTRIBUTES)NULL // The default protection
);
CreateProcess(path, " 2", NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &StartupInfo, &ChildProcessInfo);
// Check
if (hNamedPipe == INVALID_HANDLE_VALUE)
{
cout << "Creation of the named pipe failed.\n";
}
if (!ConnectNamedPipe(hNamedPipe, (LPOVERLAPPED)NULL))
{
cout << "Connection fail.\n";
}
Semaphore_server[0] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "SEMAPHORE_SERVER_START_PRINT");
Semaphore_server[1] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "SEMAPHORE_SERVER_END_PRINT");
Semaphore_server[2] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "SEMAPHORE_SERVER_PRINT_EXIT");
Semaphore_server[3] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "SEMAPHORE_SERVER_SEND");
Semaphore_server[4] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE,"SEMAPHORE_SERVER_SEND_EXIT");
}
rt_private int get_pipe_events (char* id, HANDLE* p_event_r, HANDLE* p_event_w)
{
HANDLE event_r, event_w;
CHAR event_str [128];
unsigned int debuggee_pid;
DWORD count;
/* debuggee/application date */
debuggee_pid = (unsigned int) GetCurrentProcessId();
/* Get Semaphore */
event_r = NULL;
/* NT 3.51 is really fast - at this point we know we were launched by ebench.
lets wait for it to catch up with us */
sprintf (event_str, "eif_event_w%x_%s", debuggee_pid, id);
for (count = 0; (event_r == NULL) && (count < 10); count++) {
event_r = OpenSemaphore (SEMAPHORE_ALL_ACCESS, FALSE, event_str);
if (event_r == NULL)
Sleep(500);
}
if (event_r == NULL) {
#ifdef USE_ADD_LOG
add_log(12, "not started from wrapper - no read event %d", GetLastError());
#endif
return -1;
}
sprintf (event_str, "eif_event_r%x_%s", debuggee_pid, id);
event_w = OpenSemaphore (SEMAPHORE_ALL_ACCESS, FALSE, event_str);
if (event_w == NULL) {
#ifdef USE_ADD_LOG
add_log(12, "not started from wrapper - no write event");
#endif
return -1;
}
*p_event_r = event_r;
*p_event_w = event_w;
return 0;
}
void server::server_print()
{
HANDLE Semaphores[3];
Semaphore_server[0] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "SEMAPHORE_SERVER_START_PRINT");
Semaphore_server[1] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "SEMAPHORE_SERVER_END_PRINT");
Semaphore_server[2] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "SEMAPHORE_SERVER_PRINT_EXIT");
Semaphore_server[3] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "SEMAPHORE_SERVER_SEND");
Semaphore_server[4] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "SEMAPHORE_SERVER_SEND_EXIT");
Semaphores[0] = Semaphore_server[0]; //SEMAPHORE_SERVER_START_PRINT
Semaphores[1] = Semaphore_server[1]; //SEMAPHORE_SERVER_END_PRINT
Semaphores[2] = Semaphore_server[2]; //SEMAPHORE_SERVER_PRINT_EXIT
while (1)
{
flag = TRUE;
DWORD numberber_of_bytes_read;
print_message.clear();
int index = WaitForMultipleObjects(3, Semaphores, FALSE, INFINITE) - WAIT_OBJECT_0;
if (index == 2) break;
int numberber_of_blocks;
int size;
if (!ReadFile(hNamedPipe, &numberber_of_blocks, sizeof(numberber_of_blocks), &numberber_of_bytes_read, NULL)) break;
if (!ReadFile(hNamedPipe, &size, sizeof(size), &numberber_of_bytes_read, NULL)) break;
for (int i = 0; i < numberber_of_blocks; i++)
{
flag = ReadFile(hNamedPipe, buffer, size_of_buffer, &numberber_of_bytes_read, NULL);
if (!flag) break;
print_message.append(buffer, size_of_buffer);
}
if (!flag) break;
print_message.resize(size);
print_server();
for (int i = 0; i < size; i++)
{
cout << print_message[i];
Sleep(SLEEP_TIME);
}
cout << endl;
ReleaseSemaphore(Semaphore_server[1], 1, NULL); //SEMAPHORE_SERVER_END_PRINT
}
}
gpointer
ves_icall_System_Threading_Semaphore_OpenSemaphore_internal (MonoString *name, gint32 rights, gint32 *error)
{
HANDLE sem;
sem = OpenSemaphore (rights, FALSE, mono_string_chars (name));
*error = GetLastError ();
return sem;
}
client::client() {
size_of_buff = sizeof(buff);
Semaphore_client_start_print = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, GetWC("SEMAPHORE_CLIENT_START_PRINT"));
Semaphore_client_end_print = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, GetWC("SEMAPHORE_CLIENT_END_PRINT"));
Semaphore_client_print_exit = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, GetWC("SEMAPHORE_CLIENT_PRINT_EXIT"));
Semaphore_client_send = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, GetWC("SEMAPHORE_CLIENT_SEND"));
Semaphore_client_send_exit = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, GetWC("SEMAPHORE_CLIENT_SEND_EXIT"));
Semaphore_server_start_print = CreateSemaphore(NULL, 0, 1, GetWC("SEMAPHORE_SERVER_START_PRINT"));
Semaphore_server_end_print = CreateSemaphore(NULL, 0, 1, GetWC("SEMAPHORE_SERVER_END_PRINT"));
Semaphore_server_print_exit = CreateSemaphore(NULL, 0, 1, GetWC("SEMAPHORE_SERVER_PRINT_EXIT"));
Semaphore_server_send = CreateSemaphore(NULL, 0, 1, GetWC("SEMAPHORE_SERVER_SEND"));
Semaphore_server_send_exit = CreateSemaphore(NULL, 0, 1, GetWC("SEMAPHORE_SERVER_SEND_EXIT"));
cout << "Server started..." << endl << endl;
hPipe = CreateFile(GetWC("\\\\.\\pipe\\Pipe"), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
}
static os_result
condSignal(
os_cond *cond,
long mask)
{
char name[OS_SERVICE_ENTITY_NAME_MAX];
HANDLE hQueue;
DWORD result;
long oldState;
os_result osr;
assert(cond != NULL);
osr = os_resultSuccess;
if (cond->scope == OS_SCOPE_SHARED) {
_snprintf(name, sizeof(name), "%s%s%d%d",
(os_sharedMemIsGlobal() ? OS_SERVICE_GLOBAL_NAME_PREFIX : ""),
OS_SERVICE_SEM_NAME_PREFIX,
cond->qId,
os_getShmBaseAddressFromPointer(cond));
hQueue = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, name);
if (hQueue == NULL) {
OS_DEBUG_1("condSignal", "OpenSemaphore failed %d", (int)GetLastError());
assert(0);
return os_resultFail;
}
} else {
hQueue = (HANDLE)cond->qId;
}
oldState = InterlockedOr(&cond->state, mask);
if (oldState == 0) { /* no waiters */
InterlockedAnd(&cond->state, ~mask);
return osr;
}
if (mask == BROADCAST_BIT_MASK) {
result = ReleaseSemaphore(hQueue, oldState, 0);
} else {
result = ReleaseSemaphore(hQueue, 1, 0);
}
InterlockedAnd(&cond->state, ~mask);
if (cond->scope == OS_SCOPE_SHARED) {
CloseHandle(hQueue);
}
return osr;
}
void CThreadBase::DoRunThreadL()
{
CActiveScheduler* scheduler = NULL;
scheduler = new (ELeave) CActiveScheduler;
CleanupStack::PushL(scheduler);
CActiveScheduler::Install(scheduler);
OpenSemaphore();
SetUpTestL( ThreadName() );
ThreadL();
TakeDownTest();
CloseSemaphore();
CleanupStack::PopAndDestroy(scheduler);
}
DWORD WINAPI Thread(LPVOID lp)
{
HWND hEdit = (HWND) lp;
HANDLE h = OpenSemaphore(SEMAPHORE_ALL_ACCESS, false, TEXT("{41B4DBD4-F00A-4999-BFA9-1A20D12591B1}"));
if (WaitForSingleObject(h, INFINITE) == WAIT_OBJECT_0)
{
for (int i = 0; i <= 50; i++)
{
TCHAR str[5];
wsprintf(str, TEXT("%d"), i);
Sleep(100);
SetWindowText(hEdit, str);
}
ReleaseSemaphore(h, 1, NULL);
}
CloseHandle(h);
return 1;
}
DWORD L_CONNECT_response(long source, long destination, int priority)//envia ACK
{
int ret;
HANDLE c;
if(mode == 1){printf("\nL_CONNECT_response\n");}
//abrimos el semaforo que indicara que la conexion se ha realizado
c = OpenSemaphore(SEMAPHORE_ALL_ACCESS,TRUE,"semaphoreConexion");
//creamos y enviamos la trama ACK
makeFrame(ackFrame,NULL);
//esperamos hasta que nos confirmen la conexion
ret = WaitForSingleObject(c,timeout);
//si no se ha complido el timeout significa que hemos conseguido conectarnos
if(ret != WAIT_TIMEOUT){conexionOK = 1;}
return 0;
}
HANDLE getPathSemaphore(char* path, void* sharedMemory) {
HANDLE pathSemaphore = NULL;
uint32_t hashedPath = crc32(CRC_HASHING_CONSTANT, path, strlen(path) + 1);
char* hashedPathString = Malloc(sizeof(char) * BUFFER_SIZE);
if (snprintf(hashedPathString, BUFFER_SIZE, "%u", hashedPath) < 0) {
handle_error("Error converting hash to string");
}
if ((pathSemaphore = OpenSemaphore(SEMAPHORE_FLAGS, FALSE, hashedPathString)) == NULL) {
if (GetLastError() != ERROR_FILE_NOT_FOUND) {
handle_error("Error while opening path semaphore");
} else {
pathSemaphore = CREATESemaphore(NULL, 1, 1, hashedPathString);
}
}
free(hashedPathString);
return pathSemaphore;
}
Sem::Sem(const char* const inName,
const unsigned long inCount,
const unsigned long inMaxCount)
: theSemaphoreHandle(0),
theMaxCount(inMaxCount)
{
if (theMaxCount == 0 || theMaxCount > 0x7FFFFFFF)
{
theMaxCount = 0x7FFFFFFF;
}
theSemaphoreHandle = CreateSemaphore(NULL,
inCount > theMaxCount ? theMaxCount : inCount,
theMaxCount,
inName);
if (theSemaphoreHandle == NULL)
{
DWORD rc = GetLastError();
if (rc == ERROR_ALREADY_EXISTS)
{
// semaphore is creted try to open it
theSemaphoreHandle = OpenSemaphore(SEMAPHORE_ALL_ACCESS | SYNCHRONIZE, FALSE, inName);
if (theSemaphoreHandle == 0)
{
Logger::abort("Semaphore: failed to open.");
}
}
else
{
Logger::abort("Semaphore: failed to create.");
}
}
}
bool C_IPC_SERVER::Open( char *pszServerName )
{
if( m_boInited || !IsValidServerName( pszServerName ) ) return false;
char szFirstPartOfName[ _MAX_PATH ];
strcpy( szFirstPartOfName, FrefixName() ); strcat( szFirstPartOfName, pszServerName );
char szName[ _MAX_PATH ];
//////////////////////////////////////////////
strcpy( szName, szFirstPartOfName ); strcat( szName, IPC_ADD_NAME_MAPFILE_BUFFER );
if( !C_IPC_BUFFER::Open( szName ) ) return false;
//////////////////////////////////////////////
strcpy( szName, szFirstPartOfName ); strcat( szName, IPC_ADD_NAME_BREAK );
HANDLE hBreak = OpenEvent( EVENT_ALL_ACCESS, FALSE, szName );
if( !hBreak )
{
C_IPC_BUFFER::Close();
return false;
}
//////////////////////////////////////////////
strcpy( szName, szFirstPartOfName ); strcat( szName, IPC_ADD_NAME_WAIT_BUSY );
HANDLE hWaitBusy = OpenSemaphore( SEMAPHORE_ALL_ACCESS, FALSE, szName );
if( !hWaitBusy )
{
CloseHandle( hBreak );
C_IPC_BUFFER::Close();
return false;
}
//////////////////////////////////////////////
strcpy( szName, szFirstPartOfName ); strcat( szName, IPC_ADD_NAME_CONNECT_BUSY );
HANDLE hConnectBusy = OpenSemaphore( SEMAPHORE_ALL_ACCESS, FALSE, szName );
if( !hWaitBusy )
{
CloseHandle( hWaitBusy );
CloseHandle( hBreak );
C_IPC_BUFFER::Close();
return false;
}
//////////////////////////////////////////////
strcpy( szName, szFirstPartOfName ); strcat( szName, IPC_ADD_NAME_CONNECT_NEW );
HANDLE hConnect = OpenSemaphore( SEMAPHORE_ALL_ACCESS, FALSE, szName );
if( !hConnect )
{
CloseHandle( hConnectBusy );
CloseHandle( hWaitBusy );
CloseHandle( hBreak );
C_IPC_BUFFER::Close();
return false;
}
//////////////////////////////////////////////
strcpy( szName, szFirstPartOfName ); strcat( szName, IPC_ADD_NAME_SEND );
HANDLE hSend = OpenSemaphore( SEMAPHORE_ALL_ACCESS, FALSE, szName );
if( !hSend )
{
CloseHandle( hConnect );
CloseHandle( hConnectBusy );
CloseHandle( hWaitBusy );
CloseHandle( hBreak );
C_IPC_BUFFER::Close();
return false;
}
//////////////////////////////////////////////
strcpy( szName, szFirstPartOfName ); strcat( szName, IPC_ADD_NAME_RECV );
HANDLE hRecv = OpenSemaphore( SEMAPHORE_ALL_ACCESS, FALSE, szName );
if( !hRecv )
{
CloseHandle( hSend );
CloseHandle( hConnect );
CloseHandle( hConnectBusy );
CloseHandle( hWaitBusy );
CloseHandle( hBreak );
C_IPC_BUFFER::Close();
return false;
}
//////////////////////////////////////////////
m_boInited = true;
m_hBreak = hBreak;
m_hWaitBusy = hWaitBusy;
m_hConnectBusy = hConnectBusy;
m_hConnectNew = hConnect;
m_hSend = hSend;
m_hRecv = hRecv;
return true;
}
EIF_INTEGER ipc_semaphore_open (EIF_POINTER lpName) {
return (EIF_INTEGER) OpenSemaphore (SEMAPHORE_ALL_ACCESS, TRUE, (LPCTSTR)lpName);
}
int CBD1
semctl(int semid, int semnum, int cmd, ...)
{
BOOL ret;
int iret;
DWORD dwret;
int i, j, diffsemval;
#ifndef TERMINAL_SERVICE
char semstr[16];
#else
char semstr[30];
#endif /* TERMINAL_SERVICE */
BOOL lret;
HANDLE hsem;
int piid;
DWORD procid;
va_list vlist;
union semun semarg;
LPTSTR lpszPipeName = "\\\\.\\pipe\\ipcd";
SCBUF scIn, scOut;
DWORD bytesRead;
HANDLE hIpct = NULL;
IPCT *ipct = NULL;
#ifdef TERMINAL_SERVICE
OSVERSIONINFOEX osvi;
ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
if( !GetVersionEx ((OSVERSIONINFO *) &osvi) )
{
// If OSVERSIONINFOEX doesn't work, try OSVERSIONINFO.
osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
GetVersionEx( (OSVERSIONINFO *) &osvi );
}
#endif /* TERMINAL_SERVICE */
// StartIPCD();
if (semid<0 || semid>=MAXNOOFIPC)
{
errno=EINVAL;
return -1;
}
if (GetIPCT(&hIpct, &ipct)<0)
{
errno=EFAULT;
return -1;
}
if (ipct->semt[semid].key<0)
{
procid=GetCurrentProcessId();
piid=FindPINFO(OPT_SEM, procid, ipct);
if (piid>=0)
{
for (i=0; i<MAXNSEM; i++)
ipct->pseminfo[piid].semadj[semid][i]=0;
ipct->pseminfo[piid].semid[semid]=0;
InitPINFO(OPT_SEM, piid, ipct);
}
errno=EINVAL;
FreeIPCT(hIpct, ipct);
return -1;
}
if (semnum<0 || semnum>ipct->semt[semid].semds.sem_nsems)
{
errno=EINVAL;
FreeIPCT(hIpct, ipct);
return -1;
}
va_start(vlist, cmd);
semarg=va_arg(vlist, union semun);
va_end(vlist);
switch (cmd)
{
case IPC_STAT:
if (semarg.buf == NULL)
{
FreeIPCT(hIpct, ipct);
return -1;
}
memcpy((PSTR)semarg.buf, (PSTR)&ipct->semt[semid].semds,
sizeof(ipct->semt[semid].semds));
FreeIPCT(hIpct, ipct);
return 0;
case IPC_RMID:
scIn.cmd=SNO_SEMCTL;
scIn.data=semid;
lret = CallNamedPipe(lpszPipeName,
(char *)&scIn, sizeof(scIn),
(char *)&scOut, sizeof(scOut),
&bytesRead, NMPWAIT_WAIT_FOREVER);
if (lret==FALSE)
{
errno=GetLastError();
FreeIPCT(hIpct, ipct);
return -1;
}
if (scOut.cmd!=SNO_OK)
{
errno=scOut.data;
FreeIPCT(hIpct, ipct);
return -1;
}
if( InitSEMT(semid, ipct) < 0 )
return -1;
for (i=0; i<MAXNOOFIPC; i++)
{
for (j=0; j<MAXNSEM; j++)
ipct->pseminfo[i].semadj[semid][j]=0;
ipct->pseminfo[i].semid[semid]=0;
InitPINFO(OPT_SEM, i, ipct);
}
FreeIPCT(hIpct, ipct);
return 0;
case GETVAL:
iret=ipct->semb[semid][semnum].semval;
FreeIPCT(hIpct, ipct);
return iret;
case SETVAL:
if (semarg.val < 0)
{
errno = EINVAL;
FreeIPCT(hIpct, ipct);
return -1;
}
diffsemval=semarg.val-ipct->semb[semid][semnum].semval;
#ifndef TERMINAL_SERVICE
MakeSemstr(semstr, semnum, semid, ipct->semt[semid].key);
#else
if( osvi.dwMajorVersion >= 5 ) /* Windows 2000 */
MakeGlobalSemstr(semstr, semnum, semid, ipct->semt[semid].key);
else
MakeSemstr(semstr, semnum, semid, ipct->semt[semid].key);
#endif /* TERMINAL_SERVICE */
hsem=OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, semstr);
if (hsem==NULL)
{
errno=GetLastError();
FreeIPCT(hIpct, ipct);
return -1;
}
for (i=0; i<abs(diffsemval); i++)
{
if (diffsemval>0)
{
ret=ReleaseSemaphore(hsem, diffsemval, NULL);
if (ret==FALSE)
{
errno=GetLastError();
CloseHandle(hsem);
FreeIPCT(hIpct, ipct);
return -1;
}
break; /*2000.4.19*/
}
else if (diffsemval<0)
{
/********************
do
{
dwret=MsgWaitForMultipleObjects(1, &hsem,
FALSE, INFINITE,
QS_SENDMESSAGE|QS_POSTMESSAGE|QS_TIMER);
********************/
dwret=WaitForSingleObject(hsem, INFINITE);
switch (dwret)
{
/********************
case WAIT_OBJECT_0 + 1 :
if (l_peekmessage()<0)
{
CloseHandle(hsem);
FreeIPCT(hIpct, ipct);
return -1;
}
break;
********************/
case WAIT_OBJECT_0 :
break;
case WAIT_TIMEOUT :
case WAIT_FAILED :
errno=GetLastError();
default :
CloseHandle(hsem);
FreeIPCT(hIpct, ipct);
return -1;
}
/*************
} while (dwret==(WAIT_OBJECT_0 + 1));
*************/
}
}
CloseHandle(hsem);
ipct->semb[semid][semnum].semval=semarg.val;
for (i=0; i<MAXNOOFIPC; i++)
ipct->pseminfo[i].semadj[semid][semnum]=0;
FreeIPCT(hIpct, ipct);
return 0;
case GETPID:
iret=ipct->semb[semid][semnum].sempid;
FreeIPCT(hIpct, ipct);
return iret;
case GETNCNT:
iret=ipct->semb[semid][semnum].semncnt;
FreeIPCT(hIpct, ipct);
return iret;
case GETZCNT:
iret=ipct->semb[semid][semnum].semzcnt;
FreeIPCT(hIpct, ipct);
return iret;
case GETALL:
if (semarg.array == NULL)
{
errno=EINVAL;
FreeIPCT(hIpct, ipct);
return -1;
}
for (i=0; i<ipct->semt[semid].semds.sem_nsems; i++)
semarg.array[i]=(short)ipct->semb[semid][i].semval;
FreeIPCT(hIpct, ipct);
return 0;
case SETALL:
/* #####PENDING */
FreeIPCT(hIpct, ipct);
return 0;
default:
FreeIPCT(hIpct, ipct);
return -1;
}
}
//---------------------------------------------------------------------------
void __fastcall TThdSend::Execute()
{
double p;
int n,un;
bool undoall = false;
TBourse bourse;
HANDLE hMutex=OpenSemaphore(SEMAPHORE_ALL_ACCESS ,true,TRjlFunc::ThrSendMutex.c_str());
TQueItf *q = NULL;
while(true) {
Sleep(500);
WaitForSingleObject(hMutex,INFINITE);
GetFromQue(); //读取队列
for(int i=0;i<FLocalDtl->Count;i++){ //扫描本地列表
double curp = 0;
TLocalDtl *l = ((TLocalDtl*)FLocalDtl->Items[i]);
TItfTrd *it = (TItfTrd *)(FItfTrdLst->Items[l->ItfTrdPos]);
if(l->SecuID.SubString(1,1).UpperCase() == "S") bourse = bsSZ;
else bourse = bsSH;
//10秒查询一次成交情况
//////////////////////
undoall = false;
if((time(NULL) - l->QryTime)>10 || Terminated){
l->QryTime = time(NULL);
for(int j=0;j<l->TrdInfo->Count;j++){
TTrdInfo *t = (TTrdInfo *)(l->TrdInfo->Items[j]);
String ContractID = t->ContractID;
n = 0;
if(it->QryDetail(ContractID,bourse,p,n,un)<=-1) {continue;}//成交查询 ,出错提示不需要
curp = n*p;
if(t->HasUndo){ //如果是已经执行撤单的单子
if(un!=0 || n>=t->Num){ //如果撤单成功，或者单子已经全部成交
l->LastPrc = curp + l->LastPrc;
l->LastVol += n;
if(n - t->CurVol>0){
FRepTime = Time();
FRepBuy = true;
FRepSecuID = l->SecuID;
FRepVol = n - t->CurVol;
FRepPrice = p;
// Synchronize(TrdRep);
}
l->CurVol -= t->CurVol;
delete t;
l->TrdInfo->Delete(j);
j--;
}
else{ //还未完成撤单
}
}
else if(n - t->CurVol > 0){ //加到成交回报
FRepTime = Time();
FRepBuy = false;
FRepSecuID = l->SecuID;
FRepVol = n - t->CurVol;
FRepPrice = p;
// Synchronize(TrdRep);
l->CurVol += n - t->CurVol; //累计该股票所有单子的成交量
t->CurVol = n; //保存成交量
}
if(l->CurVol + l->LastVol>=l->TotalVol) undoall = true; //表示该股票可以全部撤单
}
q = (TQueItf*)(FInSend->Items[l->Locate]);
if(q != NULL){
q->CurVol = l->CurVol + l->LastVol; //向指针中置当前量
if(l->CurVol + l->LastVol>0)
q->AvgPrice = (curp + l->LastPrc)/(l->CurVol + l->LastVol);//向指针中置当前总成交金额
}
}
if(undoall){ //对该股票执行全部撤单
UndoAllTrd(l);
if(q!=NULL) q->State = tsFinish;
FErrMsg = l->SecuID+" 派发完成,派发总量为："+IntToStr(l->CurVol + l->LastVol); //派发完成提示
Synchronize(ShowErr);
DeleteTrd(i); //从本地列表中删除
i--;
if(!Terminated) continue;
}
//按时撤单
////////////////////////
// if((time(NULL) - l->UndoTime) > l->Scheme->TrdCancel*60){
// l->UndoTime = time(NULL);
// l->LastTime = time(NULL);
for(int j=0;j<l->TrdInfo->Count;j++){
TTrdInfo *t = (TTrdInfo *)(l->TrdInfo->Items[j]);
String ContractID = t->ContractID;
bool canCancel = false;
if(l->Scheme->TrdCancelTime != 0){
if((time(NULL) - t->DoTime) > l->Scheme->TrdCancelTime) canCancel=true; //按时间撤单
}
else{
double zxj = StrToFloat(TRjlSysVar()()->DatDyn->GetField(TRjlSysVar()()->DatDyn->GetLoc(l->SecuID),dtCp))/1000;
if(zxj<t->Prc - t->Prc*l->Scheme->TrdCancelPrc/100) canCancel=true; //价偏离撤单
}
if(!canCancel) continue;
if(it->Undo(ContractID,bourse)<-1) {
FErrMsg = "异常错误，按时撤单未成功,合同号：" + ContractID; //撤单未成功
Synchronize(ShowErr);
}
else{
t->HasUndo = true;
}
}
// l->CurVol = 0;
// if(!Terminated) continue;
// }
if(!Terminated){
//按时下单
//////////////////////
if(l->Scheme->TrdSec<0){
if(l->TrdX==TRjlFunc::StrToDouble(TRjlSysVar()()->DatDyn->GetField(TRjlSysVar()()->DatDyn->GetLoc(l->SecuID),dtCp))) continue;
l->TrdX=TRjlFunc::StrToDouble(TRjlSysVar()()->DatDyn->GetField(TRjlSysVar()()->DatDyn->GetLoc(l->SecuID),dtCp));
}
else if(l->Scheme->TrdSec>0){ //按指定时间下单
if((time(NULL) - l->LastTime)<l->Scheme->TrdSec) continue;
l->LastTime = time(NULL);
}
else{
if((time(NULL) - l->LastTime)<l->TrdX) continue; //取随机时间下单
l->TrdX = random(l->Scheme->Sec2-l->Scheme->Sec1)+l->Scheme->Sec1;
}
double prc=0;
long vol=0,dv=0;
String ContractID="";
if(GetInfo(l->SecuID) <= -1){
FErrMsg = "未获得"+ l->SecuID +"的盘口数据";
Synchronize(ShowErr);
continue;
}
if(l->Scheme->ConsignPrice==0)
prc = FZXJ + l->Scheme->FloatMny;
else{
prc = FPrice[l->Scheme->ConsignPrice-1] + l->Scheme->FloatMny;
}
if(l->Scheme->VolPercent==0){
vol = random(l->Scheme->Vol2 - l->Scheme->Vol1) + l->Scheme->Vol1;
}
else{
for(int i=0;i<l->Scheme->VolScheme;i++) vol += FVolum[i];
vol = vol*l->Scheme->VolPercent/100;
}
vol = vol/100<=0?100:vol/100*100;
for(int j=0;j<l->TrdInfo->Count;j++) dv += ((TTrdInfo*)(l->TrdInfo->Items[j]))->Num;
if(dv+l->LastVol>=l->TotalVol) continue; //如果下单的总量已经达到吸纳的总量，就不用再下单了
if(vol+dv+l->LastVol>l->TotalVol) vol = l->TotalVol - dv - l->LastVol;
int done = -1;
int balance,avalid,bf,sf;
if(it->QryStock(l->SecuID,balance,avalid,bf,sf)<=-1){
FErrMsg = " 股份查询失败，"+l->SecuID + "价格"+FloatToStr(prc) + " 派发下单未成功";
Synchronize(ShowErr);
continue;
}
else{
if(vol>balance){
vol = balance;
FErrMsg = " 派发股份不足";
Synchronize(ShowErr);
continue;
}
}
if((l->PriceLimit==0 && l->VolLimit == 0) || (prc>l->PriceLimit && vol<l->VolLimit))
done = it->Sell(l->SecuID,prc,vol,ContractID);
if(done <= -1) {
FErrMsg = "股票"+l->SecuID + "价格"+FloatToStr(prc) + " 吸纳下单未成功";
Synchronize(ShowErr);
continue;
}
else AddTrd(l,ContractID,vol,prc);
}
} //end for
if(FLocalDtl->Count>0) ReleaseSemaphore(hMutex,1,NULL);
if(Terminated){ //线程中断全撤单
for(int i=0;i<FLocalDtl->Count;i++){
TLocalDtl *l = ((TLocalDtl*)FLocalDtl->Items[i]);
UndoAllTrd(l);
}
break;
}
}
CloseHandle(hMutex);
}
int main(int argc, char *argv[])
{
#ifdef _WIN32
DWORD numRead;
DWORD numToWrite;
if (argc != 2)
{
HANDLE namedPipe = CreateNamedPipe(TEXT("\\\\.\\pipe\\Pipe"),
PIPE_ACCESS_DUPLEX,
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
PIPE_UNLIMITED_INSTANCES,
1024, 1024,
NMPWAIT_USE_DEFAULT_WAIT,
NULL);
if (namedPipe == INVALID_HANDLE_VALUE)
{
cout << "Can't create pipe. Error. Press any key to exit " << GetLastError();
_getch();
exit(0);
}
HANDLE serverSemaphore = CreateSemaphore(NULL, 0, 1, TEXT("serverSemaphore"));
HANDLE clientSemaphore = CreateSemaphore(NULL, 0, 1, TEXT("clientSemaphore"));
MyProcess *clientProcess = new MyProcess(argv[0]);
ConnectNamedPipe(namedPipe, NULL);
WaitForSingleObject(serverSemaphore, INFINITE);
char *buffer = NULL;
buffer = (char *)malloc(sizeof(char) * 1024);
printf("Server process\n");
if (!WriteFile(namedPipe, "Ready", 1024, &numToWrite, NULL))
return 0;
while (1)
{
ReleaseSemaphore(clientSemaphore, 1, NULL);
WaitForSingleObject(serverSemaphore, INFINITE);
if (ReadFile(namedPipe, buffer, 1024, &numRead, NULL))
printf("Client message: %s", buffer);
if (!strcmp(buffer, "exit"))
{
CloseHandle(namedPipe);
CloseHandle(serverSemaphore);
free(buffer);
return 0;
}
printf("\nInput message to client: ");
fflush(stdin);
gets_s(buffer, 1024);
if (!WriteFile(namedPipe, buffer, 1024, &numToWrite, NULL))
break;
ReleaseSemaphore(clientSemaphore, 1, NULL);
if (!strcmp(buffer, "exit"))
{
CloseHandle(namedPipe);
CloseHandle(serverSemaphore);
free(buffer);
return 0;
}
}
return 0;
}
else
{
HANDLE serverSemaphore = OpenSemaphore(EVENT_ALL_ACCESS, FALSE, TEXT("serverSemaphore"));
HANDLE clientSemaphore = OpenSemaphore(EVENT_ALL_ACCESS, FALSE, TEXT("clientSemaphore"));
HANDLE namedPipe = CreateFile(TEXT("\\\\.\\pipe\\Pipe"),
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
0,
NULL);
if (namedPipe == INVALID_HANDLE_VALUE)
{
printf("Can't create pipe. Error. Press any key to exit", GetLastError());
_getch();
exit(0);
}
ReleaseSemaphore(serverSemaphore, 1, NULL);
char *buffer = NULL;
buffer = (char *)malloc(sizeof(char) * 1024);
printf("Client process\n");
while (1)
{
WaitForSingleObject(clientSemaphore, INFINITE);
if (ReadFile(namedPipe, buffer, 1024, &numRead, NULL))
{
if (!strcmp(buffer, "exit"))
{
CloseHandle(clientSemaphore);
free(buffer);
return 0;
}
printf("Server message: %s", buffer);
char input[1024] = { '\0' };
cout << "\nInput message to server: ";
fflush(stdin);
gets_s(input, 1024);
if (!WriteFile(namedPipe, input, 1024, &numToWrite, NULL))
break;
if (!strcmp(input, "exit"))
{
ReleaseSemaphore(serverSemaphore, 1, NULL);
CloseHandle(clientSemaphore);
free(buffer);
return 0;
}
}
ReleaseSemaphore(serverSemaphore, 1, NULL);
}
return 0;
}
#elif __linux__
pid_t pid;
key_t key = ftok("/home/", 0);
struct sembuf serverSemaphore;
struct sembuf clientSemaphore;
int semaphoreId;
int sharedMemoryId;
char *segmentPtr;
if (argc != 2)
{
switch (pid = fork())
{
case -1:
printf("Can't fork process %d\n", pid);
break;
case 0:
execlp("gnome-terminal", "gnome-terminal", "-x", argv[0], "1", NULL);
default:
if ((sharedMemoryId = shmget(key, 1024, IPC_CREAT | IPC_EXCL | 0660)) == -1)
{
if ((sharedMemoryId = shmget(key, 1024, 0)) == -1)
{
printf("error\n");
exit(1);
}
}
if ((segmentPtr = (char*)shmat(sharedMemoryId, NULL, 0)) == (char*)(-1))
{
printf("Can't attach shared memory\n");
exit(1);
}
semaphoreId = semget(key, 1, 0666 | IPC_CREAT);
if (semaphoreId < 0)
{
printf("Can't get semaphore\n");
exit(EXIT_FAILURE);
}
if (semctl(semaphoreId, 0, SETVAL, (int)0) < 0)
{
printf("Can't initialize semaphore\n");
exit(EXIT_FAILURE);
}
serverSemaphore.sem_num = 0;
serverSemaphore.sem_op = 0;
serverSemaphore.sem_flg = 0;
printf("Server process: ");
while (1) {
char *message = NULL;
message = (char*)malloc(1024 * sizeof(char));
semop(semaphoreId, &serverSemaphore, 1);
printf("\nInput message to client: ");
fflush(stdin);
cin >> message;
strcpy(segmentPtr, message);
serverSemaphore.sem_op = 3;
semop(semaphoreId, &serverSemaphore, 1);
serverSemaphore.sem_op = 0;
semop(semaphoreId, &serverSemaphore, 1);
if (!strcmp("exit", message))
return 0;
strcpy(message, segmentPtr);
printf("Client message: %s\n", message);
}
return 0;
}
}
else
{
if ((sharedMemoryId = shmget(key, 1024, IPC_CREAT | IPC_EXCL | 0660)) == -1)
int
SemOp(int semid, struct sembuf *semopbuf, DWORD procid, int piid, IPCT *ipct)
{
int i;
BOOL ret;
DWORD dwret;
HANDLE hsem;
#ifndef TERMINAL_SERVICE
char semstr[16];
#else
char semstr[30];
#endif /* TERMINAL_SERVICE */
#ifndef TERMINAL_SERVICE
MakeSemstr(semstr, semopbuf->sem_num, semid, ipct->semt[semid].key);
#else
OSVERSIONINFOEX osvi;
ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
if( !GetVersionEx ((OSVERSIONINFO *) &osvi) )
{
// If OSVERSIONINFOEX doesn't work, try OSVERSIONINFO.
osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
GetVersionEx( (OSVERSIONINFO *) &osvi );
}
if( osvi.dwMajorVersion >= 5 ) /* Windows 2000 */
MakeGlobalSemstr(semstr, semopbuf->sem_num, semid, ipct->semt[semid].key);
else
MakeSemstr(semstr, semopbuf->sem_num, semid, ipct->semt[semid].key);
#endif /* TERMINAL_SERVICE */
hsem=OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, semstr);
if (hsem==NULL)
{
errno=GetLastError();
return -1;
}
if (semopbuf->sem_op<0)
{
if (ipct->semb[semid][semopbuf->sem_num].semval
>= abs((int)semopbuf->sem_op))
ipct->semb[semid][semopbuf->sem_num].semncnt++;
if (ipct->semb[semid][semopbuf->sem_num].semval
< abs((int)semopbuf->sem_op))
{
if (semopbuf->sem_flg & IPC_NOWAIT)
{
ipct->semb[semid][semopbuf->sem_num].sempid=procid;
CloseHandle(hsem);
return 0;
}
}
for (i=0; i<abs((int)semopbuf->sem_op); i++)
{
/**************
do
{
dwret=MsgWaitForMultipleObjects(1, &hsem,
FALSE, INFINITE,
QS_SENDMESSAGE|QS_POSTMESSAGE|QS_TIMER);
***************/
dwret=WaitForSingleObject(hsem, INFINITE);
switch (dwret)
{
/*****************
case WAIT_OBJECT_0 + 1 :
if (l_peekmessage()<0)
{
CloseHandle(hsem);
return -1;
}
break;
*****************/
case WAIT_OBJECT_0 :
/* by KJC 98.09.24 **************************************
ipct->semb[semid][semopbuf->sem_num].semval--;
***********************************************************/
InterlockedDecrement(&ipct->semb[semid][semopbuf->sem_num].semval);
/***********************************************************/
break;
case WAIT_TIMEOUT :
case WAIT_FAILED :
errno=GetLastError();
default :
CloseHandle(hsem);
return -1;
}
/***************
} while (dwret==(WAIT_OBJECT_0 + 1));
***************/
if (semopbuf->sem_flg & SEM_UNDO)
{
ipct->pseminfo[piid].semadj[semid][semopbuf->sem_num]++;
}
}
ipct->semb[semid][semopbuf->sem_num].sempid=procid;
ipct->semb[semid][semopbuf->sem_num].semncnt--;
// CloseHandle(hsem);
}
else if (semopbuf->sem_op>0)
{
ret=ReleaseSemaphore(hsem, semopbuf->sem_op, NULL);
if (ret==FALSE)
{
CloseHandle(hsem);
return -1;
}
ipct->semb[semid][semopbuf->sem_num].sempid=procid;
/* by KJC 98.9.24 ********************************
ipct->semb[semid][semopbuf->sem_num].semval+=(int)semopbuf->sem_op;
***********************************************************/
InterlockedExchangeAdd(&ipct->semb[semid][semopbuf->sem_num].semval, (long)semopbuf->sem_op);
/***********************************************************/
// CloseHandle(hsem);
if (semopbuf->sem_flg & SEM_UNDO)
{
ipct->pseminfo[piid].semadj[semid][semopbuf->sem_num]-=(int)semopbuf->sem_op;
}
}
else
{
if (!ipct->semb[semid][semopbuf->sem_num].semval)
{
CloseHandle(hsem);
return 0;
}
if (semopbuf->sem_flg & IPC_NOWAIT)
{
CloseHandle(hsem);
return 0;
}
ipct->semb[semid][semopbuf->sem_num].sempid=procid;
ipct->semb[semid][semopbuf->sem_num].semzcnt++;
/*###################################*/
/*###################################*/
}
CloseHandle(hsem);
return 0;
}
static os_result
condTimedWait(
os_cond *cond,
os_mutex *mutex,
DWORD timeout)
{
HANDLE hQueue;
HANDLE hMtx;
char name[OS_SERVICE_ENTITY_NAME_MAX];
DWORD wsr;
LONG c;
LONG lockCount;
os_result osr;
os_result result;
assert(cond != NULL);
assert(mutex != NULL);
result = os_resultSuccess;
if (cond->scope == OS_SCOPE_SHARED) {
_snprintf(name, sizeof(name), "%s%s%d%d",
(os_sharedMemIsGlobal() ? OS_SERVICE_GLOBAL_NAME_PREFIX : ""),
OS_SERVICE_SEM_NAME_PREFIX,
cond->qId,
os_getShmBaseAddressFromPointer(cond));
hQueue = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, name);
if (hQueue == NULL) {
OS_DEBUG_1("condTimedWait", "OpenSemaphore failed %d", (int)GetLastError());
assert(0);
return os_resultFail;
}
_snprintf(name, sizeof(name), "%s%s%d%d",
(os_sharedMemIsGlobal() ? OS_SERVICE_GLOBAL_NAME_PREFIX : ""),
OS_SERVICE_EVENT_NAME_PREFIX,
mutex->id,
os_getShmBaseAddressFromPointer(cond));
hMtx = OpenEvent(EVENT_ALL_ACCESS, FALSE, name);
if (hMtx == NULL) {
OS_DEBUG_1("condTimedWait", "OpenEvent failed %d", (int)GetLastError());
CloseHandle(hQueue);
assert(0);
return os_resultFail;
}
} else {
hQueue = (HANDLE)cond->qId;
hMtx = (HANDLE)mutex->id;
}
InterlockedIncrement(&cond->state);
lockCount = InterlockedDecrement(&mutex->lockCount);
if (lockCount > 0) {
wsr = SignalObjectAndWait(hMtx, hQueue, timeout, FALSE);
} else {
wsr = WaitForSingleObject(hQueue, timeout);
}
assert((wsr == WAIT_OBJECT_0) || (wsr == WAIT_FAILED) || (wsr == WAIT_ABANDONED) || (wsr == WAIT_TIMEOUT));
if (wsr == WAIT_TIMEOUT) {
result = os_resultTimeout;
} else if (wsr != WAIT_OBJECT_0) {
result = os_resultFail;
}
c = InterlockedDecrement(&cond->state);
osr = os_mutexLock(mutex);
if (osr != os_resultSuccess) {
result = osr;
}
if (cond->scope == OS_SCOPE_SHARED) {
CloseHandle(hQueue);
CloseHandle(hMtx);
}
return result;
}
bool CanalSharedMemLevel1::doCmdOpen( const char *szInterface, unsigned long flags )
{
HANDLE hMapListen = NULL;
HANDLE hListenMutex = NULL;
HANDLE semListenCommand = NULL;
HANDLE semListenDone = NULL;
DWORD err;
bool rv = true; // return value
wxChar buf[ MAX_PATH ];
struct __shmOpen *pListenShMemArea = NULL;
::wxLogDebug( _T("CanalSharedMemLevel1: Before %ul"), GetLastError() );
SetLastError( 0 );
if ( NULL == ( semListenCommand =
OpenSemaphore( SEMAPHORE_ALL_ACCESS,
FALSE,
CANAL_LISTEN_COMMAND_SEM ) ) ) {
::wxLogDebug( _T("CanalSharedMemLevel1: Failed to open Listen Command semaphore %ul"),
( err = GetLastError() ) );
return false;
}
if ( NULL == ( semListenDone =
OpenSemaphore( SEMAPHORE_ALL_ACCESS,
FALSE,
CANAL_LISTEN_DONE_SEM ) ) ) {
::wxLogDebug( _T("CanalSharedMemLevel1: Failed to open Listen Done semaphore %ul"),
( err = GetLastError() ) );
CloseHandle( semListenCommand );
return false;
}
// Get client shared memory
if ( NULL == ( hMapListen =
OpenFileMapping( FILE_MAP_WRITE,
TRUE,
CANAL_LISTEN_SHM_NAME ) ) ) {
::wxLogDebug( _T("CanalSharedMemLevel1: Failed to open Listen Command semaphore %ul"),
( err = GetLastError() ) );
CloseHandle( semListenCommand );
CloseHandle( semListenDone );
return false;
}
if ( NULL == ( pListenShMemArea =
(struct __shmOpen *)MapViewOfFile( hMapListen,
FILE_MAP_WRITE, 0, 0, 0 ) ) ) {
::wxLogDebug( _T("CanalSharedMemLevel1: Failed to open Listen Shared memory %ul"),
( err = GetLastError() ) );
CloseHandle( hMapListen );
CloseHandle( semListenCommand );
CloseHandle( semListenDone );
return false;
}
if ( NULL == ( hListenMutex =
OpenMutex( MUTEX_ALL_ACCESS,
TRUE,
CANAL_LISTEN_SHARED_MEMORY_MUTEX ) ) ) {
::wxLogDebug( _T("CanalSharedMemLevel1: Failed to open Listen Nutex %ul"),
GetLastError() );
UnmapViewOfFile( pListenShMemArea );
CloseHandle( hMapListen );
CloseHandle( semListenCommand );
CloseHandle( semListenDone );
return false;
}
// Get access to Listenthread common resources
WaitForSingleObject( hListenMutex, INFINITE );
// Write Command
pListenShMemArea->m_command = CANAL_COMMAND_OPEN_VSCP_LEVEL1;
pListenShMemArea->m_flags = flags;
if ( NULL != szInterface ) {
strncpy( pListenShMemArea->m_strIfName, szInterface, sizeof( szInterface ) );
}
// Execute command on server
ReleaseSemaphore( semListenCommand, 1, NULL );
// Wait until command is handled
WaitForSingleObject( semListenDone, INFINITE );
if ( !pListenShMemArea->m_cmdResult ) {
// Give the server thread some time to start
Sleep( 1 );
// Get the client command memory area
_stprintf( buf, CANAL_LISTEN_CLIENT_SHM_TEMPLATE, pListenShMemArea->m_shmid );
if ( NULL != ( m_hMapClient =
OpenFileMapping( FILE_MAP_WRITE, TRUE, buf ) ) ) {
if ( NULL != ( m_pCommandMem = MapViewOfFile( m_hMapClient,
FILE_MAP_WRITE, 0, 0, 0 ) ) ) {
// Save a pointer to the command structure
m_pLevel1 = (struct __shmCanalLevelI *)m_pCommandMem;
// Wait for server thread to give clearence
DWORD start = GetTickCount();
while( 0xaa55 != m_pLevel1->m_test ) {
if ( ( GetTickCount() - start ) > 1000 ) {
// Release listen thread resources we are done with them
// No need for memory anymore
#ifndef CANAL_MFCAPP
wxLogDebug(_T("ERROR: No server thread\n"));
#endif
return false;
}
}
// Get the Client Semaphores
_stprintf( buf, CANAL_CLIENT_COMMAND_SEM_TEMPLATE, pListenShMemArea->m_shmid );
if ( NULL == ( m_semClientCommand = OpenSemaphore( SEMAPHORE_ALL_ACCESS,
TRUE,
buf ) ) ) {
CloseHandle( semListenCommand );
return false;
}
_stprintf( buf, CANAL_CLIENT_DONE_SEM_TEMPLATE, pListenShMemArea->m_shmid );
if ( NULL == ( m_semClientDone = OpenSemaphore( SEMAPHORE_ALL_ACCESS,
TRUE,
buf ) ) ) {
CloseHandle( semListenCommand );
return false;
}
// Go on
m_pLevel1->m_test = 0x55aa;
// We have an open channel!
// Do a dummy Open of interface
doCommand( CANAL_COMMAND_OPEN );
}
else {
// Failed to map in client shared memory
}
}
else {
// Failed to get Client shared memory
}
}
// Release listen thread resources we are done with them
ReleaseMutex( hListenMutex );
if ( NULL != semListenCommand ) {
CloseHandle( semListenCommand );
}
if ( NULL != semListenDone ) {
CloseHandle( semListenDone );
}
// release listthread sh memory
if ( NULL != pListenShMemArea ) {
UnmapViewOfFile( pListenShMemArea );
}
// ...and handle for shared memory
if ( NULL != hMapListen ) {
CloseHandle( hMapListen );
}
return rv;
}
int RGServerPort :: Connect (RGClient* parent) {
if (Connected) {
LastError = RGALREADYCONNECTED;
return -1;
}
if (parent == NULL) {
LastError = RGCLIENTNULL;
return -1;
}
Parent = parent;
//
// Name is the name of the server. To get the client name, use Parent.
//
RGString OKToReadName = Name + "OKToReadReceiveBuffer";
RGString OKToWriteName = Name + "OKToWriteIntoReceiveBuffer";
RGString ContinuationName = Name + "ReceiveContinuation";
RGString ImTryingToContactYouName = Name + "ImTryingToContactYou";
RGString BufferName = Name + "ReceiveBuffer";
RGString To ("To");
RGString HotLineName = "HotLineFrom" + Name + To + Parent->GetName ();
FirstTime = TRUE;
LastError = RGOK;
// BufferHandle = OpenFileMapping (PAGE_READWRITE, FALSE, BufferName);
BufferHandle = CreateFileMapping (INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0,
4, BufferName);
if (BufferHandle == NULL) {
LastError = RGNOHANDLE;
return -1;
}
BufferMapAddress = (unsigned char*)MapViewOfFile (BufferHandle,
FILE_MAP_WRITE, 0, 0, 0);
if (BufferMapAddress == NULL) {
cout << "Map Error = " << GetLastError () << endl;
LastError = RGNOBUFFER;
return -1;
}
int LongLength = sizeof (unsigned long);
unsigned long* size = (unsigned long*) BufferMapAddress;
Type = (unsigned long*) (BufferMapAddress + LongLength);
Length = (unsigned long*) (BufferMapAddress + 2 * LongLength);
ReplyPointer = (unsigned long*) (BufferMapAddress + 3 * LongLength);
ServerPid = (unsigned long*) (BufferMapAddress + 4 * LongLength);
BufferSize = *size;
DataBegin = BufferMapAddress + DATAMAPOFFSET;
OKToReadHandle = OpenEvent (EVENT_ALL_ACCESS, FALSE, OKToReadName);
if (OKToReadHandle == NULL) {
LastError = RGNOHANDLE;
return -1;
}
OKToWriteHandle = OpenEvent (EVENT_ALL_ACCESS, FALSE, OKToWriteName);
if (OKToWriteHandle == NULL) {
LastError = RGNOHANDLE;
return -1;
}
ContinuationHandle = OpenEvent (EVENT_ALL_ACCESS, FALSE, ContinuationName);
if (ContinuationHandle == NULL) {
LastError = RGNOHANDLE;
return -1;
}
ImTryingToContactYouHandle = OpenSemaphore (SEMAPHORE_ALL_ACCESS, FALSE, ImTryingToContactYouName);
if (ImTryingToContactYouHandle == NULL) {
cout << "Windows error: " << GetLastError () << endl;
LastError = RGNOHANDLE;
return -1;
}
ServerPidHandle = OpenProcess (SYNCHRONIZE, FALSE, *ServerPid); // SYNCHRONIZE required by "wait" functions
if (ServerPidHandle == NULL) {
LastError = RGNOHANDLE;
return -1;
}
HotLineHandle = CreateEvent (NULL, FALSE, FALSE, HotLineName);
if (HotLineHandle == NULL) {
LastError = RGNOHANDLE;
return -1;
}
Connected = TRUE;
return 0;
}
HSemaphore::HSemaphore( const GChar * strName, ThreadingAccess iAccessFlags ):
HThreadingObject()
{
m_hThreadingObject = OpenSemaphore( _BuildThreadingAccess(iAccessFlags), FALSE, strName );
DebugAssert( m_hThreadingObject != NULL );
}
