long redrobd_rc_net_server_thread::execute(void *arg)
{
// Make GCC happy (-Wextra)
if (arg) {
return THREAD_INTERNAL_ERROR;
}
try {
redrobd_log_writeln(get_name() + " : execute started");
handle_clients();
redrobd_log_writeln(get_name() + " : execute done");
return THREAD_SUCCESS;
}
catch (excep &exp) {
syslog_error(redrobd_error_syslog_string(exp).c_str());
return THREAD_INTERNAL_ERROR;
}
catch (...) {
syslog_error("redrobd_rc_net_server_thread::execute->Unexpected exception");
return THREAD_INTERNAL_ERROR;
}
}
void server_loop(t_server *server)
{
struct timeval timeout;
while (42)
{
handle_signal();
reset_fdset(server);
set_timeout(server, &timeout);
if (select(find_highest(server) + 1, &(server->rfds), &(server->wfds),
NULL, &timeout) == -1)
perror("Error on select");
server->stimeout = -1;
handle_new_connexion(server);
handle_clients(server);
handle_clients_awaiting(server);
}
}
void listen_server_init(char *ip_address, int port)
{
int sockfd;
struct sockaddr_in address;
sockfd = create_socket();
print_message("Socket created\n");
set_socket_options(sockfd);
bind_address(sockfd, ip_address, port);
print_message("Socket bind to address\n");
listen(sockfd, MAX_PENDING_CONNECTIONS);
print_message("Listening...\n");
handle_clients(sockfd);
shutdown(sockfd, 2);
}
int main(int argc, char *argv[], char **env)
{
int tcpsock, tcpclientsock;
int udpsockcap;
double upcap = 0, downcap = 0;
double measupcap = 0, measdowncap = 0;
unsigned int tbresult = 0, tbabortflag = 0,
tbmindepth = 0, tbmaxdepth = 0;
double tbrate = 0, trueupcap = 0, truedowncap = 0;
double sleepRes = 1;
struct sockaddr_in saddr;
unsigned int ssz = sizeof(saddr);
char tracefile[256], filename[256];
struct timeval tv;
struct sockaddr_in from;
FILE *fp;
extern double TB_RATE_AVG_INTERVAL;
int clientversion = 0;
double upCapLimit = 100000; double upProbeLimit = 95000;
double downCapLimit = 100000; double downProbeLimit = 95000;
TB_RATE_AVG_INTERVAL = 0.3;
memset(tracefile, 0, 256);
tcpsock = create_server();
sleepRes = prober_sleep_resolution();
printf("sleep time resolution: %.2f ms.\n", sleepRes*1000);
while(1)
{
printf("Waiting for new clients..\n");
udpsockcap = prober_bind_port(SERV_PORT_UDP);
CHKRET(udpsockcap);
tcpclientsock = handle_clients(tcpsock, udpsockcap);
CHKRET(tcpclientsock);
close(tcpsock);
begintimer();
if(getpeername(tcpclientsock, (struct sockaddr *)&saddr, &ssz) == -1)
fprintf(stderr, "cannot get peer address\n");
gettimeofday(&tv, NULL);
memset(filename, 0, 256);
printf("Probing from %s\n", inet_ntoa(saddr.sin_addr));
printf("\nEstimating capacity:\n");
fp = openLog(filename, inet_ntoa(saddr.sin_addr), tv); //assume this opens a fp
fprintf(fp, "sleep time resolution: %.2f ms.\n", sleepRes*1000);
CHKRET(preprocess_newclient(tcpclientsock, udpsockcap, &clientversion,
&upcap, &downcap, &from, tracefile, fp, filename));
trueupcap = upcap; truedowncap = downcap;
if(clientversion > 3) // newer clients
{ upCapLimit = 200000; upProbeLimit = 195000;
downCapLimit = 200000; downProbeLimit = 195000; }
if(upcap > upCapLimit /*200000*/) { upcap = upProbeLimit /*195000*/; }
if(downcap > downCapLimit /*200000*/) { downcap = downProbeLimit /*195000*/; }
mflowReceiver(tcpclientsock, udpsockcap, &measupcap, fp, 0);
mflowSender(tcpclientsock, udpsockcap, &from, downcap, sleepRes, &measdowncap, 0);
printf("recvrates: up %f, down %f Kbps\n", measupcap, measdowncap);
upcap = measupcap; downcap = measdowncap;
fprintf(fp, "upstream capacity: %.2f Kbps.\n", upcap);
fprintf(fp, "downstream capacity: %.2f Kbps.\n", downcap);
fprintf(fp, "### UPSTREAM ###\n");
printf("upstream capacity: %.2f Kbps.\n", upcap);
printf("downstream capacity: %.2f Kbps.\n", downcap);
if(upcap > upCapLimit /*200000*/) { upcap = upProbeLimit /*195000*/; } //else { upcap *= 0.95; }
if(downcap > downCapLimit /*200000*/) { downcap = downProbeLimit /*195000*/; } //else { downcap *= 0.95; }
printf("Checking for traffic shapers:\n");
if(clientversion > 3) //backwards-compatibility
mflowReceiver(tcpclientsock, udpsockcap, NULL, fp, 1);
CHKRET(tbdetectReceiver(tcpclientsock, udpsockcap, upcap, sleepRes,
&tbresult, &tbmindepth, &tbmaxdepth, &tbrate, &tbabortflag, fp));
if(tbresult == 1) trueupcap = tbrate;
printShaperResult(tbresult, tbmindepth, tbmaxdepth, tbrate, 0, fp);
if(clientversion > 3) //backwards-compatibility
mflowSender(tcpclientsock, udpsockcap, &from, -1, sleepRes, NULL, 1);
CHKRET(tbdetectSender(tcpclientsock, udpsockcap, &from, downcap, sleepRes,
&tbresult, &tbmindepth, &tbmaxdepth, &tbrate, &tbabortflag, fp));
if(tbresult == 1) truedowncap = tbrate;
printShaperResult(tbresult, tbmindepth, tbmaxdepth, tbrate, 1, fp);
recvData(tcpclientsock, fp, 1 /*0 up 1 down*/);
fclose(fp);
close(udpsockcap);
close(tcpclientsock);
break;
}
execl("/bin/bzip2", "/bin/bzip2", filename, NULL);
return(0);
}
/* Handle incoming connections */
void server_loop ()
{
struct sockaddr_un client_name;
socklen_t name_len = sizeof (client_name);
logit ("MOC server started, pid: %d", getpid());
assert (server_sock != -1);
log_circular_start ();
do {
int res;
fd_set fds_write, fds_read;
FD_ZERO (&fds_read);
FD_ZERO (&fds_write);
FD_SET (server_sock, &fds_read);
FD_SET (wake_up_pipe[0], &fds_read);
add_clients_fds (&fds_read, &fds_write);
res = 0;
if (!server_quit)
res = select (max_fd(server_sock)+1, &fds_read,
&fds_write, NULL, NULL);
if (res == -1 && errno != EINTR && !server_quit)
fatal ("select() failed: %s", xstrerror (errno));
if (!server_quit && res >= 0) {
if (FD_ISSET(server_sock, &fds_read)) {
int client_sock;
debug ("accept()ing connection...");
client_sock = accept (server_sock,
(struct sockaddr *)&client_name,
&name_len);
if (client_sock == -1)
fatal ("accept() failed: %s", xstrerror (errno));
logit ("Incoming connection");
if (!add_client(client_sock))
busy (client_sock);
}
if (FD_ISSET(wake_up_pipe[0], &fds_read)) {
int w;
logit ("Got 'wake up'");
if (read(wake_up_pipe[0], &w, sizeof(w)) < 0)
fatal ("Can't read wake up signal: %s", xstrerror (errno));
}
send_events (&fds_write);
handle_clients (&fds_read);
}
if (server_quit)
logit ("Exiting...");
} while (!server_quit);
log_circular_log ();
log_circular_stop ();
close_clients ();
clients_cleanup ();
close (server_sock);
server_sock = -1;
server_shutdown ();
}
int run_server(int argc, char ** argv) {
DEBUG_OUT("---DEBUG MODE---\n");
if (argc < 4) {
printf("Usage: %s <port> <adminname> <adminpass>\n", argv[0]);
return 0;
}
server_port = atoi(argv[1]);
DEBUG_OUT("Port: %d\n", server_port);
strcpy(admin_name, argv[2]);
strcpy(admin_pass, argv[3]);
/* Create server socket */
server_socket = socket(AF_INET, SOCK_STREAM, 0);
if (server_socket == -1) {
perror("socket");
exit(-1);
}
DEBUG_OUT("Got server socket\n");
/* Reuse address */
socket_flags = 1;
if (setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, &socket_flags, sizeof(socket_flags)) < 0) {
perror("setsockopt");
exit(-1);
}
/* Make socket non blocking */
socket_flags = fcntl(server_socket, F_GETFL, 0);
if (fcntl(server_socket, F_SETFL, socket_flags | O_NONBLOCK) != 0) {
perror("fcntl");
exit(-1);
}
DEBUG_OUT("Server socket is non blocking\n");
/* Bind to our port */
memset(&server_addr, 0, sizeof(struct sockaddr_in));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(server_port);
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
perror("bind");
exit(-1);
}
DEBUG_OUT("Server socket is bound\n");
/* Allocate queue for 10 sockets */
listen(server_socket, 10);
DEBUG_OUT("Server socket has room for 10 incoming connections\n");
/* Add to readset */
FD_ZERO(&readset);
FD_SET(server_socket, &readset);
/* Initialize client buffer */
memset(client_buffer, 0, sizeof(client_buffer));
for (i = 0; i < MAX_CLIENTS - 1; i++) {
client_buffer[i].next = &client_buffer[i + 1];
}
free_clients = &client_buffer[0];
/* Run IO loop */
while (1) {
reads = readset;
DEBUG_OUT("Waiting forever for IO. ");
DEBUG_OUT("Active client count: %d", count_clients(active_clients));
DEBUG_OUT(" Free client count: %d\n", count_clients(free_clients));
selected = select(FD_SETSIZE, &reads, NULL, NULL, NULL);
if (selected < 0) {
perror("select");
exit(-1);
}
DEBUG_OUT("select() returned %d\n", selected);
if (selected > 0) {
handle_clients();
handle_server();
}
}
return 0;
}
int main(int argc, char **argv) {
struct addrinfo hints, *server, *p;
struct sockaddr client[MAX_CLIENTS];
socklen_t addrlen[MAX_CLIENTS];
int sockfd, clientfd[MAX_CLIENTS], yes = 1;
int i, pid = 0, done;
char data[BUFSIZ];
char password[MAX_PASS];
memset(data, 0, sizeof data);
memset(password, 0, sizeof password);
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
if(getaddrinfo(NULL, "35970", &hints, &server) < 0) {
fprintf(stderr, "Error: Cannot get addrinfo\n");
return 1;
}
for(p = server; p != NULL; p = p->ai_next) {
if((sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
fprintf(stderr, "Error: Could not create socket.\n");
continue;
}
if(setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, p->ai_addrlen) < 0) {
fprintf(stderr, "Error: Failed to set socket options.\n");
return 2;
}
if(bind(sockfd, p->ai_addr, p->ai_addrlen) < 0) {
fprintf(stderr, "Error: Failed to bind port to socket.\n");
return 1;
}
break;
}
freeaddrinfo(server);
listen(sockfd, MAX_CLIENTS);
done = 0;
i = 0;
while(i < MAX_CLIENTS) {
pid = fork();
if(pid < 0) {
perror("fork()");
goto error;
} else if(pid == 0) {
if((clientfd[i] = accept(sockfd, &client[i], &addrlen[i])) < 0) {
fprintf(stderr, "Error: Could not accept client connection.\n");
goto error;
}
} else {
if(clientfd[i]) {
MSGIP("Client connected", ((struct sockaddr_in*)&client[i])->sin_addr);
if(send(clientfd[i], SEX_DATA, strlen(SEX_DATA), 0) != strlen(SEX_DATA))
goto error;
snprintf(data, sizeof data, "Too deep.\r\n");
if(send(clientfd[i], data, strlen(data), 0) != strlen(data))
goto error;
handle_clients(clientfd[i]);
if(close(clientfd[i]) == 0) {
MSGIP("Client disconnected", ((struct sockaddr_in*)&client[i])->sin_addr);
--i;
}
++i;
}
}
}
close(sockfd);
return 0;
error:
for(i = 0; i < MAX_CLIENTS; i++)
if(clientfd[i] > 0)
close(clientfd[i]);
close(sockfd);
return 254;
}
