int main(int argc,char **argv) { mutil_thread = 0; setup_signal_handler(); init_clients(); InitNetSystem(); ENGINE engine = CreateEngine(); int csize = atoi(argv[3]); int i = 0; for(; i < csize; ++i) EConnect(engine,argv[1],atoi(argv[2]),(void*)engine,on_connect,1000); uint32_t tick,now; tick = now = GetSystemMs(); while(!stop) { EngineRun(engine,50); sendpacket(); now = GetSystemMs(); if(now - tick > 1000) { printf("ava_interval:%d\n",ava_interval); tick = now; } } CleanNetSystem(); return 0; }
int main(int argc,char **argv) { init_net_service(); ip = argv[1]; port = atoi(argv[2]); uint32_t thread_count = atoi(argv[3]); init_clients(); netservice_t n = create_net_service(thread_count); net_add_listener(n,ip,port); msg_loop_t m = create_msg_loop(server_process_packet,process_new_connection,process_connection_disconnect,process_send_block); uint32_t now; uint32_t tick = GetSystemMs(); while(1) { msg_loop_once(m,n,100); now = GetSystemMs(); if(now - tick > 1000) { printf("total send:%u,total_recv:%u\n",isusecount,total_bytes_recv/1024/1024); //printf("w:%d,r:%d,b:%d\n",wpacket_count,rpacket_count,buf_count); tick = now; total_bytes_recv = 0; send_count = 0; } } return 0; }
int main(int argc, char *argv[]) { if (argc < 3) { printf("Not enough arguments"); exit(1); } key_t habit = ftok(argv[1], atoi(argv[2])); if (habit < 0) { perror(NULL); exit(1); } zakonnica = msgget(habit, IPC_CREAT | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); if (zakonnica == -1) { perror(NULL); exit(2); } signal(SIGINT, handler); srand(time(NULL)); atexit(close); init_clients(); while (1) { struct msg message; if (msgrcv(zakonnica, &message, sizeof(message), 0, IPC_NOWAIT) >= 0) { long type = message.mtype; switch (type) { case NEWCLNT: { int new_id = get_id(); if (new_id !=-1) { int cl = message.client_id; clients[new_id] = message.client_id; message.mtype = SERACCLIENT; message.client_id = new_id; if (msgsnd(cl, &message, sizeof(message), 0)) { perror(NULL); exit(2); } } break; } case CLRESP: { if (message.is_prime) { printf("Liczba pierwsza: %d klient %d\n", message.number, message.client_id); } break; } case GETNEXT: { message.number = rand() % 10000; msgsnd(clients[message.client_id], &message, sizeof(message), 0); break; } default: break; } } } }
int main(int argc,char **argv) { HANDLE engine; uint32_t n; ip = argv[1]; port = atoi(argv[2]); signal(SIGPIPE,SIG_IGN); if(InitNetSystem() != 0) { printf("Init error\n"); return 0; } wpacket_allocator = (allocator_t)create_block_obj_allocator(0,sizeof(struct wpacket)); uint32_t i = 0; //getchar(); //init_wpacket_pool(100000); //init_rpacket_pool(50000); //buffer_init_maxbuffer_size(2000); //buffer_init_64(2000); init_clients(); engine = CreateEngine(); thread_run(_Listen,&engine); tick = GetSystemMs(); while(1) { EngineRun(engine,15); now = GetSystemMs(); if(now - tick > 1000) { printf("recv:%u,send:%u,s_req:%u\n",packet_recv,packet_send,send_request); tick = now; packet_recv = 0; packet_send = 0; send_request = 0; s_p = 0; iocp_count = 0; recv_count = 0; } /*if(now - last_send_tick > 50) { //心跳,每50ms集中发一次包 last_send_tick = now; for(i=0; i < MAX_CLIENT; ++i) { if(clients[i]) { //++send_request; connection_send(clients[i],0,0); } } }*/ } return 0; }
int main(int argc,char **argv) { HANDLE engine; uint32_t n; init_system_time(10); ip = argv[1]; port = atoi(argv[2]); signal(SIGPIPE,SIG_IGN); if(InitNetSystem() != 0) { printf("Init error\n"); return 0; } wpacket_allocator = (allocator_t)create_block_obj_allocator(SINGLE_THREAD,sizeof(struct wpacket)); uint32_t i = 0; init_clients(); engine = CreateEngine(); thread_run(_Listen,&engine); tick = GetSystemMs(); while(1) { EngineRun(engine,100); now = GetSystemMs(); if(now - tick > 1000) { printf("recv:%u,send:%u,s_req:%u,total_recv:%u\n",packet_recv,packet_send,send_request,total_bytes_recv/1024/1024); tick = now; packet_recv = 0; packet_send = 0; send_request = 0; iocp_count = 0; total_bytes_recv = 0; //printf("w:%d,r:%d,b:%d\n",wpacket_count,rpacket_count,buf_count); } /* if(now - last_send_tick > 10) { last_send_tick = now; for(i=0; i < MAX_CLIENT; ++i) { if(clients[i]) { connection_send(clients[i],NULL,NULL); } } }*/ } return 0; }
int32_t main() { DWORD dwThread; HANDLE iocp; uint32_t n; uint32_t i = 0; //getchar(); init_wpacket_pool(10000000); init_rpacket_pool(500000); buffer_init_maxbuffer_size(2000); buffer_init_64(2000); init_clients(); InitNetSystem(); iocp = CreateNetEngine(1); CreateThread(NULL,0,Listen,&iocp,0,&dwThread); tick = GetTickCount(); while(1) { RunEngine(iocp,15); /*now = GetTickCount(); if(now - tick > 1000) { printf("recv:%u,send:%u,s_req:%u,pool_size:%u,bf:%u,sp:%u,iocp:%u\n",packet_recv,packet_send,send_request,wpacket_pool_size(),bf_count,s_p,iocp_count); tick = now; packet_recv = 0; packet_send = 0; send_request = 0; s_p = 0; iocp_count = 0; } if(now - last_send_tick > 50) { //心跳,每50ms集中发一次包 last_send_tick = now; for(i=0; i < MAX_CLIENT; ++i) { if(clients[i]) { ++send_request; connection_send(clients[i],0,0); } } }*/ } return 0; }
int main(int argc,char **argv) { mutil_thread = 0; setup_signal_handler(); init_clients(); InitNetSystem(); struct netservice *tcpserver = new_service(); tcpserver->listen(tcpserver,argv[1],atoi(argv[2]),(void*)tcpserver,accept_client); uint32_t tick,now; tick = now = GetSystemMs(); while(!stop){ tcpserver->loop(tcpserver,50); now = GetSystemMs(); if(now - tick > 1000) { printf("client_count:%d,send_count:%d\n",client_count,(packet_send_count*1000)/(now-tick)); tick = now; packet_send_count = 0; } } destroy_service(&tcpserver); CleanNetSystem(); return 0; }
int main(int argc, char *argv[]){ key_t key; if( (key = ftok(CHAT_PATH,CHAT_KEY)) == -1) print_error(errno, "ftok error"); int registration_queue; if( (registration_queue = msgget(key, IPC_CREAT | 0600)) == -1) print_error(errno, "msgget error"); struct message message; struct client *clients = malloc(sizeof(struct client) * MAX_CLIENTS_NUMBER); init_clients(clients); while(1){ usleep(500000); if(msgrcv(registration_queue, &message, MAX_CLIENT_NAME_LENGTH, 0, IPC_NOWAIT) == -1){ if(errno == E2BIG) print_error(errno, "client name too long"); else if (errno != ENOMSG) // empty queue is ok print_error(errno, "msgrcv server_queue error"); } else { int i; for(i = 0; i < MAX_CLIENTS_NUMBER; i++){ if(clients[i].name[0] == '\0') break; } if(clients[i].name[0] != '\0') print_error(errno, "maximum number of clients already reached"); else { key_t tmp_client_key; strcpy(clients[i].name, message.message); if( (tmp_client_key = ftok(CHAT_PATH, message.type)) == -1) print_error(errno, "ftok client error"); if( (clients[i].queue = msgget(tmp_client_key, 0600)) == -1) print_error(errno, "msgget klient error"); char *info1 = "------------ "; char *info2 =" has joined the channel ------------\n"; char m[strlen(info1) + strlen(info2) + strlen(clients[i].name) + 1]; strcpy(m, info1); strcat(m, clients[i].name); strcat(m, info2); send_message(m, i, clients); } } int i; for(i = 0; i < MAX_CLIENTS_NUMBER; i++){ if(clients[i].name[0] != '\0'){ if(msgrcv(clients[i].queue, &message, MAX_MESSAGE_SIZE, CLIENT_TO_SERVER, IPC_NOWAIT) == -1){ int tmp_errno = errno; if(tmp_errno == EINVAL){ char *info1 = "------------ "; char *info2 =" has left the channel ------------"; char m[strlen(info1) + strlen(info2) + strlen(clients[i].name) + 1]; strcpy(m, info1); strcat(m, clients[i].name); strcat(m, info2); clients[i].name[0] = '\0'; send_message(m, i, clients); } else if (tmp_errno != ENOMSG) print_error(tmp_errno, "error in msgrcv in message reciver loop"); } else if (strcmp(message.message, "exit\n") !=0){ send_message(message.message, i, clients); } } } } }
int main(int argc, char *argv[]) { struct mq_attr attr; attr.mq_flags = 0; attr.mq_maxmsg = 10; attr.mq_msgsize = MAX_SIZE; attr.mq_curmsgs = 1; char message[MAX_SIZE + 1]; zakonnica = mq_open("/server", O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR, &attr); if (zakonnica == -1) { perror("open queue"); exit(1); } signal(SIGINT, handler); srand(time(NULL)); atexit(clean); init_clients(); while (1) { if (mq_receive(zakonnica, message, MAX_SIZE, 0) >= 0) { long type = message[0]; switch (type) { case NEWCLNT: { int new_id = get_id(); int cl_q = -1; if (new_id != -1) { cl_q = mq_open(message + 1, O_WRONLY, 0, &attr); clients[new_id] = cl_q; if (cl_q == -1) new_id = -1; } message[0] = SERACCLIENT; sprintf(message + 1, "%d", new_id); if (mq_send(cl_q, message, MAX_SIZE, 0)) { perror("send"); exit(2); } break; } case CLRESP: { int clientid; int number; int isprime; sscanf(message + 1, "%d %d %d", &clientid, &number, &isprime); if (isprime) { printf("Liczba pierwsza: %d klient %d\n", number, clientid); } break; } case GETNEXT: { int tmp = rand() % 100; int cl_q; sscanf(message + 1, "%d", &cl_q); sprintf(message + 1, "%d", tmp); if (mq_send(clients[cl_q], message, MAX_SIZE, 0) < 0) { perror(NULL); } break; } case CLSCLNT: { int client_id; sscanf(message + 1, "%d", &client_id); mq_close(clients[client_id]); clients[client_id] = -1; break; } default: break; } } } }
int main(int argc, char **argv) { int i, ret, become_daemon = 1; for(i=1; i<argc; i++) { if(argv[i][0] == '-' && argv[i][2] == 0) { switch(argv[i][1]) { case 'd': become_daemon = !become_daemon; break; case 'v': verbose = 1; break; case 'h': printf("usage: %s [options]\n", argv[0]); printf("options:\n"); printf(" -d\tdo not daemonize\n"); printf(" -v\tverbose output\n"); printf(" -h\tprint this usage information\n"); return 0; default: fprintf(stderr, "unrecognized argument: %s\n", argv[i]); return 1; } } else { fprintf(stderr, "unexpected argument: %s\n", argv[i]); return 1; } } if(become_daemon) { daemonize(); } write_pid_file(); puts("Spacenav daemon " VERSION); read_cfg("/etc/spnavrc", &cfg); if(init_clients() == -1) { return 1; } signal(SIGINT, sig_handler); signal(SIGTERM, sig_handler); signal(SIGSEGV, sig_handler); signal(SIGHUP, sig_handler); signal(SIGUSR1, sig_handler); signal(SIGUSR2, sig_handler); if(init_dev() == -1) { init_hotplug(); } init_unix(); #ifdef USE_X11 init_x11(); #endif atexit(cleanup); for(;;) { fd_set rset; int fd, max_fd = 0; struct client *c; FD_ZERO(&rset); /* set the device fd if it's open, otherwise set the hotplug fd */ if((fd = get_dev_fd()) != -1 || (fd = get_hotplug_fd()) != -1) { FD_SET(fd, &rset); if(fd > max_fd) max_fd = fd; } /* the UNIX domain socket listening for connections */ if((fd = get_unix_socket()) != -1) { FD_SET(fd, &rset); if(fd > max_fd) max_fd = fd; } /* all the UNIX socket clients */ c = first_client(); while(c) { if(get_client_type(c) == CLIENT_UNIX) { int s = get_client_socket(c); assert(s >= 0); FD_SET(s, &rset); if(s > max_fd) max_fd = s; } c = next_client(); } /* and the X server socket */ #ifdef USE_X11 if((fd = get_x11_socket()) != -1) { FD_SET(fd, &rset); if(fd > max_fd) max_fd = fd; } #endif do { ret = select(max_fd + 1, &rset, 0, 0, 0); } while(ret == -1 && errno == EINTR); if(ret > 0) { handle_events(&rset); } } return 0; /* unreachable */ }
int main(int argc,char *argv[]) { int socktemp; char message[MAX_MESSAGES]; int message_length; // Initialisation de la socket socketInit = socket (AF_INET,SOCK_STREAM ,IPPROTO_TCP ); if(socketInit==-1) { printf("\n ERREUR lors de la création de la socket côté serveur"); return -1; } struct sockaddr_in serveur,client; unsigned short port = atoi(argv[1]); //initialisation de la structure sockaddr_in serveur.sin_family = AF_INET; serveur.sin_port = port; serveur.sin_addr.s_addr = INADDR_ANY; // liaison de la socket avec l'adresse IP et port du serveur if (bind(socketInit, (struct sockaddr*) &serveur, sizeof(serveur)) == -1){ printf("ERREUR lors du bind côté serveur\n"); return -1; } // mise en ecoute du serveur if (listen(socketInit, MAX_CLIENTS) == -1){ printf("ERREUR lors du listen côté serveur\n"); return -1; } int lg_client; FD_ZERO(&set); // initialisation de la liste int maxsock = getdtablesize(); FD_SET(socketInit,&set); // ajout du socket du serveur dans la liste init_clients(); printf("\nServeur prêt : attente de clients...\n"); while (1) { bcopy ( (char*) &set, (char*) &setbis, sizeof(set)) ; // On réinitialise set à chaque fois select(maxsock, &setbis, 0, 0, 0); //Socket du serveur pret a etre lu: connexion d'un nouveau client if (FD_ISSET(socketInit, &setbis)) { socktemp = accept(socketInit,(struct sockaddr *)&client, &lg_client); if (socktemp == -1) { printf("Erreur lors de la connexion d'un client\n"); return -1; } else { ajouter_client(socktemp); // s'il n'y a pas d'erreur on ajoute le client } } for(int i=0;i<MAX_CLIENTS;i++) { //On vérifie si les clients ont une requête if(les_clients[i].socket!=-1 && FD_ISSET( les_clients[i].socket, &setbis)) { message_length = read(les_clients[i].socket,message, MAX_MESSAGES); message[message_length]='\0'; traiter_requete_client(i,message); } } } }
void WindowManager::init_internals(void) { ELOG("Starting window manager"); wm_conf = new WindowManagerConfig; app_starting = false; // defaults, in case world goes down wm_conf->title_active_color = fl_rgb(0,0,128); wm_conf->title_active_color_text = fl_rgb(255,255,255); wm_conf->title_normal_color = fl_rgb(192,192,192); wm_conf->title_normal_color_text = fl_rgb(0,0,128); wm_conf->title_label_align = FL_ALIGN_LEFT; wm_conf->title_height = 20; wm_conf->title_box_type = 0; wm_conf->frame_do_opaque = false; wm_conf->frame_animate = true; wm_conf->frame_animate_speed = 15; fl_open_display(); XSetErrorHandler(xerror_handler); wm_area.set(0, 0, Fl::w(), Fl::h()); read_configuration(); read_xset_configuration(); //register_protocols(); #ifdef _DEBUG InitAtoms(fl_display, atom_map); register_events(); #else InitAtoms(fl_display); #endif //cur = XCreateFontCursor(fl_display, XC_left_ptr); //XDefineCursor(fl_display, RootWindow(fl_display, fl_screen), cur); // load cursor cur = new CursorHandler; cur->load(X_CURSORS); cur->set_root_cursor(); sound_system = new SoundSystem(); sound_system->init(); sound_system->add(SOUND_MINIMIZE, "sounds/minimize.ogg"); sound_system->add(SOUND_MAXIMIZE, "sounds/maximize.ogg"); sound_system->add(SOUND_CLOSE, "sounds/close.ogg"); sound_system->add(SOUND_RESTORE, "sounds/restore.ogg"); sound_system->add(SOUND_SHADE, "sounds/shade.ogg"); // the world is starting here show(); register_protocols(); hint_stuff = new Hints; hint_stuff->icccm_set_iconsizes(this); init_clients(); Fl::add_handler(wm_event_handler); XSync(fl_display, 0); is_running = true; }
DWORD APIENTRY WinSock ( LPVOID threadNum ) { // call Socket library (initialize) WSADATA sd; SYSTEMTIME nowtime; WORD ver=0x0101; SOCKET svrSck,sck; DWORD arg; SOCKADDR_IN addr; fd_set rfd,efd; SOCKADDR_IN ad; struct timeval timeout; int len; char szMessage[1000]; client clt; HINSTANCE hInstance = *(HINSTANCE *) threadNum ; HANDLE hThread = NULL ; DWORD ThreadID = 0L ; init_clients(); // Initialize users' list if(WSAStartup(ver,&sd)) { LoadString ( hInstance , IDS_INIT_FAILURE , szMessage , sizeof (szMessage ) ) ; MessageBox ( hCurDlg , szMessage , szCaption , MB_ICONERROR ) ; ExitProcess ( EXIT_FAILURE ) ; } // Create Socket svrSck=socket(AF_INET,SOCK_STREAM,0); if(svrSck==INVALID_SOCKET) { WSACleanup ( ); LoadString ( hInstance , IDS_CREATION_FAILED , szMessage , sizeof ( szMessage ) ) ; MessageBox ( hCurDlg , szMessage , szCaption , MB_ICONERROR ) ; ExitProcess ( EXIT_FAILURE ) ; } // Set Socket running mode arg=1; ioctlsocket(svrSck,FIONBIO,&arg); // Set non-blocking mode // bind addr.sin_family=AF_INET; addr.sin_port=htons(2007); addr.sin_addr.s_addr = htonl(ADDR_ANY); if(bind(svrSck,(SOCKADDR*)&addr,sizeof(SOCKADDR)) == SOCKET_ERROR) { shutdown(svrSck,SD_BOTH); closesocket(svrSck); WSACleanup(); LoadString ( hInstance , IDS_BIND_FAILED , szMessage , sizeof ( szMessage ) ) ; MessageBox ( hCurDlg , szMessage , szCaption , MB_ICONERROR ) ; ExitProcess ( EXIT_FAILURE ) ; } // start listening if( listen(svrSck,10) == SOCKET_ERROR ) { closesocket ( svrSck ) ; LoadString ( hInstance , IDS_LISTEN_FALED , szMessage , sizeof ( szMessage ) ) ; MessageBox ( hCurDlg , szMessage , szCaption , MB_ICONERROR ) ; ExitProcess ( EXIT_FAILURE ) ; } state = TRUE ; hThread = CreateThread (NULL, 0, GetMessageFromClient, 0, 0, &ThreadID) ; while ( state ) // Wait for client connection { FD_ZERO(&rfd); // used for judging whether there is connection FD_ZERO(&efd); // used for judging whether there's any error FD_SET(svrSck,&rfd) ; FD_SET(svrSck,&efd) ; timeout.tv_sec=0 ; timeout.tv_usec=10000 ; // set timeout as 10 second if( select(0,&rfd,NULL,&efd,&timeout) ) { if(FD_ISSET(svrSck,&rfd)) // if there's a connction { len = sizeof(SOCKADDR_IN); sck = accept(svrSck,(SOCKADDR*)&ad,&len); if( sck != INVALID_SOCKET ) { GetLocalTime(&nowtime); set_client (&clt,sck,ad,"","","",TRUE,nowtime,NULL); ins_clients(clt); refresh( ) ; } } else if( FD_ISSET( svrSck,&efd ) ) // Something goes wrong { shutdown(svrSck,SD_BOTH); closesocket(svrSck); WSACleanup(); LoadString ( hInstance , IDS_SOCKET_ERROR , szMessage , sizeof ( szMessage ) ) ; MessageBox ( hCurDlg , szMessage , szCaption , MB_ICONERROR ) ; ExitProcess ( EXIT_FAILURE ) ; } } Sleep(10); } TerminateThread ( hThread , 0 ) ; CloseHandle ( hThread ) ; hThread = NULL ; dst_clients( ); shutdown(svrSck,SD_BOTH); closesocket(svrSck); WSACleanup(); return 0L; }