int main(int argc, char **argv) { struct xmpp xmpp = { 0 }; int i, port = XMPP_PORT, fd, ret = 1; char *jid = 0, *pwdfile = 0, *srv = 0; for (i = 1; i < argc - 1 && argv[i][0] == '-'; i++) switch (argv[i][1]) { case 'j': jid = argv[++i]; break; case 'k': pwdfile = argv[++i]; break; case 's': srv = argv[++i]; break; case 'l': show_log = atoi(argv[++i]); break; case 'p': port = atoi(argv[++i]); break; default: die_usage(); } if (!jid) die_usage(); xmpp.io_context = &fd; xmpp.send = io_send; xmpp.tls_fn = use_tls ? start_tls : 0; xmpp.stream_fn = stream_handler; xmpp.node_fn = node_handler; xmpp.auth_fn = auth_handler; xmpp.use_sasl = use_sasl; xmpp.jid = jid; read_pw(pwdfile, &xmpp); if (xmpp_init(&xmpp, 4096)) return 1; if (!srv) srv = xmpp.server; fd = tcp_connect(srv, port); if (fd < 0) return 1; if (!(xmpp_start(&xmpp) || process_connection(fd, &xmpp))) ret = 0; xmpp_printf(&xmpp, "</stream:stream>"); xmpp_clean(&xmpp); close(fd); shutdown(fd, 2); return ret; }
void accept_connection( const fc::tcp_socket_ptr& s ) { try { // init DH handshake, TODO: this could yield.. what happens if we exit here before // adding s to connections list. ilog( "accepted connection from ${ep}", ("ep", std::string(s->remote_endpoint()) ) ); connections[s->remote_endpoint()] = connection(s); fc::async( [=](){ process_connection( connections[s->remote_endpoint()] ); } ); } catch ( const fc::canceled_exception& e ) { ilog( "canceled accept operation" ); } catch ( const fc::exception& e ) { wlog( "error accepting connection: ${e}", ("e", e.to_detail_string() ) ); } catch( ... ) { elog( "unexpected exception" ); } }
void events(ldp_connection_t *conn, pn_collector_t *coll) { pn_event_t *event; while((event = pn_collector_peek(coll))) { switch (pn_event_type(event)) { case PN_EVENT_NONE: break; case PN_CONNECTION_REMOTE_STATE: case PN_CONNECTION_LOCAL_STATE: process_connection(conn, event); break; case PN_SESSION_REMOTE_STATE: case PN_SESSION_LOCAL_STATE: process_session(conn, event); break; case PN_LINK_REMOTE_STATE: case PN_LINK_LOCAL_STATE: process_link(conn, event); break; case PN_LINK_FLOW: process_flow(conn, event); break; case PN_DELIVERY: process_delivery(conn, event); break; case PN_TRANSPORT: process_transport(conn, event); break; } pn_collector_pop(coll); } }
int main(int argc, char **argv) { struct xmpp xmpp = {0}; char path_buf[PATH_BUF]; int i, port = XMPP_PORT, ret = 1; char *jid = 0, *srv = 0, *s; s = getenv("HOME"); snprintf(path_buf, sizeof(path_buf), "%s/%s", (s) ? s : ".", root); s = getenv("USER"); snprintf(me, sizeof(me), "%s", (s) ? s : "me"); for (i = 1; i < argc - 1 && argv[i][0] == '-'; i++) switch (argv[i][1]) { case 'r': snprintf(path_buf, sizeof(path_buf), "%s", argv[++i]); break; case 'n': snprintf(me, sizeof(me), "%s", argv[++i]); break; case 'j': jid = argv[++i]; break; case 's': srv = argv[++i]; break; case 'p': port = atoi(argv[++i]); break; case 'l': log_level = atoi(argv[++i]); break; case 'e': snprintf(evfifo, sizeof(evfifo), "%s", argv[++i]); break; default: die_usage(); } if (!jid) die_usage(); xmpp.send = io_send; xmpp.tls_fn = start_tls; xmpp.stream_fn = stream_handler; xmpp.node_fn = node_handler; xmpp.auth_fn = auth_handler; xmpp.use_sasl = use_sasl; xmpp.jid = jid; if (read_line(0, sizeof(xmpp.pwd), xmpp.pwd)) xmpp.pwd[0] = 0; if (xmpp_init(&xmpp, 4096)) return 1; if (!srv) srv = xmpp.server; s = jid_partial(xmpp.jid, &i); snprintf(rootdir, sizeof(rootdir), "%s/%.*s", path_buf, i, s); fd = tcp_connect(srv, port); if (fd < 0) return 1; if (!(xmpp_start(&xmpp) != 0 || process_connection(fd, &xmpp))) ret = 0; xmpp_clean(&xmpp); close(fd); shutdown(fd, 2); return ret; }
int main(int argc, char* argv[]) { int c_fd, s_fd; struct sockaddr_in s_addr, c_addr; char buf[BUF_SIZE]; socklen_t sin_size; int so_reuseaddr_val = 1; signal(SIGINT, handle_sigint); if ((s_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket"); exit(1); } if (setsockopt(s_fd, SOL_SOCKET, SO_REUSEADDR, &so_reuseaddr_val, sizeof(so_reuseaddr_val)) == -1) { perror("setsockopt"); exit(2); } s_addr.sin_family = AF_INET; s_addr.sin_port = htons(PORT); s_addr.sin_addr.s_addr = INADDR_ANY; memset(&(s_addr.sin_zero), '\0', 8); if (bind(s_fd, (struct sockaddr *)&s_addr, sizeof(struct sockaddr)) == -1) { perror("bind"); exit(3); } if (listen(s_fd, BACKLOG) == -1) { perror("listen"); exit(4); } while (1) { sin_size = sizeof(struct sockaddr_in); if ((c_fd = accept(s_fd, (struct sockaddr *)&c_addr, &sin_size)) == -1) { perror("accept"); continue; } { //wrap this in fork/thread pool/event loop process_connection(c_fd, buf, BUF_SIZE); } } close(s_fd); }
void http_server::process_ready_list() { logger::instance().log(logger::LOG_DEBUG, "[http_server::process_ready_list] Processing %d connection(s) from the ready list.", _M_nready); unsigned nready = _M_nready; for (unsigned i = 0; i < nready; i++) { if (!process_connection(_M_ready_list[i], 0)) { remove(_M_ready_list[i]); } } for (unsigned i = nready; i < _M_nready; i++) { _M_ready_list[i - nready] = _M_ready_list[i]; } _M_nready -= nready; }
int main(int argc, char* argv) { int listenfd, connfd, i, pid; struct sockaddr_in servaddr; clock_t start, time; if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) err_quit("socket error"); bzero(&servaddr, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = htonl(INADDR_ANY); servaddr.sin_port = htons(13); /* daytime server */ if( (bind(listenfd, (SA *) &servaddr, sizeof(servaddr))) < 0 ) err_sys("bind error"); if( (listen(listenfd, LISTENQ)) < 0 ) err_sys("listen error"); printf("ECHO server starts listening\n"); while(1) { if( (connfd = accept(listenfd, (SA *) NULL, NULL)) < 0 ) err_sys("accept error"); start = clock(); pid = fork(); if(pid < 0) { err_sys("fork error"); } else if(pid == 0) { /* process connection in child process */ process_connection(connfd); exit(0); } waitpid(pid); time = clock() - start; printf("Time taken = %f msec\n", ((double)time/CLOCKS_PER_SEC)*1000.00); close(connfd); } }
bool http_server::on_event(unsigned fd, int events) { // New connection? if ((int) fd == _M_listener) { int client; if ((client = on_new_connection()) != -1) { _M_connection_handlers[client] = rulelist::LOCAL_HANDLER; } } else { if (!process_connection(fd, events)) { return false; } if (_M_connections[fd]->_M_in_ready_list) { // Add to ready list. _M_ready_list[_M_nready++] = fd; logger::instance().log(logger::LOG_DEBUG, "Added fd %d to ready list.", fd); } } return true; }
static int handle_server_connection (void) { int listen_port = conn_port; struct sockaddr_in listen_addr; int listen_socket; socklen_t len; fd_set rset; struct timeval tv; struct timeval start; struct timeval now; int rv, flags, fd; int need_new_conn; listen_socket = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP); if (listen_socket == -1) { log_info (LOG_DEFAULT, "Could not create socket for XS to connect to: %s", strerror (errno)); return 1; } flags = 1; rv = setsockopt (listen_socket, SOL_SOCKET, SO_REUSEADDR, &flags, sizeof (flags)); if (rv == -1) { log_info (LOG_DEFAULT, "Could not set SO_REUSEADDR on the listening socket (%s)", strerror (errno)); // not a fatal failure } // Bind memset (&listen_addr, 0, sizeof (listen_addr)); listen_addr.sin_family = AF_INET; listen_addr.sin_port = htons (listen_port); listen_addr.sin_addr.s_addr = INADDR_ANY; rv = bind (listen_socket, (struct sockaddr *) &listen_addr, sizeof (listen_addr)); if (rv == -1) { log_info (LOG_DEFAULT, "Could not bind to address: %s", strerror (errno)); rv = 2; goto cleanup; } // Make the socket non-blocking flags = fcntl (listen_socket, F_GETFL, NULL); flags |= O_NONBLOCK; fcntl (listen_socket, F_SETFL, flags); rv = listen (listen_socket, 1); if (rv == -1) { log_info (LOG_DEFAULT, "Could not listen for XS: %s", strerror (errno)); rv = 2; goto cleanup; } // Wait for connections start.tv_sec = 0; start.tv_usec = 0; need_new_conn = TRUE; while (need_new_conn) { FD_ZERO (&rset); FD_SET (listen_socket, &rset); do { // Calculate how long we can wait if we can only work for 2s since we started gettimeofday (&now, NULL); if (start.tv_sec == 0) { start.tv_sec = now.tv_sec; start.tv_usec = now.tv_usec; tv.tv_sec = 2; tv.tv_usec = 0; } else if ((start.tv_sec + 2 == now.tv_sec && start.tv_usec < now.tv_usec) || start.tv_sec + 2 < now.tv_sec) { // timeout } else { tv.tv_sec = start.tv_sec + 2 - now.tv_sec; if (start.tv_usec > now.tv_usec) { tv.tv_usec = start.tv_usec - now.tv_usec; } else { tv.tv_sec--; tv.tv_usec = 1000000 + start.tv_usec - now.tv_usec; } } // LOG ("MonoTouch: Waiting for connections from XS, sec: %i usec: %i\n", (int) tv.tv_sec, (int) tv.tv_usec); if ((rv = select (listen_socket + 1, &rset, NULL, NULL, &tv)) == 0) { // timeout hit, no connections available. log_info (LOG_DEFAULT, "Listened2 for connections from XS for 2 seconds, nobody connected.\n"); rv = 3; goto cleanup; } } while (rv == -1 && errno == EINTR); if (rv == -1) { log_info (LOG_DEFAULT, "Failed while waiting for XS to connect: %s", strerror (errno)); rv = 2; goto cleanup; } len = sizeof (struct sockaddr_in); fd = accept (listen_socket, (struct sockaddr *) &listen_addr, &len); if (fd == -1) { log_info (LOG_DEFAULT, "Failed to accept connection from XS: %s", strerror (errno)); rv = 3; goto cleanup; } flags = 1; if (setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (char *) &flags, sizeof (flags)) < 0) { log_info (LOG_DEFAULT, "Could not set TCP_NODELAY on socket (%s)", strerror (errno)); // not a fatal failure } log_info (LOG_DEFAULT, "Successfully received connection from XS on port %i, fd: %i\n", listen_port, fd); need_new_conn = process_connection (fd); } log_info (LOG_DEFAULT, "Successfully talked to XS. Will continue startup now.\n"); rv = 0; cleanup: close (listen_socket); return rv; }