int main(int argc, char *argv[]) { int i; int sockfd; struct sockaddr_in servaddr; if (argc != 2) { puts("usage: client address"); return 0; } bzero(&servaddr, sizeof(servaddr)); servaddr.sin_family = AF_INET; inet_pton(AF_INET, argv[1], &servaddr.sin_addr); servaddr.sin_port = htons(SERV_PORT); sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd < 0) { perror("socket create error"); return 1; } if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0) { perror("connect socket error"); return 1; } client_process(stdin, sockfd); return 0; }
void client_loop(int remotefd, int localfd) { fd_set set; int max; this.client.status = CLIENT_STATUS_NORMAL | CLIENT_STATUS_WAITING_HEADER; this.client.want = sizeof(msg_t); this.client.buffer = this.client.read = pool_room_alloc(&this.pool, RECV_ROOM_IDX, this.client.want); int keepalive_send = 0; int rc; if (this.client.buffer == NULL) { fprintf(stderr, "Not enough memory\n"); return; } this.keepalive_replyed = 1; while (1) { struct timeval tv = {1, 0}; FD_ZERO(&set); FD_SET(remotefd, &set); FD_SET(localfd, &set); max = remotefd > localfd ? remotefd : localfd; if (this.keepalive_replyed && (time(NULL) - this.keepalive) > KEEPALIVE_INTERVAL) { msg_t* msg = new_keepalive_msg(1); write_n(remotefd, msg, sizeof(msg_t)); printf("send keepalive message\n"); this.keepalive = time(NULL); this.keepalive_replyed = 0; pool_room_free(&this.pool, MSG_ROOM_IDX); keepalive_send = 1; } max = select(max + 1, &set, NULL, NULL, &tv); if (max > 0) { rc = client_process(max, &set, remotefd, localfd); switch (rc) { case RETURN_CONNECTION_CLOSED: case RETURN_READ_ERROR: pool_room_free(&this.pool, RECV_ROOM_IDX); return; } } if (keepalive_send && !this.keepalive_replyed && (time(NULL) - this.keepalive) > KEEPALIVE_TIMEOUT) { fprintf(stderr, "keepalive reply timeouted, connection closed\n"); pool_room_free(&this.pool, RECV_ROOM_IDX); return; } } }
void event_raised_callback(evutil_socket_t socket, short event, void *context) { client_st *client = (client_st *)context; /* The following will trigger processing within burrow: */ burrow_event_raised(client->burrow, (int)socket, event); /* Which we will then attempt to take advantage of; if burrow is still waiting, this call will simply do no work */ client_process(client); }
void client_handle(networking::Client *c) { pid_t pid = fork(); if (pid == -1) { std::cerr << "Impossible de forker pour le client @" << c->get_ip_address() << std::endl; } else if (pid == 0) { c->set_pid(pid); client_process(c); } }
void pthread_handle (void) { int fd; for (;;) { struct request *get = get_request(); if (get != NULL) { fd = (get->fd); client_process(fd); } } }
/* * This is the function for handling a _single_ request. Understand * what each of the steps in this function do, so that you can handle * _multiple_ requests. Use this function as an _example_ of the * basic functionality. As you increase the server in functionality, * you will want to probably keep all of the functions called in this * function, but define different code to use them. */ void server_single_request(int accept_fd) { int fd; /* * The server thread will always want to be doing the accept. * That main thread will want to hand off the new fd to the * new threads/processes/thread pool. */ fd = server_accept(accept_fd); client_process(fd); return; }
void client_loop(int remotefd, int localfd) { fd_set set; int max; while (1) { struct timeval tv = {60, 0}; FD_ZERO(&set); FD_SET(remotefd, &set); FD_SET(localfd, &set); max = remotefd > localfd ? remotefd : localfd; max = select(max + 1, &set, NULL, NULL, &tv); if (max > 0) client_process(max, &set, remotefd, localfd); } }
// Get and process messages forever or until interrupted void start_brokering() { while (!s_interrupted) { zmq::pollitem_t items [] = { { *m_socket, 0, ZMQ_POLLIN, 0 } }; zmq::poll (items, 1, HEARTBEAT_INTERVAL); // Process next input message, if any if (items [0].revents & ZMQ_POLLIN) { zmsg *msg = new zmsg(*m_socket); if (m_verbose) { s_console ("I: received message:"); msg->dump (); } std::string sender = std::string((char*)msg->pop_front ().c_str()); msg->pop_front (); //empty message std::string header = std::string((char*)msg->pop_front ().c_str()); // std::cout << "sbrok, sender: "<< sender << std::endl; // std::cout << "sbrok, header: "<< header << std::endl; // std::cout << "msg size: " << msg->parts() << std::endl; // msg->dump(); if (header.compare(MDPC_CLIENT) == 0) { client_process (sender, msg); } else if (header.compare(MDPW_WORKER) == 0) { worker_process (sender, msg); } else { s_console ("E: invalid message:"); msg->dump (); delete msg; } } // Disconnect and delete any expired workers // Send heartbeats to idle workers if needed if (s_clock () > m_heartbeat_at) { purge_workers (); for (std::vector<worker*>::iterator it = m_waiting.begin(); it != m_waiting.end() && (*it)!=0; it++) { worker_send (*it, (char*)MDPW_HEARTBEAT, "", NULL); } m_heartbeat_at = s_clock () + HEARTBEAT_INTERVAL; } } }
void client_init (const char *s, const char *n) { int i; GTET_O_STRCPY(server, s); GTET_O_STRCPY(nick, n); connectingdialog_new (); /* wipe spaces off the nick */ for (i = 0; nick[i]; i ++) if (isspace (nick[i])) nick[i] = 0; /* set the game mode */ inmsg_change(); client_process (); }
int DiscussClient::Connect() { memset(&servaddr, 0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(servSettings.ss_port); servaddr.sin_addr.s_addr = inet_addr(servSettings.ss_addr.c_str()); sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); socklen_t socklen = sizeof(servaddr); if(connect(sockfd, (struct sockaddr*)&servaddr, socklen) == -1) { perror("connect"); return -1; } client_process(); }
void server_processes(int accept_fd) { pid_t childID; int fd, status, endID, i; int count = 0; int temp = 0; pid_t *connect = malloc(sizeof(pid_t)*MAX_CONCURRENCY); for(;;){ while (count >= MAX_CONCURRENCY) { wait(&status); int tempCount = count; count = 0; for (i = 0 ; i < tempCount ; i++) { if (waitpid(connect[i], &status, WNOHANG|WUNTRACED)) { connect[temp] = connect[i]; temp++; } else count++; } } if (count >= MAX_CONCURRENCY) continue; else { fd = server_accept(accept_fd); if (childID == -1) { perror("FORK ERROR"); break; } else if (childID == 0) { client_process(fd); break; } else { childID = fork(); temp++; connect[temp] = childID; count++; } } } return; }
/* * This is the function for handling a _single_ request. Understand * what each of the steps in this function do, so that you can handle * _multiple_ requests. Use this function as an _example_ of the * basic functionality. As you increase the server in functionality, * you will want to probably keep all of the functions called in this * function, but define different code to use them. */ void server_single_request(int accept_fd) { int fd; /* * The server thread will always want to be doing the accept. * That main thread will want to hand off the new fd to the * new threads/processes/thread pool. */ fd = server_accept(accept_fd); client_process(fd); /* * A loop around these two lines will result in multiple * documents being served. */ return; }
void* worker_thread_routine(void) { int fd; job *job_to_do; while(1) { pthread_mutex_lock(&mutex); pthread_cond_wait(&cond, &mutex); job_to_do = job_get(); fd = job_to_do->fd; free(job_to_do); client_process(fd); pthread_mutex_unlock(&mutex); printf("thd finished\n"); } return NULL; }
int main(void) { const int CLIENT_COUNT = 4; event_base_st *ev_base; burrow_st *burrow; client_st *clients[CLIENT_COUNT]; int i; burrow = burrow_create("http"); burrow_set_options(burrow, BURROW_OPT_NONBLOCK); /* eday seemed to support this type of interface for backend parameters for modularity, stating that most */ burrow_set_backend_option_string("server", "burrow.example.com"); burrow_set_backend_option_int("port", 1234); /* We won't implement connection pooling. This is just an example: */ burrow_set_backend_option_int("connection_pool", 4); burrow_set_event_fn(burrow, &wait_for_event_callback); burrow_set_message_fn(burrow, &message_callback); burrow_set_queue_fn(burrow, &queue_callback); burrow_set_account_fn(burrow, &account_callback); burrow_set_error_fn(burrow, &error_callback); ev_base = event_base_new(); /* Set up libevent base */ for (i = 0; i < CLIENT_COUNT; i++) { client = client_create(burrow, ev_base); /* Kick off client processing */ client_process(client); } event_base_dispatch(ev_base); /* This encapsulates the whole select/wait loop */ for (i = 0; i < CLIENT_COUNT; i++) free(client); event_base_free(ev_base); burrow_free(burrow); }
void main() { pid_t pid; struct sockaddr_in addr_me; if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) { perror("socket"); } addr_me.sin_family = AF_INET; addr_me.sin_port = htons(PORT); inet_aton(IPADDR,&addr_me.sin_addr); if (bind(sock, (struct sockaddr *)&addr_me, sizeof(addr_me)) == -1) { perror("bind"); } pid = fork(); if (pid == 0) { client_process(); } wait(0); close(sock); }
void client_process() { pid_t pid; pthread_t thread; char buf[MSGLEN]; struct sockaddr_in addr_me ,addr_other; int struct_len = sizeof(addr_other),i,sock_new; if ((sock_new = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) { perror("socket"); } addr_me.sin_family = AF_INET; addr_me.sin_port = 0; inet_aton(IPADDR,&addr_me.sin_addr); if (bind(sock_new, (struct sockaddr *)&addr_me, sizeof(addr_me)) == -1) { perror("bind"); } pthread_create(&thread,NULL,MulPlex,&sock_new); printf("%d\n",htons(addr_other.sin_port)); for (i=0;i<CLIENT;i++) { printf("Waiting data\n"); if (recvfrom(sock,buf,MSGLEN,0,(struct sockaddr *)&addr_other,&struct_len) == -1) { perror("recvfrom"); } if (sendto(sock_new,"Connection",MSGLEN,0,(struct sockaddr *)&addr_other,struct_len) == -1) { perror("sendto"); } printf("%s\n", buf); } pid = fork(); if (pid == 0) client_process(); }
static int main_loop(int listenfd) { int to, cnt, i, dto; struct fdlist pollfds; struct timespec tspec; sigset_t empty_sigset; sigemptyset(&empty_sigset); // unmask all signals fdlist_create(&pollfds); while(!should_exit) { usbmuxd_log(LL_FLOOD, "main_loop iteration"); to = usb_get_timeout(); usbmuxd_log(LL_FLOOD, "USB timeout is %d ms", to); dto = device_get_timeout(); usbmuxd_log(LL_FLOOD, "Device timeout is %d ms", dto); if(dto < to) to = dto; fdlist_reset(&pollfds); fdlist_add(&pollfds, FD_LISTEN, listenfd, POLLIN); usb_get_fds(&pollfds); client_get_fds(&pollfds); usbmuxd_log(LL_FLOOD, "fd count is %d", pollfds.count); tspec.tv_sec = to / 1000; tspec.tv_nsec = (to % 1000) * 1000000; cnt = ppoll(pollfds.fds, pollfds.count, &tspec, &empty_sigset); usbmuxd_log(LL_FLOOD, "poll() returned %d", cnt); if(cnt == -1) { if(errno == EINTR) { if(should_exit) { usbmuxd_log(LL_INFO, "Event processing interrupted"); break; } if(should_discover) { should_discover = 0; usbmuxd_log(LL_INFO, "Device discovery triggered"); usb_discover(); } } } else if(cnt == 0) { if(usb_process() < 0) { usbmuxd_log(LL_FATAL, "usb_process() failed"); fdlist_free(&pollfds); return -1; } device_check_timeouts(); } else { int done_usb = 0; for(i=0; i<pollfds.count; i++) { if(pollfds.fds[i].revents) { if(!done_usb && pollfds.owners[i] == FD_USB) { if(usb_process() < 0) { usbmuxd_log(LL_FATAL, "usb_process() failed"); fdlist_free(&pollfds); return -1; } done_usb = 1; } if(pollfds.owners[i] == FD_LISTEN) { if(client_accept(listenfd) < 0) { usbmuxd_log(LL_FATAL, "client_accept() failed"); fdlist_free(&pollfds); return -1; } } if(pollfds.owners[i] == FD_CLIENT) { client_process(pollfds.fds[i].fd, pollfds.fds[i].revents); } } } } } fdlist_free(&pollfds); return 0; }
//***************************************************************************************** // // Function : main // Description : main program, // //***************************************************************************************** int main (void) { // change your mac address here avr_mac.byte[0] = 'A'; avr_mac.byte[1] = 'V'; avr_mac.byte[2] = 'R'; avr_mac.byte[3] = 'P'; avr_mac.byte[4] = 'O'; avr_mac.byte[5] = 'R'; // read avr and server ip from eeprom eeprom_read_block ( &avr_ip, ee_avr_ip, 4 ); eeprom_read_block ( &server_ip, ee_server_ip, 4 ); // setup port as input and enable pull-up SW_DDR &= ~ ( _BV( SW_MENU ) | _BV( SW_EXIT ) | _BV( SW_UP ) | _BV( SW_DW ) ); SW_PORT |= _BV( SW_MENU ) | _BV( SW_EXIT ) | _BV( SW_UP ) | _BV( SW_DW ); SFIOR &= ~_BV( PUD ); // setup lcd backlight as output LCD_BL_DDR |= _BV( LCD_BL_PIN ); // lcd backlight on LCD_BL_PORT |= _BV( LCD_BL_PIN ); // setup clock for timer1 TCCR1B = 0x01; // clk/1 no prescaling // initial adc, lcd, and menu adc_init(); lcd_init (); menu_init (); // set LED1, LED2 as output */ LED_DDR |= _BV( LED_PIN1_DDR ) | _BV( LED_PIN2_DDR ); // set LED pin to "1" ( LED1,LED2 off) LED_PORT |= _BV( LED_PIN1 ) | _BV( LED_PIN2 ); // initial enc28j60 enc28j60_init( (BYTE*)&avr_mac ); // loop forever for(;;) { // wait until timer1 overflow while ( (TIFR & _BV ( TOV1 )) == 0 ); TIFR |= _BV(TOV1); TCNT1 = 1536; // Timer1 overflow every 1/16MHz * ( 65536 - 1536 ) = 4ms, 250Hz // general time base, generate by timer1 // overflow every 1/250 seconds time_base (); // read temparature adc_read_temp(); // server process response for arp, icmp, http server_process (); // send temparature to web server unsing http protocol // disable by default. client_process (); // lcd user interface menu // setup IP address, countdown timer menu_process (); // display AVR ethernet status // temparature, AVR ip, server ip, countdown time standby_display (); } return 0; }
int main(int argc, const char* argv[]) { pid_t server_child = 0; int fd; int res = 0, status; struct sigaction sigchildAction; tio_param sParam [] = { {"D:", "DURATION", "Duration"}, { "m:", "PORTSPEED", "Prot speed"}, { "s:", "SENDPACKSLENGTH", "Send pack length"}, { "d", "SERVERMODE", "Server mode" }, { "l", "CLIENTMODE", "Client mode" }, { "L", "CLIENTSERVERMODE", "Client/Server mode" }, {NULL, NULL, NULL} }; sigchildAction.sa_handler = termination_signal; sigchildAction.sa_flags = SA_NOCLDSTOP; sigemptyset(&(sigchildAction.sa_mask)); sigaddset(&(sigchildAction.sa_mask),SIGTERM); if (sigaction(SIGTERM, &sigchildAction, NULL)) { perror("Signal SIGTERM registration failed"); return -1; } if (sigaction(SIGINT, &sigchildAction, NULL)) { perror("Signal SIGINT registration failed"); return -1; } // Инициализация tio и разбор входных параметров командной строки tioInit( "alpha", "RS232 test", sParam, argc, argv); if (write_configuration(&config)) { fputs("Congiguration read error\n", stderr); return -1; } fd = open_serial_port( tio_argv[0], tioGetDefL( "PORTSPEED", 115200 )); if (fd < 0) { return -1; } config.outputDevice = fd; if ( tioGetL( "CLIENTSERVERMODE" ) > 0 ) { server_child = fork(); } if ((server_child == 0) && (tioGetL( "CLIENTSERVERMODE" ) || tioGetL( "SERVERMODE" ) ) ) { if (server_process(&config)) { return -1; } } else if ( tioGetL( "CLIENTSERVERMODE" ) || tioGetL( "CLIENTMODE" )) res = client_process(&config); else { DEBUGMSG("Undefined target action"); return -1; } if (server_child != 0) waitpid(server_child, &status, WNOHANG); // Завершение работы библиотеки tio tioFinish(0); return (int)(res || status); /*return 0;*/ }
void server_multiple_requests(int accept_fd) { for (;;) client_process(server_accept(accept_fd)); return; }
int main (int argc, char *argv[]) { AGENT_CTX ATX; int exitcode = EXIT_SUCCESS; buffer *message = NULL; /* input Message */ int agent_init = 0; /* agent is initialized */ setbuf (stdout, NULL); /* unbuffered output */ #ifdef DEBUG DO_DEBUG = 0; #endif srand ((long) time << (long) getpid()); umask (006); #ifndef DAEMON LOG(LOG_ERR, ERR_DAEMON_NO_SUPPORT); exit(EXIT_FAILURE); #endif /* Read dspam.conf into global config structure (ds_config_t) */ agent_config = read_config(NULL); if (!agent_config) { LOG(LOG_ERR, ERR_AGENT_READ_CONFIG); exitcode = EXIT_FAILURE; goto BAIL; } if (!_ds_read_attribute(agent_config, "Home")) { LOG(LOG_ERR, ERR_AGENT_DSPAM_HOME); exitcode = EXIT_FAILURE; goto BAIL; } /* Set up agent context to define behavior of processor */ if (initialize_atx(&ATX)) { LOG(LOG_ERR, ERR_AGENT_INIT_ATX); exitcode = EXIT_FAILURE; goto BAIL; } else { agent_init = 1; } if (process_arguments(&ATX, argc, argv)) { LOG(LOG_ERR, ERR_AGENT_INIT_ATX); exitcode = EXIT_FAILURE; goto BAIL; } if (apply_defaults(&ATX)) { LOG(LOG_ERR, ERR_AGENT_INIT_ATX); exitcode = EXIT_FAILURE; goto BAIL; } if (check_configuration(&ATX)) { LOG(LOG_ERR, ERR_AGENT_MISCONFIGURED); exitcode = EXIT_FAILURE; goto BAIL; } /* Read the message in and apply ParseTo services */ message = read_stdin(&ATX); if (message == NULL) { exitcode = EXIT_FAILURE; goto BAIL; } if (ATX.users->items == 0) { LOG (LOG_ERR, ERR_AGENT_USER_UNDEFINED); fprintf (stderr, "%s\n", SYNTAX); exitcode = EXIT_FAILURE; goto BAIL; } /* Perform client-based processing */ #ifdef DAEMON if (_ds_read_attribute(agent_config, "ClientIdent") && (_ds_read_attribute(agent_config, "ClientHost") || _ds_read_attribute(agent_config, "ServerDomainSocketPath"))) { exitcode = client_process(&ATX, message); } else { LOG(LOG_ERR, ERR_CLIENT_INVALID_CONFIG); exitcode = EINVAL; } #endif BAIL: if (message) buffer_destroy(message); if (agent_init) nt_destroy(ATX.users); if (agent_config) _ds_destroy_config(agent_config); exit (exitcode); }