void psync_set_event_callback(pevent_callback_t callback){ pthread_mutex_lock(&statusmutex); eventthreadrunning=1; pthread_mutex_unlock(&statusmutex); psync_list_init(&eventlist); psync_run_thread1("event", event_thread, callback); }
void overlay_main_loop(VOID) { BOOL fConnected = FALSE; HANDLE hPipe = INVALID_HANDLE_VALUE; HANDLE ghSemaphore; DWORD dwWaitResult; // The main loop creates an instance of the named pipe and // then waits for a client to connect to it. When the client // connects, a thread is created to handle communications // with that client, and this loop is free to wait for the // next client connect request. It is an infinite loop. 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; } for (;;) { //debug(D_NOTICE, "\nPipe Server: Main thread awaiting client connection on %s\n", PORT); dwWaitResult = WaitForSingleObject( ghSemaphore, // handle to semaphore INFINITE); // zero-second time-out interval hPipe = CreateNamedPipe( PORT, // pipe name PIPE_ACCESS_DUPLEX, // read/write access PIPE_TYPE_MESSAGE | // message type pipe PIPE_READMODE_MESSAGE | // message-read mode PIPE_WAIT, // blocking mode PIPE_UNLIMITED_INSTANCES, // max. instances POVERLAY_BUFSIZE, // output buffer size POVERLAY_BUFSIZE, // input buffer size 0, // client time-out NULL); // default security attribute if (hPipe == INVALID_HANDLE_VALUE) { //debug(D_NOTICE, "CreateNamedPipe failed, GLE=%d.\n", GetLastError()); return; } fConnected = ConnectNamedPipe(hPipe, NULL) ? TRUE : (GetLastError() == ERROR_PIPE_CONNECTED); if (fConnected) { //debug(D_NOTICE, "Client connected, creating a processing thread.\n"); // Create a thread for this client. psync_run_thread1( "Pipe request handle routine", instance_thread, // thread proc (LPVOID)hPipe // thread parameter ); } else CloseHandle(hPipe); if (!ReleaseSemaphore( ghSemaphore, // handle to semaphore 1, // increase count by one NULL)) // not interested in previous count { debug(D_WARNING,"ReleaseSemaphore error: %d\n", GetLastError()); } } CloseHandle(ghSemaphore); return; }
static void psync_p2p_thread(){ ssize_t ret; char buff[2048]; /* struct sockaddr_in6 addr; */ struct sockaddr_in addr4; psync_socket_t tcpsock, socks[2], *inconn; socklen_t sl; int sret; psync_wait_statuses_array(requiredstatuses, ARRAY_SIZE(requiredstatuses)); tcpsock=INVALID_SOCKET; /* udpsock=psync_create_socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP); if (unlikely_log(udpsock==INVALID_SOCKET)){*/ udpsock=psync_create_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if (unlikely_log(udpsock==INVALID_SOCKET)) goto ex; setsockopt(udpsock, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on)); memset(&addr4, 0, sizeof(addr4)); addr4.sin_family=AF_INET; addr4.sin_port =htons(PSYNC_P2P_PORT); addr4.sin_addr.s_addr=INADDR_ANY; if (unlikely_log(bind(udpsock, (struct sockaddr *)&addr4, sizeof(addr4))==SOCKET_ERROR)) goto ex; /* } else{ setsockopt(udpsock, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on)); memset(&addr, 0, sizeof(addr)); addr.sin6_family=AF_INET6; addr.sin6_port =htons(PSYNC_P2P_PORT); addr.sin6_addr =in6addr_any; if (unlikely_log(bind(udpsock, (struct sockaddr *)&addr, sizeof(addr))==SOCKET_ERROR)) goto ex; } tcpsock=psync_create_socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); if (unlikely_log(tcpsock==INVALID_SOCKET)){*/ tcpsock=psync_create_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (unlikely_log(tcpsock==INVALID_SOCKET)) goto ex; setsockopt(tcpsock, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on)); memset(&addr4, 0, sizeof(addr4)); addr4.sin_family=AF_INET; addr4.sin_port =htons(0); addr4.sin_addr.s_addr=INADDR_ANY; if (unlikely_log(bind(tcpsock, (struct sockaddr *)&addr4, sizeof(addr4))==SOCKET_ERROR)) goto ex; sl=sizeof(addr4); if (unlikely_log(getsockname(tcpsock, (struct sockaddr *)&addr4, &sl)==SOCKET_ERROR)) goto ex; tcpport=ntohs(addr4.sin_port); /* } else{ setsockopt(tcpsock, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on)); memset(&addr, 0, sizeof(addr)); addr.sin6_family=AF_INET6; addr.sin6_port =htons(0); addr.sin6_addr =in6addr_any; if (unlikely_log(bind(tcpsock, (struct sockaddr *)&addr, sizeof(addr))==SOCKET_ERROR)) goto ex; sl=sizeof(addr); if (unlikely_log(getsockname(tcpsock, (struct sockaddr *)&addr, &sl)==SOCKET_ERROR)) goto ex; tcpport=ntohs(addr.sin6_port); }*/ if (unlikely_log(listen(tcpsock, 2))) goto ex; socks[0]=udpsock; socks[1]=tcpsock; while (psync_do_run){ if (unlikely(!psync_setting_get_bool(_PS(p2psync)))){ pthread_mutex_lock(&p2pmutex); if (!psync_setting_get_bool(_PS(p2psync))){ running=0; psync_close_socket(tcpsock); psync_close_socket(udpsock); pthread_mutex_unlock(&p2pmutex); return; } pthread_mutex_unlock(&p2pmutex); } psync_wait_statuses_array(requiredstatuses, ARRAY_SIZE(requiredstatuses)); sret=psync_select_in(socks, 2, -1); if (unlikely_log(sret==-1)){ psync_milisleep(1); continue; } if (sret==0){ paddrlen=sizeof(paddr); ret=recvfrom(udpsock, buff, sizeof(buff), 0, (struct sockaddr *)&paddr, &paddrlen); if (likely_log(ret!=SOCKET_ERROR)) psync_p2p_process_packet(buff, ret); else psync_milisleep(1); } else if (sret==1){ inconn=psync_new(psync_socket_t); *inconn=accept(tcpsock, NULL, NULL); if (unlikely_log(*inconn==INVALID_SOCKET)) psync_free(inconn); else psync_run_thread1("p2p tcp", psync_p2p_tcphandler, inconn); } } ex: pthread_mutex_lock(&p2pmutex); running=0; psync_close_socket(tcpsock); psync_close_socket(udpsock); pthread_mutex_unlock(&p2pmutex); }
void psync_set_status_callback(pstatus_change_callback_t callback){ pthread_mutex_lock(&statusmutex); statusthreadrunning=1; pthread_mutex_unlock(&statusmutex); psync_run_thread1("status change", status_change_thread, callback); }
void psync_syncer_new(psync_syncid_t syncid){ psync_syncid_t *psid=psync_new(psync_syncid_t); *psid=syncid; psync_run_thread1("syncer", psync_do_sync_thread, psid); }