/* Create a semaphore */
ACL_SEM *acl_sem_create2(const char *pathname, unsigned int initial_value)
{
const char *myname = "acl_sem_create2";
ACL_SEM *sem;
/* Allocate sem memory */
sem = (ACL_SEM *) acl_mymalloc(sizeof(*sem));
if (sem == NULL) {
acl_msg_error("%s, %s(%d): malloc error(%s)",
__FILE__, myname, __LINE__, acl_last_serror());
return NULL;
}
/* Create the semaphore, with max value 32K */
sem->id = CreateSemaphore(NULL, initial_value, 32 * 1024, pathname);
sem->count = initial_value;
if (!sem->id) {
acl_msg_error("%s, %s(%d): Couldn't create semaphore(%s)",
__FILE__, myname, __LINE__, acl_last_serror());
acl_myfree(sem);
return NULL;
}
return sem;
}
int pvinit_semaphore(WSEMAPHORE *s, int cmax)
{
/* Create a semaphore with initial count=0 max. counts of cmax. */
#ifdef PVWIN32THREAD
s->cmax = cmax;
s->hSemaphore = CreateSemaphore(
NULL, /* no security attributes */
0, /* initial count */
cmax, /* maximum count */
NULL); /* unnamed semaphore */
if(s->hSemaphore == NULL) return -1; /* Check for error. */
return 0;
#else
s->cmax = cmax;
s->nready = 0;
pvthread_mutex_init(&s->mutex, NULL);
return 0;
#endif
}
int pthread_cond_init(pthread_cond_t *cond, const void *unused) {
REDIS_NOTUSED(unused);
cond->waiters = 0;
cond->was_broadcast = 0;
InitializeCriticalSection(&cond->waiters_lock);
cond->sema = CreateSemaphore(NULL, 0, LONG_MAX, NULL);
if (!cond->sema) {
errno = GetLastError();
return -1;
}
cond->continue_broadcast = CreateEvent(NULL, /* security */
FALSE, /* auto-reset */
FALSE, /* not signaled */
NULL); /* name */
if (!cond->continue_broadcast) {
errno = GetLastError();
return -1;
}
return 0;
}
DWORD WINAPI MainThread(void* pData)
{
MAIN_THREAD_DATA_STRUCT* mtds = (MAIN_THREAD_DATA_STRUCT*)pData;
CRIFFChunkTreeDlg* dlg = mtds->dlg;
STREAM* source = mtds->source;
__int64 qwPos=source->GetPos();
dwMBNbr=0;
LISTHEADER lh;
source->Seek(0);
while (!source->IsEndOfStream()) {
source->Read(&lh,12);
HANDLE h = CreateSemaphore(NULL, 0, 1, NULL);
StartInsertListThread(dlg, NULL, &lh, source->GetPos() - 12, h);
WaitForSingleObject(h, INFINITE);
CloseHandle(h);
}
source->Seek(qwPos);
delete mtds;
return 1;
}
void OsNetworkSetInterfaceChangedObserver(OsContext* aContext, InterfaceListChanged aCallback, void* aArg)
{
InterfaceChangeObserver* icobs;
if (NULL != aContext->iInterfaceChangeObserver) {
return;
}
icobs = (InterfaceChangeObserver*)malloc(sizeof(InterfaceChangeObserver));
if (NULL == icobs) {
return;
}
icobs->iSocket = socket(AF_INET, SOCK_DGRAM, 0);
SetSocketBlocking(icobs->iSocket);
icobs->iEvent = WSACreateEvent();
icobs->iShutdownEvent = WSACreateEvent();
icobs->iCallback = aCallback;
icobs->iArg = aArg;
icobs->iShutdown = 0;
icobs->iSem = CreateSemaphore(NULL, 0, INT32_MAX, NULL);
(void)WSAEventSelect(icobs->iSocket, icobs->iEvent, FD_ADDRESS_LIST_CHANGE);
(void)CreateThread(NULL, 16*1024, (LPTHREAD_START_ROUTINE)&interfaceChangeThread, icobs, 0, NULL);
aContext->iInterfaceChangeObserver = icobs;
}
// -----------------------------------------------------------------------------------------
// Semaphore functions
// -----------------------------------------------------------------------------------------
WcmSemaphore_t WcmSemaphore_Create(void)
{
#ifdef WIN32
return CreateSemaphore(NULL, 0, 1000, NULL);
#endif
#ifdef LINUX_OR_OSX
WcmSemaphore_t hSem;
if ((hSem = WcmMalloc(sizeof(stWcmSemaphore_t))) == NULL)
return NULL;
hSem->u32Count = 0;
if(pthread_mutex_init(&hSem->hMutex, NULL) != 0)
{
WcmFree(hSem);
return NULL;
}
if(pthread_cond_init(&hSem->condSem, NULL) != 0)
{
pthread_mutex_destroy(&hSem->hMutex);
WcmFree(hSem);
return NULL;
}
return hSem;
#endif
} /* WcmSemaphore_Create */
/*
* ======== SemMP_create ========
*/
SemMP_Handle SemMP_create(Int key, Int count)
{
HANDLE mutexId;
HANDLE semId;
SemMP_Obj *sem;
TCHAR tszKey[MAX_PATH + 1] = TEXT("");
GT_2trace(curTrace, GT_ENTER, "SemMP_create> key: 0x%x count: %d\n", key,
count);
if ((sem = (SemMP_Obj *)Memory_alloc(sizeof(SemMP_Obj), NULL)) == NULL) {
GT_0trace(curTrace, GT_7CLASS, "SemMP_create> Memory_alloc failed\n");
return (NULL);
}
_stprintf(tszKey, TEXT("%d"), key);
sem->id = CreateSemaphore(NULL, count, count, tszKey);
GT_1trace(curTrace, GT_ENTER, "SemMP_create> semId: 0x%x\n", sem->id);
GT_1trace(curTrace, GT_ENTER, "Leaving SemMP_create> sem[0x%x]\n", sem);
return (sem);
}
void ipcon_device_create(Device *device, const char *uid) {
int i;
for(i = 0; i < MAX_NUM_CALLBACKS; i++) {
device->registered_callbacks[i] = NULL;
device->callback_wrappers[i] = NULL;
}
device->uid = ipcon_base58decode(uid);
device->ipcon = NULL;
device->response.function_id = 0;
device->response.length = 0;
#ifdef _WIN32
InitializeCriticalSection(&device->write_mutex);
// Default state for response semaphore is empty
device->response_semaphore = CreateSemaphore(NULL, 0, 1, NULL);
#else
pthread_mutex_init(&device->write_mutex, NULL);
pthread_mutex_init(&device->response_mutex, NULL);
pthread_cond_init(&device->response_cond, NULL);
device->response_flag = false;
#endif
}
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.");
}
}
}
/*-------------------------------------------
| Name:OS_CreateMB
| Description:
| Parameters:
| Return Type:
| Comments:
| See:
---------------------------------------------*/
void OS_CreateMB (OS_MAILBOX* pMB, OS_U8 sizeofMsg, OS_UINT maxnofMsg, void* Buffer){
if(!pMB)return;
pMB->hSemMB = CreateSemaphore (NULL,1,1,NULL);
pMB->hEvtMB = CreateEvent(NULL,0,0,NULL);
pMB->dwThreadId = 0;
pMB->pData = Buffer;
pMB->pRead = pMB->pData;
pMB->pWrite = pMB->pData;
pMB->pEnd = pMB->pData + ((maxnofMsg-1)*sizeofMsg);
pMB->maxnofMsg = maxnofMsg;
pMB->sizeofMsg = sizeofMsg;
pMB->r = 0;
pMB->w = 0;
pMB->size = maxnofMsg*sizeofMsg;
}
sys_mbox_t sys_mbox_new(int size)
{
struct lwip_mbox *new_mbox;
LWIP_UNUSED_ARG(size);
new_mbox = (struct lwip_mbox*)malloc(sizeof(struct lwip_mbox));
LWIP_ASSERT("new_mbox != NULL", new_mbox != NULL);
if(new_mbox == NULL) {
#if LWIP_STATS
lwip_stats.sys.mbox.err++;
#endif /* LWIP_STATS */
return SYS_SEM_NULL;
}
new_mbox->sem = CreateSemaphore(0, 0, MAX_QUEUE_ENTRIES, 0);
LWIP_ASSERT("Error creating semaphore", new_mbox->sem != NULL);
if(new_mbox->sem == NULL) {
#if LWIP_STATS
lwip_stats.sys.mbox.err++;
#endif /* LWIP_STATS */
free(new_mbox);
new_mbox = NULL;
return SYS_SEM_NULL;
}
memset(&new_mbox->q_mem, 0, sizeof(u32_t)*MAX_QUEUE_ENTRIES);
new_mbox->head = 0;
new_mbox->tail = 0;
#if LWIP_STATS
lwip_stats.sys.mbox.used++;
LWIP_ASSERT("sys_mbox_new() counter overflow", lwip_stats.sys.mbox.used != 0 );
if (lwip_stats.sys.mbox.used > lwip_stats.sys.mbox.max) {
lwip_stats.sys.mbox.max = lwip_stats.sys.mbox.used;
}
#endif /* LWIP_STATS */
return new_mbox;
}
/* Create a semaphore */
SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)
{
SDL_sem *sem;
/* Allocate sem memory */
sem = (SDL_sem *)SDL_malloc(sizeof(*sem));
if ( sem ) {
/* Create the semaphore, with max value 32K */
#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
sem->id = CreateSemaphoreCE(NULL, initial_value, 32*1024, NULL);
#else
sem->id = CreateSemaphore(NULL, initial_value, 32*1024, NULL);
#endif
sem->count = initial_value;
if ( ! sem->id ) {
SDL_SetError("Couldn't create semaphore");
SDL_free(sem);
sem = NULL;
}
} else {
SDL_OutOfMemory();
}
return(sem);
}
mutex_t mutex_create(void)
{
mutex_t m;
m = (mutex_t) malloc(sizeof(struct mutex_s));
if(m == NULL)
return NULL;
#if defined(OS_WINDOWS)
m->mutex = CreateSemaphore(NULL, 1, 1, NULL);
if(m->mutex == NULL)
goto fail_mutex;
#else
pthread_mutex_init(&(m->mutex), NULL);
#endif
return m;
#if defined(OS_WINDOWS)
fail_mutex:
free(m);
return NULL;
#endif
}
int rktio_winsock_init(rktio_t *rktio)
{
if (!winsock_sema) {
winsock_sema = CreateSemaphore(NULL, 1, 1, NULL);
}
WaitForSingleObject(winsock_sema, INFINITE);
if (!winsock_started) {
WSADATA data;
if (!WSAStartup(MAKEWORD(1, 1), &data)) {
winsock_started = 1;
} else {
get_windows_error();
ReleaseSemaphore(winsock_sema, 1, NULL);
return 0;
}
} else
winsock_started++;
ReleaseSemaphore(winsock_sema, 1, NULL);
return 1;
}
int main (int argc, char **argv)
{
/*** CHECK ARGUMEN VALIDATION ********/
/* Interpret command line */
if (argc == 2)
{
/* Use local address */
if (sscanf(argv[1], "%u", &port_number) != 1)
{
usage();
}
}
else if (argc == 3)
{
/* Copy address */
if (sscanf(argv[1], "%d.%d.%d.%d", &a1, &a2, &a3, &a4) != 4)
{
usage();
}
if (sscanf(argv[2], "%u", &port_number) != 1)
{
usage();
}
}
else
{
usage();
}
/******END ARGUMEN VALIDATION **************/
/* Open windows connection */
if (WSAStartup(0x0101, &w) != 0)
{
fprintf(stderr, "Could not open Windows connection.\n");
exit(0);
}
/* Open a datagram socket */
sd = socket(AF_INET, SOCK_DGRAM, 0);
if (sd == INVALID_SOCKET)
{
fprintf(stderr, "Could not create socket.\n");
WSACleanup();
exit(0);
}
/* Clear out server struct */
memset((void *)&server, '\0', sizeof(struct sockaddr_in));
/* Set family and port */
server.sin_family = AF_INET;
server.sin_port = htons(port_number);
/* Set address automatically if desired */
if (argc == 2)
{
/* Get host name of this computer */
gethostname(host_name, sizeof(host_name));
hp = gethostbyname(host_name);
/* Check for NULL pointer */
if (hp == NULL)
{
fprintf(stderr, "Could not get host name.\n");
closesocket(sd);
WSACleanup();
exit(0);
}
/* Assign the address */
server.sin_addr.S_un.S_un_b.s_b1 = hp->h_addr_list[0][0];
server.sin_addr.S_un.S_un_b.s_b2 = hp->h_addr_list[0][1];
server.sin_addr.S_un.S_un_b.s_b3 = hp->h_addr_list[0][2];
server.sin_addr.S_un.S_un_b.s_b4 = hp->h_addr_list[0][3];
}
/* Otherwise assign it manually */
else
{
server.sin_addr.S_un.S_un_b.s_b1 = (unsigned char)a1;
server.sin_addr.S_un.S_un_b.s_b2 = (unsigned char)a2;
server.sin_addr.S_un.S_un_b.s_b3 = (unsigned char)a3;
server.sin_addr.S_un.S_un_b.s_b4 = (unsigned char)a4;
}
/* Bind address to socket */
if (bind(sd, (struct sockaddr *)&server, sizeof(struct sockaddr_in)) == -1)
{
fprintf(stderr, "Could not bind name to socket.\n");
closesocket(sd);
WSACleanup();
exit(0);
}
/* Print out server information */
printf("Binding pada %u.%u.%u.%u : %u\n", (unsigned char)server.sin_addr.S_un.S_un_b.s_b1,
(unsigned char)server.sin_addr.S_un.S_un_b.s_b2,
(unsigned char)server.sin_addr.S_un.S_un_b.s_b3,
(unsigned char)server.sin_addr.S_un.S_un_b.s_b4,
(unsigned short) port_number);
printf("Press CTRL + C to quit\n");
/* Loop and get data from clients */
// Create a semaphore with initial and max counts of MAX_SEM_COUNT
ghSemaphore = CreateSemaphore(
NULL, // default security attributes
MAX_SEM_COUNT, // initial count
MAX_SEM_COUNT, // maximum count
NULL); // unnamed semaphore
if (ghSemaphore == NULL)
{
printf("CreateSemaphore error: %d\n", GetLastError());
return 1;
}
// Create 2 worker threads aThread[0] for reading and sending file
aThread[0] = CreateThread(
NULL, // default security attributes
0, // default stack size
(LPTHREAD_START_ROUTINE) ProcRcvData,
NULL, // no thread function arguments
0, // default creation flags
&ThreadID); // receive thread identifier
//case of making thread error
if( aThread[0] == NULL )
{
printf("CreateThread error: %d\n", GetLastError());
return 1;
}
//aThread[1] for listening XON and XOFF
aThread[1] = CreateThread(
NULL, // default security attributes
0, // default stack size
(LPTHREAD_START_ROUTINE) ProcWaitSignal,
NULL, // no thread function arguments
0, // default creation flags
&ThreadID); // receive thread identifier
//case of making thread error
if( aThread[1] == NULL )
{
printf("CreateThread error: %d\n", GetLastError());
return 1;
}
// Wait for all threads to terminate
WaitForMultipleObjects(THREADCOUNT, aThread, TRUE, INFINITE);
// Close thread and semaphore handles
for( i=0; i < THREADCOUNT; i++ )
CloseHandle(aThread[i]);
CloseHandle(ghSemaphore);
return 0;
}
/*** Semaphore ***/
void vlc_sem_init (vlc_sem_t *sem, unsigned value)
{
*sem = CreateSemaphore (NULL, value, 0x7fffffff, NULL);
if (*sem == NULL)
abort ();
}
int DIB_OpenAudio(_THIS, SDL_AudioSpec *spec)
{
MMRESULT result;
int i;
WAVEFORMATEX waveformat;
/* Initialize the wavebuf structures for closing */
sound = NULL;
audio_sem = NULL;
for ( i = 0; i < NUM_BUFFERS; ++i )
wavebuf[i].dwUser = 0xFFFF;
mixbuf = NULL;
/* Set basic WAVE format parameters */
SDL_memset(&waveformat, 0, sizeof(waveformat));
waveformat.wFormatTag = WAVE_FORMAT_PCM;
/* Determine the audio parameters from the AudioSpec */
switch ( spec->format & 0xFF ) {
case 8:
/* Unsigned 8 bit audio data */
spec->format = AUDIO_U8;
waveformat.wBitsPerSample = 8;
break;
case 16:
/* Signed 16 bit audio data */
spec->format = AUDIO_S16;
waveformat.wBitsPerSample = 16;
break;
default:
SDL_SetError("Unsupported audio format");
return(-1);
}
waveformat.nChannels = spec->channels;
waveformat.nSamplesPerSec = spec->freq;
waveformat.nBlockAlign =
waveformat.nChannels * (waveformat.wBitsPerSample/8);
waveformat.nAvgBytesPerSec =
waveformat.nSamplesPerSec * waveformat.nBlockAlign;
/* Check the buffer size -- minimum of 1/4 second (word aligned) */
if ( spec->samples < (spec->freq/4) )
spec->samples = ((spec->freq/4)+3)&~3;
/* Update the fragment size as size in bytes */
SDL_CalculateAudioSpec(spec);
/* Open the audio device */
result = waveOutOpen(&sound, WAVE_MAPPER, &waveformat,
(DWORD_PTR)FillSound, (DWORD_PTR)this, CALLBACK_FUNCTION);
if ( result != MMSYSERR_NOERROR ) {
SetMMerror("waveOutOpen()", result);
return(-1);
}
#ifdef SOUND_DEBUG
/* Check the sound device we retrieved */
{
WAVEOUTCAPS caps;
result = waveOutGetDevCaps((UINT)sound, &caps, sizeof(caps));
if ( result != MMSYSERR_NOERROR ) {
SetMMerror("waveOutGetDevCaps()", result);
return(-1);
}
printf("Audio device: %s\n", caps.szPname);
}
#endif
/* Create the audio buffer semaphore */
#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
audio_sem = CreateSemaphoreCE(NULL, NUM_BUFFERS-1, NUM_BUFFERS, NULL);
#else
audio_sem = CreateSemaphore(NULL, NUM_BUFFERS-1, NUM_BUFFERS, NULL);
#endif
if ( audio_sem == NULL ) {
SDL_SetError("Couldn't create semaphore");
return(-1);
}
/* Create the sound buffers */
mixbuf = (Uint8 *)SDL_malloc(NUM_BUFFERS*spec->size);
if ( mixbuf == NULL ) {
SDL_SetError("Out of memory");
return(-1);
}
for ( i = 0; i < NUM_BUFFERS; ++i ) {
SDL_memset(&wavebuf[i], 0, sizeof(wavebuf[i]));
wavebuf[i].lpData = (LPSTR) &mixbuf[i*spec->size];
wavebuf[i].dwBufferLength = spec->size;
wavebuf[i].dwFlags = WHDR_DONE;
result = waveOutPrepareHeader(sound, &wavebuf[i],
sizeof(wavebuf[i]));
if ( result != MMSYSERR_NOERROR ) {
SetMMerror("waveOutPrepareHeader()", result);
return(-1);
}
}
/* Ready to go! */
next_buffer = 0;
return(0);
}
Semaphore::Semaphore(U32 initialCount, U32 maximumCount)
{
mSemaphore = CreateSemaphore(NULL, initialCount, maximumCount, NULL);
}
// Winamp calls this with mlplugin populated after the above has been called
int mlinit()
{
static char c[512];
char filename[512];
HWND hWnd = NULL;
g_hDllInstance = mlplugin.hDllInstance;
g_hwndParent = mlplugin.hwndWinampParent;
_Module.Init(NULL, mlplugin.hDllInstance, &LIBID_ATLLib);
// Handle Multiple Instances
hSem = CreateSemaphore (NULL, 1, 1,szSemName);
if (WaitForSingleObject (hSem, 0) == WAIT_TIMEOUT)
{
CloseHandle (hSem);
return -1;
}
int version = WINAMP_VERSION_MAJOR( SendMessage( mlplugin.hwndWinampParent,WM_WA_IPC,0,IPC_GETVERSION) );
// If the version is earlier than 5, we need to use a method of track play detection
// that involves overriding the playlist editor's event handler.
if ( version < 5 )
{
hWnd = GetPEWindow(mlplugin.hwndWinampParent);
if ( hWnd != NULL )
{
SetWndSubClass( hWnd, WndProcPE, &lpWndProcOldPE );
}
else
PRINTF(DEBUG_ERROR, "Gen_AudioScrobbler::mlinit", "Failed to find Winamp PE Window");
}
// From version 5, Winamp supplies a better way to detect track plays that goes
// through the main window's event handler. From 5.5 the old PE method does
// not even work any longer.
if ( version >= 5 && mlplugin.hwndWinampParent != NULL )
{
SetWndSubClass( mlplugin.hwndWinampParent, WndProcParent, &lpWndProcOldParent );
}
if(GetModuleFileName(mlplugin.hDllInstance,filename,sizeof(filename)) == 0)
{
CStdString strText;
strText.Format("An error occurred loading the AS plugin during GetModuleFileName(), the return code was %d", GetLastError());
::MessageBox(mlplugin.hwndWinampParent, strText.c_str(), "AudioScrobbler Error", MB_OK);
return -1;
}
if(!theScrobbler.StartScrobbling(mlplugin.hDllInstance,
mlplugin.hwndWinampParent,
mlplugin.hwndLibraryParent,
filename))
config();
sprintf((mlplugin.description=c), "%s v%s (ML Mode)", theScrobbler.GetAppName().c_str(), theScrobbler.GetVersionString().c_str());
return 0;
}
static void os_sem_init(os_sem_t *s)
{
*s = CreateSemaphore(NULL, 0, 0x7FFFFFFFL, NULL);
}
/* HOLDS: main_loop_lock */
static void
g_main_poll (gint timeout,
gboolean use_priority,
gint priority)
{
#ifdef G_MAIN_POLL_DEBUG
GTimer *poll_timer;
#endif
GPollFD *fd_array;
GPollRec *pollrec;
gint i;
gint npoll;
#ifdef G_THREADS_ENABLED
#ifndef NATIVE_WIN32
if (wake_up_pipe[0] < 0)
{
if (pipe (wake_up_pipe) < 0)
g_error ("Cannot create pipe main loop wake-up: %s\n",
g_strerror (errno));
wake_up_rec.fd = wake_up_pipe[0];
wake_up_rec.events = G_IO_IN;
g_main_add_poll_unlocked (0, &wake_up_rec);
}
#else
if (wake_up_semaphore == NULL)
{
if ((wake_up_semaphore = CreateSemaphore (NULL, 0, 100, NULL)) == NULL)
g_error ("Cannot create wake-up semaphore: %d", GetLastError ());
wake_up_rec.fd = (gint) wake_up_semaphore;
wake_up_rec.events = G_IO_IN;
g_main_add_poll_unlocked (0, &wake_up_rec);
}
#endif
#endif
fd_array = g_new (GPollFD, n_poll_records);
pollrec = poll_records;
i = 0;
while (pollrec && (!use_priority || priority >= pollrec->priority))
{
if (pollrec->fd->events)
{
fd_array[i].fd = pollrec->fd->fd;
/* In direct contradiction to the Unix98 spec, IRIX runs into
* difficulty if you pass in POLLERR, POLLHUP or POLLNVAL
* flags in the events field of the pollfd while it should
* just ignoring them. So we mask them out here.
*/
fd_array[i].events = pollrec->fd->events & ~(G_IO_ERR|G_IO_HUP|G_IO_NVAL);
fd_array[i].revents = 0;
i++;
}
pollrec = pollrec->next;
}
#ifdef G_THREADS_ENABLED
poll_waiting = TRUE;
poll_changed = FALSE;
#endif
npoll = i;
if (npoll || timeout != 0)
{
#ifdef G_MAIN_POLL_DEBUG
g_print ("g_main_poll(%d) timeout: %d\r", npoll, timeout);
poll_timer = g_timer_new ();
#endif
G_UNLOCK (main_loop);
(*poll_func) (fd_array, npoll, timeout);
G_LOCK (main_loop);
#ifdef G_MAIN_POLL_DEBUG
g_print ("g_main_poll(%d) timeout: %d - elapsed %12.10f seconds",
npoll,
timeout,
g_timer_elapsed (poll_timer, NULL));
g_timer_destroy (poll_timer);
pollrec = poll_records;
i = 0;
while (i < npoll)
{
if (pollrec->fd->events)
{
if (fd_array[i].revents)
{
g_print (" [%d:", fd_array[i].fd);
if (fd_array[i].revents & G_IO_IN)
g_print ("i");
if (fd_array[i].revents & G_IO_OUT)
g_print ("o");
if (fd_array[i].revents & G_IO_PRI)
g_print ("p");
if (fd_array[i].revents & G_IO_ERR)
g_print ("e");
if (fd_array[i].revents & G_IO_HUP)
g_print ("h");
if (fd_array[i].revents & G_IO_NVAL)
g_print ("n");
g_print ("]");
}
i++;
}
pollrec = pollrec->next;
}
g_print ("\n");
#endif
} /* if (npoll || timeout != 0) */
#ifdef G_THREADS_ENABLED
if (!poll_waiting)
{
#ifndef NATIVE_WIN32
gchar c;
read (wake_up_pipe[0], &c, 1);
#endif
}
else
poll_waiting = FALSE;
/* If the set of poll file descriptors changed, bail out
* and let the main loop rerun
*/
if (poll_changed)
{
g_free (fd_array);
return;
}
#endif
pollrec = poll_records;
i = 0;
while (i < npoll)
{
if (pollrec->fd->events)
{
pollrec->fd->revents = fd_array[i].revents;
i++;
}
pollrec = pollrec->next;
}
g_free (fd_array);
}
int CMainDlg::startScanSubDomain(CStringArray *sArray)
{
DWORD dwError;
BOOL bSemaphore = FALSE;
DWORD dwThreadId;
HANDLE hObject = NULL;
LONG previousCount;
int nMaxThread;
int nScannedCount = 0;
CString strDomain, strIP, strHostName;
int nTotalNum = sArray->GetSize();
nMaxThread = m_nMaxThread;
m_nIpScanned = 0;
hSemaphore = CreateSemaphore(0, nMaxThread, nMaxThread, 0);
if (!hSemaphore)
{
StatusTextOut(0, "Fail To Create Semaphore");
return 0;
}
for (int i = 0; i < nTotalNum; i++)
{
if (bStopScan)
break;
strDomain = sArray->GetAt(i);
if (GetTickCount()%10 == 0)
StatusTextOut(0, "%s", strDomain);
if (GetTickCount()%5 == 0)
StatusTextOut(1, "进度: %d/%d", i, nTotalNum);
ThreadParameter *lparam = new ThreadParameter;
lparam->strDomain = strDomain;
lparam->pThis = this;
hObject = CreateThread(0, 0, DomainScanThread, lparam, 0, &dwThreadId);
if (hObject)
{
EnterCriticalSection(&cs);
++nScannedCount;
++dwThreadsUsed;
LeaveCriticalSection(&cs);
CloseHandle(hObject);
}
WaitForSingleObject(hSemaphore, INFINITE);
}
while (dwThreadsUsed)
{
WaitForSingleObject(hSemaphore, INFINITE);
if (!bStopScan)//不是强制终止的才显示
{
StatusTextOut(0, "仍有%d线程正在扫描...", dwThreadsUsed);
StatusTextOut(1, "");
}
EnterCriticalSection(&cs);
bSemaphore = ReleaseSemaphore(hSemaphore, 1, &previousCount);
LeaveCriticalSection(&cs);
if (!bSemaphore)
{
dwError = GetLastError();
StatusTextOut(1, "Error Code: %d", dwError);
Sleep(1000);
break;
}
if (previousCount + 1 != nMaxThread)
{
Sleep(200);
if (m_nIpScanned != nScannedCount)//说明还没扫描完
continue;
}
break;
}
if ( hSemaphore )
CloseHandle(hSemaphore);
return 0;
}
/*
* TransferInit: Prepare for transfer.
*/
void TransferInit(void)
{
buf = (char *)SafeMalloc(BUFSIZE);
hSemaphore = CreateSemaphore(NULL, 1, 1, NULL); // Signaled initially
}
ThreadQueue::ThreadQueue(unsigned int start,unsigned int max){
semaphore=CreateSemaphore(NULL,start,max>0?max:50,NULL);
}
static void test_iocp_callback(void)
{
char temp_path[MAX_PATH];
char filename[MAX_PATH];
DWORD ret;
BOOL retb;
static const char prefix[] = "pfx";
HANDLE hFile;
HMODULE hmod = GetModuleHandleA("kernel32.dll");
DWORD bytesWritten;
const char *buffer = "12345678123456781234567812345678";
OVERLAPPED overlapped;
p_BindIoCompletionCallback = (void*)GetProcAddress(hmod, "BindIoCompletionCallback");
if(!p_BindIoCompletionCallback) {
skip("BindIoCompletionCallback not found in this DLL\n");
return;
}
sem = CreateSemaphore(NULL, 0, 1, NULL);
ok(sem != INVALID_HANDLE_VALUE, "Creating a semaphore failed\n");
ret = GetTempPathA(MAX_PATH, temp_path);
ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
ret = GetTempFileNameA(temp_path, prefix, 0, filename);
ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
hFile = CreateFileA(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA: error %d\n", GetLastError());
retb = p_BindIoCompletionCallback(hFile, iocp_callback, 0);
ok(retb == FALSE, "BindIoCompletionCallback succeeded on a file that wasn't created with FILE_FLAG_OVERLAPPED\n");
ok(GetLastError() == ERROR_INVALID_PARAMETER, "Last error is %d\n", GetLastError());
ret = CloseHandle(hFile);
ok( ret, "CloseHandle: error %d\n", GetLastError());
ret = DeleteFileA(filename);
ok( ret, "DeleteFileA: error %d\n", GetLastError());
hFile = CreateFileA(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, FILE_FLAG_RANDOM_ACCESS | FILE_FLAG_OVERLAPPED, 0);
ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA: error %d\n", GetLastError());
retb = p_BindIoCompletionCallback(hFile, iocp_callback, 0);
ok(retb == TRUE, "BindIoCompletionCallback failed\n");
memset(&overlapped, 0, sizeof(overlapped));
retb = WriteFile(hFile, (const void *) buffer, 4, &bytesWritten, &overlapped);
ok(retb == TRUE || GetLastError() == ERROR_IO_PENDING, "WriteFile failed, lastError = %d\n", GetLastError());
ret = WaitForSingleObject(sem, 5000);
ok(ret == WAIT_OBJECT_0, "Wait for the IO completion callback failed\n");
CloseHandle(sem);
retb = p_BindIoCompletionCallback(hFile, iocp_callback, 0);
ok(retb == FALSE, "BindIoCompletionCallback succeeded when setting the same callback on the file again\n");
ok(GetLastError() == ERROR_INVALID_PARAMETER, "Last error is %d\n", GetLastError());
retb = p_BindIoCompletionCallback(hFile, NULL, 0);
ok(retb == FALSE, "BindIoCompletionCallback succeeded when setting the callback to NULL\n");
ok(GetLastError() == ERROR_INVALID_PARAMETER, "Last error is %d\n", GetLastError());
ret = CloseHandle(hFile);
ok( ret, "CloseHandle: error %d\n", GetLastError());
ret = DeleteFileA(filename);
ok( ret, "DeleteFileA: error %d\n", GetLastError());
/* win2k3 requires the Flags parameter to be zero */
SetLastError(0xdeadbeef);
hFile = CreateFileA(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, FILE_FLAG_RANDOM_ACCESS | FILE_FLAG_OVERLAPPED, 0);
ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA: error %d\n", GetLastError());
retb = p_BindIoCompletionCallback(hFile, iocp_callback, 12345);
if (!retb)
ok(GetLastError() == ERROR_INVALID_PARAMETER,
"Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
else
ok(retb == TRUE, "BindIoCompletionCallback failed with Flags != 0\n");
ret = CloseHandle(hFile);
ok( ret, "CloseHandle: error %d\n", GetLastError());
ret = DeleteFileA(filename);
ok( ret, "DeleteFileA: error %d\n", GetLastError());
retb = p_BindIoCompletionCallback(NULL, iocp_callback, 0);
ok(retb == FALSE, "BindIoCompletionCallback succeeded on a NULL file\n");
ok(GetLastError() == ERROR_INVALID_HANDLE ||
GetLastError() == ERROR_INVALID_PARAMETER, /* vista */
"Last error is %d\n", GetLastError());
}
int main( void )
{
int i = 0;
int j, k = 1;
dFILE *df;
bHEAD *bh;
dFIELD *field[2];
char buff[4096];
long l, ll;
HANDLE hsem;
TS_COM_PROPS tscp1;
strncpy(buff, "abcdefg", 10);
strncpy(buff, "abcdefg", 3);
/* ProcessAttach();
field[0] = "BH";
field[1] = NULL;
bh = IndexBuild("lz0.dbf", field, "lz0", BTREE_FOR_CLOSEDBF);
IndexClose(bh);
ProcessDetach();
return 0;
ProcessAttach();
df = dAwake("e:\\wmtasql\\ls.dbf", DOPENPARA);
ProcessDetach();
return 0;
get1rec(df);
dbtFromFile(df, 1, "e:\\wmtasql\\debug\\a1");
put_fld(df, 0, "1");
putrec(df);
get1rec(df);
dbtFromFile(df, 1, "e:\\wmtasql\\debug\\a2");
put_fld(df, 0, "2");
putrec(df);
get1rec(df);
dbtFromFile(df, 1, "e:\\wmtasql\\debug\\a3");
put_fld(df, 0, "3");
putrec(df);
dseek(df, 0, dSEEK_SET);
get1rec(df);
dbtFromFile(df, 1, "e:\\wmtasql\\debug\\aa.c");
put_fld(df, 0, "2");
put1rec(df);
dbtToFile(df, 1, "e:\\wmtasql\\debug\\bb.c");
dclose(df);
return 2;*/
/*strcpy(field[0].field,"ABCDEFGHIJKLMNOPQRSTUVWXYZ");
field[0].fieldtype = 'C';
field[0].fieldlen = 10;
field[0].fielddec = 0;
field[1].field[0] = '\0';
hBuildCodeLib( "d:\\code\\code.dbf" );
//return 0;
*/
/* ProcessAttach();
df = dopen("e:\\wmtasql\\ls.dbf", DOPENPARA);
dseek(df, 10, dSEEK_SET);
RecDelete(df);
dseek(df, 18, dSEEK_SET);
RecDelete(df);
dpack(df);
dclose(df);
ProcessDetach();
return 0;
*/
tscp1.packetType = 'Q';
tscp1.msgType = 'Q';
tscp1.len = strlen("lz0.dbf");
tscp1.lp = cmTS_OPEN_DBF;
memcpy(buff, &tscp1, sizeof(TS_COM_PROPS));
memcpy(buff+sizeof(TS_COM_PROPS), "lz0.dbf", 8);
justRunASQL(buff, buff, 4096);
ll = l = ((TS_COM_PROPS *)buff)->lp;
tscp1.packetType = 'Q';
tscp1.msgType = 'Q';
tscp1.len = 8;
tscp1.lp = cmTS_REC_FETCH;
memcpy(buff, &tscp1, sizeof(TS_COM_PROPS));
memcpy(buff+sizeof(TS_COM_PROPS), &l, 4);
l = 1;
memcpy(buff+sizeof(TS_COM_PROPS)+4, &l, 4);
justRunASQL(buff, buff, 4096);
tscp1.packetType = 'Q';
tscp1.msgType = 'Q';
tscp1.len = 8;
tscp1.lp = cmTS_CLOSE_DBF;
memcpy(buff, &tscp1, sizeof(TS_COM_PROPS));
memcpy(buff+sizeof(TS_COM_PROPS), &ll, 4);
justRunASQL(buff, buff, 4096);
return 0;
buf[0] = "thread0 ";
buf[1] = "thread1 ";
buf[2] = "thread2 ";
buf[3] = "thread3 ";
buf[4] = "thread4 ";
buf[5] = "thread5 ";
buf[6] = "thread6 ";
ProcessAttach();
printf("init success\n");
hsem = CreateSemaphore(NULL, 1, 1, NULL);
j = wmtAskQS(1234, "Tgask", AsqlExprInFile|Asql_USEENV, &asqlEnv, NULL, NULL, buff, 255, hsem);
if( j >= asqlTaskThreadNum )
printf("no thread to service\n");
else
printf("thread %d is servicing\n", j);
{
MSG msg1;
while( 1 ) {
GetMessage(&msg1, NULL, 0, 65535);
printf("message received: %d\n", msg1.message);
if( msg1.message == ASQL_ENDTASK_MSG ) {
break;
}
}
ReleaseSemaphore(hsem, 1, NULL);
}
CloseHandle(hsem);
printf("asql finish. return value %s", buff);
ProcessDetach();
return 0;
}
static void test_signalandwait(void)
{
DWORD (WINAPI *pSignalObjectAndWait)(HANDLE, HANDLE, DWORD, BOOL);
HMODULE kernel32;
DWORD r;
int i;
HANDLE event[2], maxevents[MAXIMUM_WAIT_OBJECTS], semaphore[2], file;
kernel32 = GetModuleHandle("kernel32");
pSignalObjectAndWait = (void*) GetProcAddress(kernel32, "SignalObjectAndWait");
if (!pSignalObjectAndWait)
return;
/* invalid parameters */
r = pSignalObjectAndWait(NULL, NULL, 0, 0);
if (r == ERROR_INVALID_FUNCTION)
{
skip("SignalObjectAndWait is not implemented\n");
return; /* Win98/ME */
}
ok( r == WAIT_FAILED, "should fail\n");
event[0] = CreateEvent(NULL, 0, 0, NULL);
event[1] = CreateEvent(NULL, 1, 1, NULL);
ok( event[0] && event[1], "failed to create event flags\n");
r = pSignalObjectAndWait(event[0], NULL, 0, FALSE);
ok( r == WAIT_FAILED, "should fail\n");
r = pSignalObjectAndWait(NULL, event[0], 0, FALSE);
ok( r == WAIT_FAILED, "should fail\n");
/* valid parameters */
r = pSignalObjectAndWait(event[0], event[1], 0, FALSE);
ok( r == WAIT_OBJECT_0, "should succeed\n");
/* event[0] is now signalled */
r = pSignalObjectAndWait(event[0], event[0], 0, FALSE);
ok( r == WAIT_OBJECT_0, "should succeed\n");
/* event[0] is not signalled */
r = WaitForSingleObject(event[0], 0);
ok( r == WAIT_TIMEOUT, "event was signalled\n");
r = pSignalObjectAndWait(event[0], event[0], 0, FALSE);
ok( r == WAIT_OBJECT_0, "should succeed\n");
/* clear event[1] and check for a timeout */
ok(ResetEvent(event[1]), "failed to clear event[1]\n");
r = pSignalObjectAndWait(event[0], event[1], 0, FALSE);
ok( r == WAIT_TIMEOUT, "should timeout\n");
CloseHandle(event[0]);
CloseHandle(event[1]);
/* create the maximum number of events and make sure
* we can wait on that many */
for (i=0; i<MAXIMUM_WAIT_OBJECTS; i++)
{
maxevents[i] = CreateEvent(NULL, 1, 1, NULL);
ok( maxevents[i] != 0, "should create enough events\n");
}
r = WaitForMultipleObjects(MAXIMUM_WAIT_OBJECTS, maxevents, 0, 0);
ok( r != WAIT_FAILED && r != WAIT_TIMEOUT, "should succeed\n");
for (i=0; i<MAXIMUM_WAIT_OBJECTS; i++)
if (maxevents[i]) CloseHandle(maxevents[i]);
/* semaphores */
semaphore[0] = CreateSemaphore( NULL, 0, 1, NULL );
semaphore[1] = CreateSemaphore( NULL, 1, 1, NULL );
ok( semaphore[0] && semaphore[1], "failed to create semaphore\n");
r = pSignalObjectAndWait(semaphore[0], semaphore[1], 0, FALSE);
ok( r == WAIT_OBJECT_0, "should succeed\n");
r = pSignalObjectAndWait(semaphore[0], semaphore[1], 0, FALSE);
ok( r == WAIT_FAILED, "should fail\n");
r = ReleaseSemaphore(semaphore[0],1,NULL);
ok( r == FALSE, "should fail\n");
r = ReleaseSemaphore(semaphore[1],1,NULL);
ok( r == TRUE, "should succeed\n");
CloseHandle(semaphore[0]);
CloseHandle(semaphore[1]);
/* try a registry key */
file = CreateFile("x", GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE, NULL);
r = pSignalObjectAndWait(file, file, 0, FALSE);
ok( r == WAIT_FAILED, "should fail\n");
ok( ERROR_INVALID_HANDLE == GetLastError(), "should return invalid handle error\n");
CloseHandle(file);
}
// file: kernelfile.cpp
// author: Aleksandar Abu-Samra
#include "kernelfile.h"
#include "semaphores.h"
#include "drive.h"
#include "rootcluster.h"
#include "datacluster.h"
HANDLE partitionAccessMutex = CreateSemaphore(NULL, 1, 32, NULL);
HANDLE numOfFilesMutex = CreateSemaphore(NULL, 1, 32, NULL);
KernelFile::KernelFile(char *fname, char mode, Entry entry, Drive *drive) {
strcpy(this->fname, fname);
this->mode = mode;
this->entry = entry;
this->drive = drive;
cluster = new DataCluster(drive);
switch (mode) {
case 'r': pointer = 0;
break;
case 'w': pointer = 0;
truncate();
break;
case 'a': pointer = entry.size;
seek(pointer);
break;
}
Thread::Thread() : mRunning(true)
{
mThreadHnd = CreateThread(0, 0, ThreadFunction, this, 0, 0);
mSemaphore = CreateSemaphore(0, 0, 0xFFFF, 0);
}
//
// COutputQueue Constructor :
//
// Determines if a thread is to be created and creates resources
//
// pInputPin - the downstream input pin we're queueing samples to
//
// phr - changed to a failure code if this function fails
// (otherwise unchanges)
//
// bAuto - Ask pInputPin if it can block in Receive by calling
// its ReceiveCanBlock method and create a thread if
// it can block, otherwise not.
//
// bQueue - if bAuto == FALSE then we create a thread if and only
// if bQueue == TRUE
//
// lBatchSize - work in batches of lBatchSize
//
// bBatchEact - Use exact batch sizes so don't send until the
// batch is full or SendAnyway() is called
//
// lListSize - If we create a thread make the list of samples queued
// to the thread have this size cache
//
// dwPriority - If we create a thread set its priority to this
//
COutputQueue::COutputQueue(
IPin *pInputPin, // Pin to send stuff to
__inout HRESULT *phr, // 'Return code'
BOOL bAuto, // Ask pin if queue or not
BOOL bQueue, // Send through queue
LONG lBatchSize, // Batch
BOOL bBatchExact, // Batch exactly to BatchSize
LONG lListSize,
DWORD dwPriority,
bool bFlushingOpt // flushing optimization
) : m_lBatchSize(lBatchSize),
m_bBatchExact(bBatchExact && (lBatchSize > 1)),
m_hThread(NULL),
m_hSem(NULL),
m_List(NULL),
m_pPin(pInputPin),
m_ppSamples(NULL),
m_lWaiting(0),
m_evFlushComplete(FALSE, phr),
m_pInputPin(NULL),
m_bSendAnyway(FALSE),
m_nBatched(0),
m_bFlushing(FALSE),
m_bFlushed(TRUE),
m_bFlushingOpt(bFlushingOpt),
m_bTerminate(FALSE),
m_hEventPop(NULL),
m_hr(S_OK)
{
ASSERT(m_lBatchSize > 0);
if (FAILED(*phr)) {
return;
}
// Check the input pin is OK and cache its IMemInputPin interface
*phr = pInputPin->QueryInterface(IID_IMemInputPin, (void **)&m_pInputPin);
if (FAILED(*phr)) {
return;
}
// See if we should ask the downstream pin
if (bAuto) {
HRESULT hr = m_pInputPin->ReceiveCanBlock();
if (SUCCEEDED(hr)) {
bQueue = hr == S_OK;
}
}
// Create our sample batch
m_ppSamples = new PMEDIASAMPLE[m_lBatchSize];
if (m_ppSamples == NULL) {
*phr = E_OUTOFMEMORY;
return;
}
// If we're queueing allocate resources
if (bQueue) {
DbgLog((LOG_TRACE, 2, TEXT("Creating thread for output pin")));
m_hSem = CreateSemaphore(NULL, 0, 0x7FFFFFFF, NULL);
if (m_hSem == NULL) {
DWORD dwError = GetLastError();
*phr = AmHresultFromWin32(dwError);
return;
}
m_List = new CSampleList(NAME("Sample Queue List"),
lListSize,
FALSE // No lock
);
if (m_List == NULL) {
*phr = E_OUTOFMEMORY;
return;
}
DWORD dwThreadId;
m_hThread = CreateThread(NULL,
0,
InitialThreadProc,
(LPVOID)this,
0,
&dwThreadId);
if (m_hThread == NULL) {
DWORD dwError = GetLastError();
*phr = AmHresultFromWin32(dwError);
return;
}
SetThreadPriority(m_hThread, dwPriority);
} else {
DbgLog((LOG_TRACE, 2, TEXT("Calling input pin directly - no thread")));
}
}