int main(int argc , char *argv[])
{
Client* client = mymalloc(sizeof(Client));
init_client(client);
client->fdmax=STDIN_FILENO;
FD_SET(STDIN_FILENO, &(client->fd_read_set));
while(TRUE) {
client->fd_read_set_select = client->fd_read_set;
client->fd_write_set_select = client->fd_write_set;
select(client->fdmax+1, &(client->fd_read_set_select),
&(client->fd_write_set_select),
NULL, NULL);
if (FD_ISSET(STDIN_FILENO, &(client->fd_read_set_select)))
handle_std_input(client);
else if(FD_ISSET(client->listening_fd, &(client->fd_read_set_select)))
handle_new_client(client);
else if(FD_ISSET(client->maintainer_fd, &(client->fd_read_set_select)))
read_server_msg(client);
else if(FD_ISSET(client->maintainer_fd, &(client->fd_write_set_select)))
write_server_msg(client);
else
for(int i=1; i<=client->fdmax; ++i)
if(FD_ISSET(i, &(client->fd_read_set_select)))
read_client_msg(client, i);
else if(FD_ISSET(i, &(client->fd_write_set_select)))
write_client_msg(client, i);
}
myfree(client);
return 0;
}
int main(int argc, char **argv)
{
fd_set read_fdset, write_fdset;
int i, opt;
int max;
sigset_t chld_set;
while ((opt=getopt(argc, argv, "q")) != -1) {
switch (opt) {
case 'q':
opt_quiet = 1;
break;
default: /* '?' */
fprintf(stderr, "usage: %s [-q] domainid domain-name [default user]\n", argv[0]);
exit(1);
}
}
if (argc - optind < 2 || argc - optind > 3) {
fprintf(stderr, "usage: %s [-q] domainid domain-name [default user]\n", argv[0]);
exit(1);
}
remote_domain_id = atoi(argv[optind]);
remote_domain_name = argv[optind+1];
if (argc - optind >= 3)
default_user = argv[optind+2];
init(remote_domain_id);
sigemptyset(&chld_set);
sigaddset(&chld_set, SIGCHLD);
signal(SIGCHLD, sigchld_handler);
/*
* The main event loop. Waits for one of the following events:
* - message from client
* - message from agent
* - new client
* - child exited
*/
for (;;) {
max = fill_fdsets_for_select(&read_fdset, &write_fdset);
if (libvchan_buffer_space(vchan) <= (int)sizeof(struct msg_header))
FD_ZERO(&read_fdset); // vchan full - don't read from clients
sigprocmask(SIG_BLOCK, &chld_set, NULL);
if (child_exited)
reap_children();
wait_for_vchan_or_argfd(vchan, max, &read_fdset, &write_fdset);
sigprocmask(SIG_UNBLOCK, &chld_set, NULL);
if (FD_ISSET(qrexec_daemon_unix_socket_fd, &read_fdset))
handle_new_client();
while (libvchan_data_ready(vchan))
handle_message_from_agent();
for (i = 0; i <= max_client_fd; i++)
if (clients[i].state != CLIENT_INVALID
&& FD_ISSET(i, &read_fdset))
handle_message_from_client(i);
}
}
/**
* Reads the thread specific userdata to figure out what
* we need to handle. Things that purely effect the network
* stack should be handled here, but otherwise we should defer
* to the connection handlers.
*/
static void invoke_event_handler(worker_ev_userdata* data) {
// Get the offending handle
ev_io *watcher = data->watcher;
int fd = watcher->fd;
// Check if this is either of the listeners
if (watcher == &data->netconf->tcp_client) {
// Accept the new client
handle_new_client(fd, data);
// Reschedule the listener
schedule_async(data->netconf, SCHEDULE_WATCHER, watcher);
return;
// If it is write ready, dispatch the write handler
} else if (data->ready_events & EV_WRITE) {
handle_client_writebuf(watcher, data);
return;
}
// Check for UDP inbound
if (watcher == &data->netconf->udp_client) {
// Read the message and process
if (!handle_udp_message(watcher, data)) {
statsite_proxy_conn_handler handle = {data->netconf->config, data->netconf->proxy, watcher->data};
handle_client_connect(&handle);
}
// Reschedule the listener
schedule_async(data->netconf, SCHEDULE_WATCHER, watcher);
return;
}
/*
* If it is not a listener, it must be a connected
* client. We should just read all the available data,
* append it to the buffers, and then invoke the
* connection handlers.
*/
conn_info *conn = watcher->data;
incref_client_connection(conn);
if (!handle_client_data(watcher, data)) {
statsite_proxy_conn_handler handle = {data->netconf->config, data->netconf->proxy, watcher->data};
handle_client_connect(&handle);
}
// Reschedule the watcher, unless told otherwise.
if (conn->should_schedule) {
schedule_async(data->netconf, SCHEDULE_WATCHER, watcher);
}
decref_client_connection(conn);
}
int main(int argc, char *argv[]) {
if (argc!=2) {
fprintf(stderr,"usage: multi_ftp_server <server_local_path>\n");
exit(-1);
}
signal(SIGINT, sig_handler);
getcwd(old_cwd,sizeof(old_cwd));
if (chdir(argv[1])==-1) {
log_err("Bad Directory:");
exit(-1);
}
fd_set read_fds,write_fds; // temp file descriptor list for select()
int listener; // listening socket descriptor
FD_ZERO(&master); // clear the master and temp sets
FD_ZERO(&w_master);
FD_ZERO(&read_fds);
FD_ZERO(&write_fds);
init_protocol();
// get us a socket and bind it
listener = do_bind(PORT);
FD_SET(listener, &master);
fdmax = listener + 1;
for(;;) {
read_fds = master; // copy it
write_fds = w_master;
if (select(fdmax+1, &read_fds, &write_fds, NULL, NULL) == -1) {
perror("select");
exit(4);
}
// run through the existing connections looking for data to read
int fdmax_nochange = fdmax;
for(int i = 0; i <= fdmax_nochange; i++) {
//debug("fdmax is %d",fdmax_nochange);
if (FD_ISSET(i, &read_fds)) {
if (i == listener) {
fdmax = handle_new_client(listener) ;
}
else {
fdmax = handle_recv_from_client(i); // handle data from a client
}
}
if (FD_ISSET(i,&write_fds)) {
fdmax = handle_send_to_client(i);
}
}//end run thrugh read fd_set
}
}
int main(int argc, char **argv)
{
fd_set read_fdset, write_fdset;
int i;
int max;
sigset_t chld_set;
if (argc != 2) {
fprintf(stderr, "usage: %s domainid\n", argv[0]);
exit(1);
}
init(atoi(argv[1]));
sigemptyset(&chld_set);
sigaddset(&chld_set, SIGCHLD);
/*
The main event loop. Waits for one of the following events:
- message from client
- message from agent
- new client
- child exited
*/
for (;;) {
max = fill_fdsets_for_select(&read_fdset, &write_fdset);
if (buffer_space_vchan_ext() <=
sizeof(struct server_header))
FD_ZERO(&read_fdset); // vchan full - don't read from clients
sigprocmask(SIG_BLOCK, &chld_set, NULL);
if (child_exited)
reap_children();
wait_for_vchan_or_argfd(max, &read_fdset, &write_fdset);
sigprocmask(SIG_UNBLOCK, &chld_set, NULL);
if (FD_ISSET(qrexec_daemon_unix_socket_fd, &read_fdset))
handle_new_client();
while (read_ready_vchan_ext())
handle_message_from_agent();
for (i = 0; i <= max_client_fd; i++)
if (clients[i].state != CLIENT_INVALID
&& FD_ISSET(i, &read_fdset))
handle_message_from_client(i);
for (i = 0; i <= max_client_fd; i++)
if (clients[i].state != CLIENT_INVALID
&& FD_ISSET(i, &write_fdset))
write_buffered_data_to_client(i);
}
}
int main(int argc, char* argv[]){
//printf("argc:%d arg1:%s\n", argc, argv[1]);
clr_connections(srv_state);
clr_connections(dirty_state);
int cont =1;
next_fid =0;
struct sigaction act;
act.sa_handler = (update_clients_handler);
if(sigaction(SIGALRM, &act, NULL)){
printf("error setting alarm handler\n");
}
struct timeval tv;
//kill(getpid(), SIGVTALRM);
tv.tv_sec=0;
tv.tv_usec = TIC_RATE;
const struct itimerval it_update = {tv, tv};
if(setitimer(ITIMER_REAL, &it_update, NULL)) perror("setitimer failure");
openfd = socket(AF_INET, SOCK_DGRAM, 0);
struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(HOST_PORT);
bind(openfd, (struct sockaddr*)&server_addr, sizeof(struct sockaddr_in));
while(cont){
struct client_data new_client;
int socklen = sizeof(struct sockaddr_in);
if(recvfrom(openfd, &new_client, sizeof(struct client_data), 0, (struct sockaddr*)&new_client.destaddr, &socklen)!=0){
printf("recieved msg. client_id=%d, address=%s\n", new_client.client_id, inet_ntoa(new_client.destaddr.sin_addr));
if(new_client.client_id>-1){
if(handle_msg(&new_client, dirty_state, openfd)){
printf("error handle_msg()\n");
return -1;
}
}
else{
if(handle_new_client(&new_client, dirty_state, openfd)){
printf("error handle_msg()\n");
return -1;
}
}
}
}
return 0;
}
int main(int argc , char *argv[])
{
Maintainer maintainer;
init_maintainer(&maintainer);
logger("<Server><main>maintainer initialized\n");
int opt = TRUE;
if((maintainer.master_socket=socket(AF_INET, SOCK_STREAM, 0))==0){
logger("<Server><main>failed at master socket creation\n");
return 1;
}
fcntl(maintainer.master_socket, F_SETFL, O_NONBLOCK);
if(setsockopt(maintainer.master_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt)) < 0){
logger("<Server><main>failed at master socket reuse\n");
return 1;
}
if(bind(maintainer.master_socket, (struct sockaddr *)&(maintainer.address), sizeof(maintainer.address)) < 0){
logger("<Server><main>failed at master socket binding\n");
return 1;
}
if (listen(maintainer.master_socket, 10) < 0){
logger("<Server><main>failed at master socket listen");
return 1;
}
FD_SET(maintainer.master_socket, &(maintainer.fd_read_set));
maintainer.max_sd = maintainer.master_socket;
while(TRUE){
maintainer.fd_read_set_select = maintainer.fd_read_set;
if ((select(maintainer.max_sd+1, &(maintainer.fd_read_set_select),NULL,NULL, NULL) < 0))
logger("<Server><main>error at select\n");
if (FD_ISSET(maintainer.master_socket, &(maintainer.fd_read_set_select)))
handle_new_client(&maintainer);
for(int i=0; i<MAX_CLIENTS; ++i){
int current_socket = maintainer.clients[i].socket_fd;
if(current_socket == -1)
continue;
if(FD_ISSET(current_socket, &(maintainer.fd_read_set_select)))
read_from_client(&maintainer, current_socket,&(maintainer.clients[i]));
}
}
return 0;
}
int main(int argc, char *argv[])
{
char errbuf[ERRBUFLEN + 1];
apr_pool_t *pool;
apr_proc_t proc;
dynalogin_session_t *h;
apr_status_t res;
apr_sockaddr_t *sa;
apr_socket_t *socket, *socket_new;
char *cfg_filename;
char *bind_address;
int bind_port;
int qlen = 32;
int cfg_detach = 1;
int ret;
int done = 0;
apr_hash_t *config;
if(apr_initialize() != APR_SUCCESS)
{
fprintf(stderr, "apr_initialize failed\n");
return 1;
}
/* Just return an error if a client closes a socket */
apr_signal_block(SIGPIPE);
openlog(argv[0], LOG_PID, LOG_AUTHPRIV);
if((res = apr_pool_create(&pool, NULL)) != APR_SUCCESS)
{
syslog(LOG_ERR, "failed to create root pool: %s",
apr_strerror(res, errbuf, ERRBUFLEN));
return 1;
}
if(argc == 2)
cfg_filename = argv[1];
else
cfg_filename = apr_psprintf(pool, "%s%c%s",
SYSCONFDIR, DIR_SEP, DEFAULT_CONFIG_FILENAME);
if(cfg_filename == NULL)
{
syslog(LOG_ERR, "apr_psprintf failed to create filename: %s",
apr_strerror(res, errbuf, ERRBUFLEN));
return 1;
}
/* Read config */
if(dynalogin_read_config_from_file(&config, cfg_filename, pool)
!= DYNALOGIN_SUCCESS)
{
syslog(LOG_ERR, "failed to read config file %s",
cfg_filename);
return 1;
}
/* Set up DYNALOGIN session (threadsafe?) */
if(dynalogin_init(&h, pool, config) != DYNALOGIN_SUCCESS)
{
syslog(LOG_ERR, "failed to init dynalogin stack");
return 1;
}
/* Daemonize? */
GET_INT_PARAM(cfg_detach, config, DYNALOGIND_PARAM_DETACH)
if((res=apr_proc_detach(cfg_detach)) != APR_SUCCESS)
{
syslog(LOG_ERR, "failed to detach: %s",
apr_strerror(res, errbuf, ERRBUFLEN));
return 1;
}
/* Create socket for clients */
if((res=apr_socket_create(&socket,
APR_INET, SOCK_STREAM, APR_PROTO_TCP, pool))!=APR_SUCCESS)
{
syslog(LOG_ERR, "failed to create listening socket: %s",
apr_strerror(res, errbuf, ERRBUFLEN));
return 1;
}
GET_STRING_PARAM_DEF(bind_address, config, DYNALOGIND_PARAM_BIND_ADDR, DEFAULT_BIND_ADDR)
GET_INT_PARAM_DEF(bind_port, config, DYNALOGIND_PARAM_BIND_PORT, DEFAULT_BIND_PORT)
if((res=apr_sockaddr_info_get(&sa, bind_address, APR_UNSPEC,
bind_port, APR_IPV4_ADDR_OK || APR_IPV6_ADDR_OK, pool))!=APR_SUCCESS)
{
syslog(LOG_ERR, "failed to resolve bind address: %s",
apr_strerror(res, errbuf, ERRBUFLEN));
apr_socket_close(socket);
return 1;
}
if((res=apr_socket_opt_set(socket, APR_SO_REUSEADDR, 1))!=APR_SUCCESS)
{
syslog(LOG_ERR, "failed to set APR_SO_REUSEADDR: %s",
apr_strerror(res, errbuf, ERRBUFLEN));
apr_socket_close(socket);
return 1;
}
if((res=apr_socket_bind(socket, sa))!=APR_SUCCESS)
{
syslog(LOG_ERR, "failed to bind: %s",
apr_strerror(res, errbuf, ERRBUFLEN));
apr_socket_close(socket);
return 1;
}
GET_STRING_PARAM_DEF(tls_cert, config, DYNALOGIND_PARAM_TLS_CERT, NULL)
GET_STRING_PARAM_DEF(tls_key, config, DYNALOGIND_PARAM_TLS_KEY, NULL)
if(tls_cert != NULL)
{
if(tls_key == NULL)
{
syslog(LOG_ERR, "%s specified, but %s not specified", DYNALOGIND_PARAM_TLS_CERT,
DYNALOGIND_PARAM_TLS_KEY);
return 1;
}
gnutls_global_init ();
gnutls_certificate_allocate_credentials (&x509_cred);
ret = gnutls_certificate_set_x509_key_file (x509_cred, tls_cert, tls_key,
GNUTLS_X509_FMT_PEM);
if (ret < 0)
{
syslog(LOG_ERR, "No certificate or key were found");
return 1;
}
generate_dh_params ();
gnutls_priority_init (&priority_cache, "PERFORMANCE:%SERVER_PRECEDENCE", NULL);
gnutls_certificate_set_dh_params (x509_cred, dh_params);
}
else if(tls_key == NULL)
{
syslog(LOG_ERR, "%s specified, but %s not specified", DYNALOGIND_PARAM_TLS_KEY,
DYNALOGIND_PARAM_TLS_CERT);
return 1;
}
/* Main loop */
while(done != 1)
{
if((res=apr_socket_listen(socket, qlen))!=APR_SUCCESS)
{
syslog(LOG_ERR, "failed apr_socket_listen: %s",
apr_strerror(res, errbuf, ERRBUFLEN));
apr_socket_close(socket);
return 1;
}
if((res=apr_socket_accept(&socket_new, socket, pool))!=APR_SUCCESS)
{
syslog(LOG_ERR, "failed to accept incoming connection: %s",
apr_strerror(res, errbuf, ERRBUFLEN));
apr_socket_close(socket);
return 1;
}
syslog(LOG_INFO, "new incoming connection");
if((res=handle_new_client(socket_new, pool, h))!=APR_SUCCESS)
{
syslog(LOG_ERR, "failed to handle incoming connection: %s",
apr_strerror(res, errbuf, ERRBUFLEN));
apr_socket_close(socket);
return 1;
}
}
apr_socket_close(socket);
return 0;
}
int main(int argc , char *argv[])
{
Maintainer* maintainer = mymalloc(sizeof(Maintainer));
init_maintainer(maintainer);
logger("<Server><main>maintainer initialized\n");
int opt = TRUE;
if((maintainer->master_socket=socket(AF_INET, SOCK_STREAM, 0))==0) {
logger("<Server><main>failed at master socket creation\n");
myfree(maintainer);
exit(EXIT_FAILURE);
}
fcntl(maintainer->master_socket, F_SETFL, O_NONBLOCK);
if(setsockopt(maintainer->master_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt)) < 0) {
logger("<Server><main>failed at master socket reuse\n");
myfree(maintainer);
exit(EXIT_FAILURE);
}
if(bind(maintainer->master_socket, (struct sockaddr *)&(maintainer->address), sizeof(maintainer->address)) < 0) {
logger("<Server><main>failed at master socket binding\n");
myfree(maintainer);
exit(EXIT_FAILURE);
}
if (listen(maintainer->master_socket, 10) < 0) {
logger("<Server><main>failed at master socket listen");
exit(EXIT_FAILURE);
}
FD_SET(maintainer->master_socket, &(maintainer->fd_read_set));
FD_SET(maintainer->master_socket, &(maintainer->fd_exception_set));
maintainer->max_sd = maintainer->master_socket;
while(TRUE) {
maintainer->fd_read_set_select = maintainer->fd_read_set;
maintainer->fd_write_set_select = maintainer->fd_write_set;
maintainer->fd_exception_set_select = maintainer->fd_exception_set;
if ((select(maintainer->max_sd+1, &(maintainer->fd_read_set_select),
&(maintainer->fd_write_set_select),
&(maintainer->fd_exception_set_select), NULL) < 0))
logger("<Server><main>error at select\n");
if (FD_ISSET(maintainer->master_socket, &(maintainer->fd_read_set_select)))
handle_new_client(maintainer);
if (FD_ISSET(maintainer->master_socket, &(maintainer->fd_exception_set_select)))
handle_server_exception(maintainer);
struct Nodes_ll* prev = maintainer->clients;
struct Nodes_ll* iterator = maintainer->clients;
while(iterator != NULL) {
int current_socket = iterator->node->socket_fd;
if(FD_ISSET(current_socket, &(maintainer->fd_exception_set_select)))
close_client_connection(maintainer, current_socket, iterator->node, TRUE);
else if(FD_ISSET(current_socket, &(maintainer->fd_read_set_select)))
if(!read_from_client(maintainer, current_socket, iterator->node))
if(FD_ISSET(current_socket, &(maintainer->fd_write_set_select)))
write_to_client(maintainer, current_socket, iterator->node);
else if(FD_ISSET(current_socket, &(maintainer->fd_write_set_select)))
write_to_client(maintainer, current_socket, iterator->node);
if(iterator != maintainer->clients) {
if(iterator->node->socket_fd == -1) {
prev->next = iterator->next;
myfree(iterator->node);
struct Nodes_ll* tmp = iterator;
iterator = iterator->next;
myfree(tmp);
}
else {
prev = prev->next;
iterator = iterator->next;
}
} else if(iterator->node->socket_fd == -1) { /*marked for deletation*/
maintainer->clients = iterator->next;
myfree(iterator->node);
struct Nodes_ll* tmp = iterator;
iterator = iterator->next;
myfree(tmp);
} else
iterator = iterator->next;
}
}
myfree(maintainer);
return 0;
}
