/**
*
* @brief Starts sesman main loop
*
*/
static void DEFAULT_CC
sesman_main_loop(void)
{
int in_sck;
int error;
/*main program loop*/
log_message(&(g_cfg->log), LOG_LEVEL_INFO, "listening...");
g_sck = g_tcp_socket();
g_tcp_set_non_blocking(g_sck);
error = scp_tcp_bind(g_sck, g_cfg->listen_address, g_cfg->listen_port);
if (error == 0)
{
error = g_tcp_listen(g_sck);
if (error == 0)
{
in_sck = g_tcp_accept(g_sck);
while (in_sck == -1 && g_tcp_last_error_would_block(g_sck))
{
g_sleep(1000);
in_sck = g_tcp_accept(g_sck);
}
while (in_sck > 0)
{
/* we've got a connection, so we pass it to scp code */
LOG_DBG(&(g_cfg->log), "new connection");
thread_sck=in_sck;
//scp_process_start((void*)in_sck);
thread_scp_start(in_sck);
/* once we've processed the connection, we go back listening */
in_sck = g_tcp_accept(g_sck);
while (in_sck == -1 && g_tcp_last_error_would_block(g_sck))
{
g_sleep(1000);
in_sck = g_tcp_accept(g_sck);
}
}
}
else
{
log_message(&(g_cfg->log), LOG_LEVEL_ERROR, "listen error");
}
}
else
{
log_message(&(g_cfg->log), LOG_LEVEL_ERROR, "bind error");
}
g_tcp_close(g_sck);
}
/* wait for incoming connections */
int APP_CC
xrdp_listen_main_loop(struct xrdp_listen* self)
{
int error;
int robjs_count;
int cont;
char port[8];
tbus robjs[8];
tbus term_obj;
tbus sync_obj;
tbus sck_obj;
tbus done_obj;
struct xrdp_process* process;
self->status = 1;
xrdp_listen_get_port(port, sizeof(port));
self->sck = g_tcp_socket();
g_tcp_set_non_blocking(self->sck);
error = g_tcp_bind(self->sck, port);
if (error != 0)
{
g_writeln("bind error in xrdp_listen_main_loop");
g_tcp_close(self->sck);
self->status = -1;
return 1;
}
error = g_tcp_listen(self->sck);
if (error == 0)
{
term_obj = g_get_term_event();
sync_obj = g_get_sync_event();
sck_obj = g_create_wait_obj_from_socket(self->sck, 0);
done_obj = self->pro_done_event;
cont = 1;
while (cont)
{
/* build the wait obj list */
robjs_count = 0;
robjs[robjs_count++] = term_obj;
robjs[robjs_count++] = sync_obj;
robjs[robjs_count++] = sck_obj;
robjs[robjs_count++] = done_obj;
/* wait */
if (g_obj_wait(robjs, robjs_count, 0, 0, -1) != 0)
{
/* error, should not get here */
g_sleep(100);
}
if (g_is_wait_obj_set(term_obj)) /* term */
{
break;
}
if (g_is_wait_obj_set(sync_obj)) /* sync */
{
g_reset_wait_obj(sync_obj);
g_loop();
}
if (g_is_wait_obj_set(sck_obj)) /* incomming connection */
{
error = g_tcp_accept(self->sck);
if ((error == -1) && g_tcp_last_error_would_block(self->sck))
{
/* should not get here */
g_sleep(100);
}
else if (error == -1)
{
/* error, should not get here */
break;
}
else
{
process = xrdp_process_create(self, self->pro_done_event);
if (xrdp_listen_add_pro(self, process) == 0)
{
/* start thread */
process->sck = error;
g_process = process;
tc_thread_create(xrdp_process_run, 0);
tc_sem_dec(g_process_sem); /* this will wait */
}
else
{
xrdp_process_delete(process);
}
}
}
if (g_is_wait_obj_set(done_obj)) /* pro_done_event */
{
g_reset_wait_obj(done_obj);
xrdp_listen_delete_done_pro(self);
}
}
/* stop listening */
g_delete_wait_obj_from_socket(sck_obj);
g_tcp_close(self->sck);
/* second loop to wait for all process threads to close */
cont = 1;
while (cont)
{
if (self->process_list->count == 0)
{
break;
}
/* build the wait obj list */
robjs_count = 0;
robjs[robjs_count++] = sync_obj;
robjs[robjs_count++] = done_obj;
/* wait */
if (g_obj_wait(robjs, robjs_count, 0, 0, -1) != 0)
{
/* error, should not get here */
g_sleep(100);
}
if (g_is_wait_obj_set(sync_obj)) /* sync */
{
g_reset_wait_obj(sync_obj);
g_loop();
}
if (g_is_wait_obj_set(done_obj)) /* pro_done_event */
{
g_reset_wait_obj(done_obj);
xrdp_listen_delete_done_pro(self);
}
}
}
else
{
DEBUG(("listen error in xrdp_listen_main_loop"));
}
self->status = -1;
return 0;
}
/**
*
* @brief Starts sesman main loop
*
*/
static void DEFAULT_CC
sesman_main_loop(void)
{
int in_sck;
int error;
int robjs_count;
int cont;
tbus sck_obj;
tbus robjs[8];
/*main program loop*/
log_message(&(g_cfg->log), LOG_LEVEL_INFO, "sesman[sesman_main_loop]: "
"listening...");
g_sck = g_tcp_socket();
g_tcp_set_non_blocking(g_sck);
error = scp_tcp_bind(g_sck, g_cfg->listen_address, g_cfg->listen_port);
if (error == 0)
{
error = g_tcp_listen(g_sck);
if (error == 0)
{
sck_obj = g_create_wait_obj_from_socket(g_sck, 0);
cont = 1;
while (cont)
{
/* build the wait obj list */
robjs_count = 0;
robjs[robjs_count++] = sck_obj;
robjs[robjs_count++] = g_term_event;
robjs[robjs_count++] = g_sync_event;
/* wait */
if (g_obj_wait(robjs, robjs_count, 0, 0, -1) != 0)
{
/* error, should not get here */
g_sleep(100);
}
if (g_is_wait_obj_set(g_term_event)) /* term */
{
break;
}
if (g_is_wait_obj_set(g_sync_event)) /* sync */
{
g_reset_wait_obj(g_sync_event);
session_sync_start();
}
if (g_is_wait_obj_set(sck_obj)) /* incomming connection */
{
in_sck = g_tcp_accept(g_sck);
if ((in_sck == -1) && g_tcp_last_error_would_block(g_sck))
{
/* should not get here */
g_sleep(100);
}
else if (in_sck == -1)
{
/* error, should not get here */
break;
}
else
{
/* we've got a connection, so we pass it to scp code */
log_message(&(g_cfg->log), LOG_LEVEL_INFO, "sesman[sesman_main_loop]: "
"new connection");
thread_scp_start(in_sck);
/* todo, do we have to wait here ? */
}
}
}
g_delete_wait_obj_from_socket(sck_obj);
}
else
{
log_message(&(g_cfg->log), LOG_LEVEL_ERROR, "sesman[sesman_main_loop]: "
"listen error %d (%s)", g_get_errno(), g_get_strerror());
}
}
else
{
log_message(&(g_cfg->log), LOG_LEVEL_ERROR, "bind error on "
"port '%s': %d (%s)", g_cfg->listen_port, g_get_errno(), g_get_strerror());
}
g_tcp_close(g_sck);
}
/**
*
* @brief Starts sesman main loop
*
*/
static void DEFAULT_CC
sesman_main_loop(void)
{
int in_sck;
int error;
int robjs_count;
int cont;
tbus sck_obj;
tbus robjs[8];
g_sck = g_tcp_socket();
if (g_sck < 0)
{
log_message(LOG_LEVEL_ERROR, "error opening socket, g_tcp_socket() failed...");
return;
}
g_tcp_set_non_blocking(g_sck);
error = scp_tcp_bind(g_sck, g_cfg->listen_address, g_cfg->listen_port);
if (error == 0)
{
error = g_tcp_listen(g_sck);
if (error == 0)
{
log_message(LOG_LEVEL_INFO, "listening to port %s on %s",
g_cfg->listen_port, g_cfg->listen_address);
sck_obj = g_create_wait_obj_from_socket(g_sck, 0);
cont = 1;
while (cont)
{
/* build the wait obj list */
robjs_count = 0;
robjs[robjs_count++] = sck_obj;
robjs[robjs_count++] = g_term_event;
/* wait */
if (g_obj_wait(robjs, robjs_count, 0, 0, -1) != 0)
{
/* error, should not get here */
g_sleep(100);
}
if (g_is_wait_obj_set(g_term_event)) /* term */
{
break;
}
if (g_is_wait_obj_set(sck_obj)) /* incoming connection */
{
in_sck = g_tcp_accept(g_sck);
if ((in_sck == -1) && g_tcp_last_error_would_block(g_sck))
{
/* should not get here */
g_sleep(100);
}
else if (in_sck == -1)
{
/* error, should not get here */
break;
}
else
{
/* we've got a connection, so we pass it to scp code */
LOG_DBG("new connection");
scp_process_start((void*)(tintptr)in_sck);
g_sck_close(in_sck);
}
}
}
g_delete_wait_obj_from_socket(sck_obj);
}
else
{
log_message(LOG_LEVEL_ERROR, "listen error %d (%s)",
g_get_errno(), g_get_strerror());
}
}
else
{
log_message(LOG_LEVEL_ERROR, "bind error on "
"port '%s': %d (%s)", g_cfg->listen_port,
g_get_errno(), g_get_strerror());
}
g_tcp_close(g_sck);
}
int APP_CC
trans_check_wait_objs(struct trans* self)
{
tbus in_sck;
struct trans* in_trans;
int read_bytes;
int to_read;
int read_so_far;
int rv;
if (self == 0)
{
return 1;
}
if (self->status != 1)
{
return 1;
}
rv = 0;
if (self->type1 == 1) /* listening */
{
if (g_tcp_can_recv(self->sck, 0))
{
in_sck = g_tcp_accept(self->sck);
if (in_sck == -1)
{
if (g_tcp_last_error_would_block(self->sck))
{
/* ok, but shouldn't happen */
}
else
{
/* error */
self->status = 0;
rv = 1;
}
}
if (in_sck != -1)
{
if (self->trans_conn_in != 0) /* is function assigned */
{
in_trans = trans_create(self->mode, self->in_s->size,
self->out_s->size);
in_trans->sck = in_sck;
in_trans->type1 = 2;
in_trans->status = 1;
if (self->trans_conn_in(self, in_trans) != 0)
{
trans_delete(in_trans);
}
}
else
{
g_tcp_close(in_sck);
}
}
}
}
else /* connected server or client (2 or 3) */
{
if (g_tcp_can_recv(self->sck, 0))
{
read_so_far = (int)(self->in_s->end - self->in_s->data);
to_read = self->header_size - read_so_far;
read_bytes = g_tcp_recv(self->sck, self->in_s->end, to_read, 0);
if (read_bytes == -1)
{
if (g_tcp_last_error_would_block(self->sck))
{
/* ok, but shouldn't happen */
}
else
{
/* error */
self->status = 0;
rv = 1;
}
}
else if (read_bytes == 0)
{
/* error */
self->status = 0;
rv = 1;
}
else
{
self->in_s->end += read_bytes;
}
read_so_far = (int)(self->in_s->end - self->in_s->data);
if (read_so_far == self->header_size)
{
if (self->trans_data_in != 0)
{
rv = self->trans_data_in(self);
init_stream(self->in_s, 0);
}
}
}
}
return rv;
}
