int main(int argc, char *argv[]) { BIO *acc, *client; THREAD_TYPE tid; init_OpenSSL( ); acc = BIO_new_accept(PORT); if (!acc) int_error("Error creating server socket"); if (BIO_do_accept(acc) <= 0) int_error("Error binding server socket"); for (;;) { if (BIO_do_accept(acc) <= 0) int_error("Error accepting connection"); client = BIO_pop(acc); THREAD_CREATE(tid, server_thread, client); } BIO_free(acc); return 0; }
fast_mtq fast_mtq_start_stop_init(int threads, fast_mtq_cb cb, void *arg, fast_mtq_start_cb start_cb, fast_mtq_stop_cb stop_cb) { fast_mtq f_mtq; int i; log_debug("Fast mtq init, threads:%d", threads); f_mtq = (fast_mtq) malloc(sizeof(_fast_mtq) + (threads * sizeof(THREAD_VAR))); memset(f_mtq, 0, sizeof(_fast_mtq)); f_mtq->threads = threads; f_mtq->cb = cb; f_mtq->start_cb = start_cb; f_mtq->stop_cb = stop_cb; f_mtq->arg = arg; f_mtq->shutdown = 0; f_mtq->first = NULL; f_mtq->last = NULL; f_mtq->queue = 0; SEM_INIT(f_mtq->sem); COND_INIT(f_mtq->cond); for (i = 0; i < f_mtq->threads; i++) { THREAD_CREATE(f_mtq->threads_table[i], fast_mtq_thread, f_mtq); } return f_mtq; }
static void setup(void) { running = true; config = UA_ServerConfig_new_default(); server = UA_Server_new(config); UA_Server_run_startup(server); THREAD_CREATE(server_thread, serverloop); }
void on_button_Connect_clicked(GtkWidget* w, gpointer data) { int index = GPOINTER_TO_INT(data); struct connectThreadArg_s* arg; /* First, check to see if the requested mobot is a DOF. If it is, we must * ensure that the dongle has been connected. */ if( (strlen(g_robotManager->getEntry(index)) == 4) && ( g_mobotParent == NULL || ( ((mobot_t*)g_mobotParent)->connected == 0 ) ) ) { /* Trying to connect to a DOF, but there is no dongle connected. Open the * connect-dongle dialog */ g_mobotParent = (recordMobot_t*)malloc(sizeof(recordMobot_t)); RecordMobot_init(g_mobotParent, "Dongle"); askConnectDongle(); /* If the dongle is still not connected, just return */ if( (g_mobotParent == NULL) || (((mobot_t*)g_mobotParent)->connected == 0)) { return; } } arg = (struct connectThreadArg_s*)malloc(sizeof(struct connectThreadArg_s)); arg->connectIndex = index; arg->connectionCompleted = 0; gtk_widget_set_sensitive(w, FALSE); THREAD_T thread; THREAD_CREATE(&thread, connectThread, arg); g_timeout_add(500, progressBarConnectUpdate, arg); }
bool Trace::ConnectToFileAndStart(char *filename, unsigned int trace_index, int register_size, int register_count, bool is_big_endian) { trace_index_ = trace_index; is_big_endian_ = is_big_endian; register_size_ = register_size; register_count_ = register_count; RWLOCK_INIT(db_lock_); MUTEX_INIT(backing_mutex_); registers_.resize(register_count_); #ifdef _WIN32 fd_ = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); #else fd_ = open(filename, O_RDONLY); if (fd_ == -1) { printf("ERROR: file open failed\n"); return false; } #endif if (!remap_backing(sizeof(struct change))) { printf("ERROR: remap backing failed\n"); return false; } THREAD_CREATE(thread, thread_entry, this); return true; }
VOID ServiceConnection(IACP *iacp) { THREAD tid; CLIENT *client; static CHAR *fid = "ServiceConnection"; BlockOnShutdown(); /* Grab the next available CLIENT slot */ if ((client = NextAvailableClient(iacp)) == NULL) { LogMsg(LOG_WARN, "WARNING: new connection rejected (threshold reached)"); BreakNewConnection(iacp, IACP_ALERT_SERVER_BUSY); return; } /* Otherwise, leave behind a thread to deal with it */ if (!THREAD_CREATE(&tid, ServiceThread, client)) { LogMsg(LOG_ERR, "%s: %s: THREAD_CREATE: %s", client->ident, fid, strerror(errno)); BreakNewConnection(iacp, IACP_ALERT_SERVER_FAULT); return; } THREAD_DETACH(tid); }
void StartSignalHandler(QHLP_PAR *arg) { int status; THREAD tid; sigset_t set; static char *fid = "StartSignalHandler"; par = arg; /* Block all signals */ /* We keep the pthread specific function in place because there is no * easy way to emulate this under Windows. This should not be a problem * because this whole section is ifdef'd out under Windows and is known to * work under Solaris/Linux (where the THREAD macros are pthread based). */ sigfillset(&set); pthread_sigmask(SIG_SETMASK, &set, NULL); /* Create signal handling thread to catch all nondirected signals */ if (!THREAD_CREATE(&tid, SignalHandlerThread, (void *) NULL)) { LogMsg("%s: THREAD_CREATE: %s", fid, strerror(errno)); Exit(MY_MOD_ID); } }
static void setup(void) { running = true; server = UA_Server_new(); UA_ServerConfig_setDefault(UA_Server_getConfig(server)); UA_Server_run_startup(server); THREAD_CREATE(server_thread, serverloop); }
/* ============================================================================= * thread_startup * -- Create pool of secondary threads * -- numThread is total number of threads (primary + secondaries) * ============================================================================= */ void thread_startup (long numThread) { long i; global_numThread = numThread; global_doShutdown = FALSE; /* Set up barrier */ assert(global_barrierPtr == NULL); global_barrierPtr = THREAD_BARRIER_ALLOC(numThread); assert(global_barrierPtr); THREAD_BARRIER_INIT(global_barrierPtr, numThread); #ifdef MAP_USE_TFAVLTREE #ifdef SEPERATE_MAINTENANCE thread_done = (bool_t *)malloc((numThread -4) * sizeof(bool_t)); for(i = 0; i < numThread -4; i++) { thread_done[i] = FALSE; } /* assert(global_barrierPtr2 == NULL); */ /* global_barrierPtr2 = THREAD_BARRIER_ALLOC(numThread-4); */ /* assert(global_barrierPtr2); */ /* THREAD_BARRIER_INIT(global_barrierPtr2, numThread-4); */ /* assert(global_barrierPtr3 == NULL); */ /* global_barrierPtr3 = THREAD_BARRIER_ALLOC(4); */ /* assert(global_barrierPtr3); */ /* THREAD_BARRIER_INIT(global_barrierPtr3, 4); */ #endif #endif /* Set up ids */ THREAD_LOCAL_INIT(global_threadId); assert(global_threadIds == NULL); global_threadIds = (long*)malloc(numThread * sizeof(long)); assert(global_threadIds); for (i = 0; i < numThread; i++) { global_threadIds[i] = i; } /* Set up thread list */ assert(global_threads == NULL); global_threads = (THREAD_T*)malloc(numThread * sizeof(THREAD_T)); assert(global_threads); /* Set up pool */ THREAD_ATTR_INIT(global_threadAttr); for (i = 1; i < numThread; i++) { THREAD_CREATE(global_threads[i], global_threadAttr, &threadWait, &global_threadIds[i]); } /* * Wait for primary thread to call thread_start */ }
void msocket_server_start(msocket_server_t *self,const char *udpAddr,uint16_t udpPort,uint16_t tcpPort){ if(self != 0){ self->tcpPort = tcpPort; self->udpPort = udpPort; if(udpAddr != 0){ self->udpAddr = strdup(udpAddr); } msocket_sethandler(self->acceptSocket,&self->handlerTable,self->handlerArg); msocket_start_io(self->acceptSocket); #ifdef _WIN32 THREAD_CREATE(self->acceptThread,acceptTask,(void*) self,self->acceptThreadId); THREAD_CREATE(self->cleanupThread,cleanupTask,(void*) self,self->cleanupThreadId); #else THREAD_CREATE(self->acceptThread,acceptTask,(void*) self); THREAD_CREATE(self->cleanupThread,cleanupTask,(void*) self); #endif } }
static void setup(void) { running = true; config = UA_ServerConfig_new_default(); server = UA_Server_new(config); UA_Server_run_startup(server); THREAD_CREATE(server_thread, serverloop); /* Waiting server is up */ UA_comboSleep(1000); }
void Timer::start() { if (!active) { MUTEX_LOCK(game->timerMutex); active = true; THREAD_CREATE(jobThread, doTick, this, "Failed to start the timer!\n"); MUTEX_UNLOCK(game->timerMutex); } }
void StartLissReader(ISIDL_PAR *par) { THREAD tid; static char *fid = "StartLissReader"; if (!THREAD_CREATE(&tid, LissThread, (void *) par)) { LogMsg(LOG_INFO, "%s: THREAD_CREATE: LissThread: %s", fid, strerror(errno)); Exit(MY_MOD_ID + 1); } }
void Timer::insertJob(TimerJob *job) { DoInsertJobArg *arg = new DoInsertJobArg(); arg->game = game; arg->timer = this; arg->job = job; // insert job asynchronously to avoid deadlock when a function called by // a job inserts another job THREAD_CREATE(insertJobThread, doInsertJob, arg, "Failed to insert timer job!\n"); }
int lstage_newthread(lua_State *L,pool_t pool) { _DEBUG("Creating new thread for pool %p\n",pool); thread_t * thread=lua_newuserdata(L,sizeof(thread_t)); thread_t t=malloc(sizeof(struct thread_s)); t->th=calloc(1,sizeof(THREAD_T)); t->pool=pool; t->state=THREAD_IDLE; *thread=t; get_metatable(L); lua_setmetatable(L,-2); THREAD_CREATE(t->th, thread_mainloop, t, 0 ); return 1; }
static void setup(void) { running = true; config = UA_ServerConfig_new_default(); config->pubsubTransportLayers = (UA_PubSubTransportLayer *) UA_malloc(sizeof(UA_PubSubTransportLayer)); if(!config->pubsubTransportLayers) { UA_ServerConfig_delete(config); } config->pubsubTransportLayers[0] = UA_PubSubTransportLayerUDPMP(); config->pubsubTransportLayersSize++; server = UA_Server_new(config); UA_Server_run_startup(server); THREAD_CREATE(server_thread, serverloop); }
// Start the log parsing thread. void startup_logparse_thread(void) { int ret; LogQueue = new MLogmsgQueue(MAX_QUEUE_SIZE); HookQueue = new MFuncQueue(MAX_QUEUE_SIZE); ret=THREAD_CREATE(&logparse_thread_id, logparse_handler); if(ret != THREAD_OK) { // For now, we just exit if this fails. META_ERROR("Couldn't start thread for log parsing! Exiting..."); do_exit(1); } }
/* ============================================================================= * thread_startup * -- Create pool of secondary threads * -- numThread is total number of threads (primary + secondaries) * ============================================================================= */ void thread_startup (long numThread) { long i; totalThreads = numThread; global_numThread = numThread; global_doShutdown = FALSE; /* Set up barrier */ assert(global_barrierPtr == NULL); global_barrierPtr = THREAD_BARRIER_ALLOC(numThread); assert(global_barrierPtr); THREAD_BARRIER_INIT(global_barrierPtr, numThread); /* Set up ids */ THREAD_LOCAL_INIT(global_threadId); assert(global_threadIds == NULL); global_threadIds = (long*)malloc(numThread * sizeof(long)); assert(global_threadIds); for (i = 0; i < numThread; i++) { global_threadIds[i] = i; } /* Set up thread list */ assert(global_threads == NULL); global_threads = (THREAD_T*)malloc(numThread * sizeof(THREAD_T)); assert(global_threads); threadArgsArr = (thread_args_t*) malloc(numThread * sizeof(thread_args_t)); threadArgsArr[0].aborts = 0; threadArgsArr[0].commits = 0; threadArgsArr[0].threadId = global_threadIds[0]; /* Set up pool */ THREAD_ATTR_INIT(global_threadAttr); for (i = 1; i < numThread; i++) { threadArgsArr[i].aborts = 0; threadArgsArr[i].commits = 0; threadArgsArr[i].threadId = global_threadIds[i]; THREAD_CREATE(global_threads[i], global_threadAttr, &threadWait, &(threadArgsArr[i])); } /* * Wait for primary thread to call thread_start */ }
boolean extract_emergency_phr(char *phr_download_to_path, void (*backend_alert_msg_callback_handler_ptr)(char *alert_msg)) { // Setup a callback handler backend_alert_msg_callback_handler = backend_alert_msg_callback_handler_ptr; // Passing variable ptr_phr_download_to_path = &phr_download_to_path; init_main(); // Create an emergency PHR extraction thread if(THREAD_CREATE(emergency_phr_extraction_thread_id, extract_emergency_phr_main, NULL) != 0) int_error("Creating a thread for \"extract_emergency_phr_main\" failed"); while(1) { if(sem_wait(&wake_up_main_thread_mutex) != 0) int_error("Locking the mutex failed"); // The emergency PHR extraction thread terminated if(emergency_phr_extraction_thread_terminated_flag) break; // Send an error message to frontend if(strlen(err_msg_to_frontend) > 0) { backend_alert_msg_handler_callback(err_msg_to_frontend); strcpy(err_msg_to_frontend, ""); if(sem_post(&confirm_err_msg_sending_to_frontend_mutex) != 0) int_error("Unlocking the mutex failed"); } } // Join the emergency PHR extraction thread if(THREAD_JOIN(emergency_phr_extraction_thread_id) != 0) int_error("Joining a thread \"extract_emergency_phr_main\" failed"); // Send signal to confirm that the emergency PHR extraction thread has been terminated if the action was performed by a cancellation thread if(emergency_phr_extracting_cancellation_flag) { if(sem_post(&send_signal_to_confirm_cancellation_thread_mutex) != 0) int_error("Unlocking the mutex failed"); if(sem_wait(&cancellation_thread_got_confirmation_mutex) != 0) int_error("Locking the mutex failed"); } uninit_main(); return transaction_success_status_flag; }
VOID StartStatusServer(PARAM *par) { THREAD tid; static UINT16 StaticPort; static char *fid = "StartStatusServer"; StaticPort = par->status; if (!THREAD_CREATE(&tid, StatusServer, (void *) &StaticPort)) { LogMsg(LOG_ERR, "%s: THREAD_CREATE: %s", fid, strerror(errno)); GracefulExit(MY_MOD_ID + 0); } THREAD_DETACH(tid); }
void on_button_playRecorded_clicked(GtkWidget*button, gpointer data) { GtkWidget *w; /* Disable the play button */ w = GTK_WIDGET(gtk_builder_get_object(g_builder, "button_playRecorded")); gtk_widget_set_sensitive(w, FALSE); teachingDialog_refreshRecordedMotions(0); /* Start the play thread */ g_haltPlayFlag = false; g_isPlaying = true; THREAD_T thread; THREAD_CREATE(&thread, playThread, NULL); g_timeout_add(200, poseGuiTimeout, NULL); }
/*---------------------------------------------------------------------*/ H_ARCHIVE ArchiveOpenForWrite(CHAR * path) { H_ARCHIVE harchive; ARCHIVE *archive; ArchiveLog(ARC_LOG_VERBOSE, "Open archive for write: %s", path); _archive_error = ARC_NO_ERROR; /* Get next available handle */ if ((harchive = GetNextHandle()) == VOID_H_ARCHIVE) return (VOID_H_ARCHIVE); _archive[harchive].last_error = ARC_NO_ERROR; /* Check out the path */ if (!ValidatePath(path, harchive)) return (VOID_H_ARCHIVE); /* Create stream list */ if (!CreateList(&_archive[harchive].streams)) { _archive_error = ARC_NO_MEMORY; return (VOID_H_ARCHIVE); } /* Get state and lock for write access */ if (!OpenStateForWrite(harchive)) { _archive_error = _archive[harchive].last_error; return (VOID_H_ARCHIVE); } _n_archives++; /* Start the purge thread... */ archive = &_archive[harchive]; if (archive->state.thres_bytes != VOID_UINT64) { MUTEX_LOCK(&archive->purge.mutex); if(!archive->purge.active ) { ArchiveLog(ARC_LOG_VERBOSE, "Starting purge thread"); if(!THREAD_CREATE(&archive->purge.thread_id, PurgeThread, &archive->purge)) { MUTEX_UNLOCK(&archive->purge.mutex); _archive_error = ARC_PURGE_THREAD; return (VOID_H_ARCHIVE); } } MUTEX_UNLOCK(&archive->purge.mutex); } return (harchive); }
void msocket_server_unix_start(msocket_server_t *self,const char *socketPath) { if(self != 0){ self->tcpPort = 0; self->udpPort = 0; if (socketPath != 0) { if (*socketPath=='\0') { int len=strlen(socketPath+1)+2; self->socketPath=(char*) malloc(len); if (self->socketPath != 0) { memcpy(self->socketPath+1,socketPath,len); } } else { self->socketPath=strdup(socketPath); #ifdef _WIN32 _unlink(socketPath); #else unlink(socketPath); #endif } } // msocket_sethandler(self->acceptSocket,&self->handlerTable,self->handlerArg); // msocket_start_io(self->acceptSocket); #ifdef _WIN32 THREAD_CREATE(self->acceptThread,acceptTask,(void*) self,self->acceptThreadId); THREAD_CREATE(self->cleanupThread,cleanupTask,(void*) self,self->cleanupThreadId); #else THREAD_CREATE(self->acceptThread,acceptTask,(void*) self); THREAD_CREATE(self->cleanupThread,cleanupTask,(void*) self); #endif } }
void FlushIsoImage() { THREAD tid; static char *fid = "FlushIsoImage"; MUTEX_LOCK(&LocalMutex); if (Enabled && !ActiveFlag) { ActiveFlag = TRUE; if (!THREAD_CREATE(&tid, FlushIsoImageThread, NULL)) { util_log(1, "%s: failed to start FlushIsoImageThread", fid); ispd_die(MY_MOD_ID + 2); } } MUTEX_UNLOCK(&LocalMutex); }
static void setup_lds(void) { // start LDS server running_lds = UA_Boolean_new(); *running_lds = true; server_lds = UA_Server_new(); configure_lds_server(server_lds); UA_Server_run_startup(server_lds); THREAD_CREATE(server_thread_lds, serverloop_lds); // wait until LDS started UA_fakeSleep(1000); UA_realSleep(1000); }
void* findDongleThread(void* arg) { static int args[MAX_COMPORT]; int i; THREAD_T threads[MAX_COMPORT]; for(i = 0; i < MAX_COMPORT; i++) { args[i] = i; } g_dongleSearchStatus = DONGLE_SEARCHING; /* Spawn worker threads to find the dongle on a com port */ for(i = 0; i < MAX_COMPORT; i++) { /* First, make sure there are less than MAX_THREADS running */ MUTEX_LOCK(&g_giant_lock); while( (g_numThreads >= MAX_THREADS) && (g_dongleSearchStatus == DONGLE_SEARCHING) ) { COND_WAIT(&g_giant_cond, &g_giant_lock); } if(g_dongleSearchStatus != DONGLE_SEARCHING) { i++; MUTEX_UNLOCK(&g_giant_lock); break; } /* Spawn a thread */ THREAD_CREATE(&threads[i], findDongleWorkerThread, &args[i]); g_numThreads++; MUTEX_UNLOCK(&g_giant_lock); } /* Join all threads */ int j; for(j = 0; j < i; j++) { MUTEX_LOCK(&g_giant_lock); if(g_dongleSearchStatus != DONGLE_SEARCHING) { MUTEX_UNLOCK(&g_giant_lock); break; } MUTEX_UNLOCK(&g_giant_lock); THREAD_JOIN(threads[j]); } MUTEX_LOCK(&g_giant_lock); if(g_dongleSearchStatus == DONGLE_SEARCHING) { g_dongleSearchStatus = DONGLE_NOTFOUND; } MUTEX_UNLOCK(&g_giant_lock); return NULL; }
int httpd_start(httpd_t *httpd, unsigned short *port) { assert(httpd); assert(port); MUTEX_LOCK(httpd->run_mutex); if (httpd->running || !httpd->joined) { MUTEX_UNLOCK(httpd->run_mutex); return 0; } httpd->server_fd4 = netutils_init_socket(port, 0, 0); if (httpd->server_fd4 == -1) { logger_log(httpd->logger, LOGGER_ERR, "Error initialising socket %d", SOCKET_GET_ERROR()); MUTEX_UNLOCK(httpd->run_mutex); return -1; } httpd->server_fd6 = netutils_init_socket(port, 1, 0); if (httpd->server_fd6 == -1) { logger_log(httpd->logger, LOGGER_WARNING, "Error initialising IPv6 socket %d", SOCKET_GET_ERROR()); logger_log(httpd->logger, LOGGER_WARNING, "Continuing without IPv6 support"); } if (listen(httpd->server_fd4, 5) == -1) { logger_log(httpd->logger, LOGGER_ERR, "Error listening to IPv4 socket"); closesocket(httpd->server_fd4); closesocket(httpd->server_fd6); MUTEX_UNLOCK(httpd->run_mutex); return -2; } if (httpd->server_fd6 != -1 && listen(httpd->server_fd6, 5) == -1) { logger_log(httpd->logger, LOGGER_ERR, "Error listening to IPv6 socket"); closesocket(httpd->server_fd4); closesocket(httpd->server_fd6); MUTEX_UNLOCK(httpd->run_mutex); return -2; } logger_log(httpd->logger, LOGGER_INFO, "Initialized server socket(s)"); /* Set values correctly and create new thread */ httpd->running = 1; httpd->joined = 0; THREAD_CREATE(httpd->thread, httpd_thread, httpd); MUTEX_UNLOCK(httpd->run_mutex); return 1; }
void *callback_server(void *ctx) { WSDualHttpBinding_USCOREICalculatorDuplexService *callback = (WSDualHttpBinding_USCOREICalculatorDuplexService*)ctx; THREAD_TYPE tid; callback->soap->accept_timeout = 10; /* server quits after 10 seconds of inactivity */ printf("\n**** Callback Server Running\n"); while (soap_valid_socket(callback->accept())) THREAD_CREATE(&tid, (void*(*)(void*))callback_thread, (void*)callback->copy()); printf("\n**** Callback Server Terminated\n"); return NULL; }
static void setup(void) { running = UA_Boolean_new(); *running = true; config = UA_ServerConfig_new_default(); config->maxPublishReqPerSession = 5; server = UA_Server_new(config); UA_Server_run_startup(server); addNewEventType(); setupSelectClauses(); THREAD_CREATE(server_thread, serverloop); client = UA_Client_new(UA_ClientConfig_default); UA_StatusCode retval = UA_Client_connect(client, "opc.tcp://localhost:4840"); ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD); setupSubscription(); }
void on_button_p1_next_clicked(GtkWidget* widget, gpointer data) { /* First, disable the widget so it cannot be clicked again */ gtk_widget_set_sensitive(widget, false); /* Make sure thread is joined */ THREAD_JOIN(g_mainSearchThread); /* Reset state vars */ g_dongleSearchStatus = DONGLE_SEARCHING; /* Start the main search thread */ THREAD_CREATE(&g_mainSearchThread, findDongleThread, NULL); /* Start the search timeout */ g_timeout_add(200, findDongleTimeout, NULL); }