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;
}
