void ClientConnectionSocket::connection_handle() {
if (conn_receive() == -1)
return;
struct MSG_AckConnectPort* ack = (struct MSG_AckConnectPort*)_rxfifo.get_out();
int last_len = 0;
struct MSG_IdentifyConnection* identify = (struct MSG_IdentifyConnection*)_rxfifo.get_out();
struct CMD_ClosePort * closeport = (struct CMD_ClosePort*)_rxfifo.get_out();
do {
last_len = _rxfifo.len();
switch (_rxfifo.get_out()[0]) {
case MSG_ACK_CONNECT_PORT:
printf("Ack connect port: %d\n", ack->id);
_rxfifo.skip( sizeof(struct MSG_AckConnectPort) );
break;
case MSG_SOCKET_DATA:
conn_socket_data(*this);
break;
case MSG_IDENTIFY_CONNECTION: {
int bufsize = identify->len - sizeof(struct MSG_IdentifyConnection) + 1;
if (_rxfifo.len() < identify->len)
break;
printf("bufsize:%d\n", bufsize);
_name.assign((char*)identify + sizeof(struct MSG_IdentifyConnection), bufsize-1);
printf("len:%d \"%s\"\n", identify->len, _name.c_str());
_rxfifo.skip(identify->len);
if ( _name == "CLIENT1") {
int server_sockfd = create_server_socket("8080");
new ForwardListenSocket(server_sockfd, 80, this);
}
if (_name == "CLIENT2") {
int server_sockfd = create_server_socket("2222");
new ForwardListenSocket(server_sockfd, 22, _parent);
}
break;
}
case CMD_CLOSE_PORT: {
printf("CMD_CLOSE_PORT id:%d\n", closeport->id);
conn_from_id(closeport->id).connlist_delete();
_rxfifo.skip( sizeof(*closeport) );
}
break;
default:
printf("Invalid package\n");
break;
}
} while (last_len != _rxfifo.len() && _rxfifo.len());
}
int main() {
int server_sockfd = create_server_socket("12345");
new ServerDaemonSocket(server_sockfd);
eventloop();
}
void server_main()
{
struct sigaction sa;
int sock;
sock_path = get_socket_path();
sock = create_server_socket(sock_path);
if (sock == -1) {
fprintf(stderr, "Error! Failed to create a server socket: %s\n",
sock_path->data);
exit(1);
}
sa.sa_handler = handle_sigint;
sa.sa_flags = 0;
sigaction(SIGINT, &sa, 0);
clang_index = clang_createIndex(0, 0);
server_loop(sock);
if (clang_tu)
clang_disposeTranslationUnit(clang_tu);
clang_disposeIndex(clang_index);
close(sock);
unlink(sock_path->data);
str_free(sock_path);
}
/* init server
* prepare for the db and get ready for connetions
*/
int server_init()
{
/* data intialization */
key_dict = dict_create(INIT_DICT_SIZE);
if(NULL == key_dict)
return E_MEM_OUT;
_curr_request = malloc(sizeof(struct request) + IN_BUF_SIZE);
if(NULL == _curr_request)
return E_MEM_OUT;
_curr_reply = malloc(sizeof(reply_t) + MAX_RPLY_SIZE);
if(NULL == _curr_reply)
return E_MEM_OUT;
_action_head.next = _action_head.prev = &_action_head;
if(NULL == (_time_bss = bss_create_empty(TIME_LEN)))
return E_MEM_OUT;
/* network initialization */
_listening_fd = create_server_socket(SERVER_PORT, MAX_QUEUED);
if(E_NET_ERR == _listening_fd)
return E_NET_ERR;
if(-1 == (_efd = epoll_create1(0)))
return E_UNKNOWN;
return 0;
}
int main(int argc, char **argv)
{
int maxsock,sockfd,sock_auth;
unsigned int myport,listnum;
fd_set fdsr;
struct timeval tv;
char *url = "OK OK";
int ret;
myport = DEF_LISTEN_PORT;
// listnum = 10;
listnum = SOMAXCONN;
if(argc > 1)
{
myport = atoi(argv[1]);
}
if(myport <= 0 )
{
printf("%s invalid paramters!\n",argv[0]);
return 0;
}
sockfd = create_server_socket(myport,listnum);
if(sockfd == -1)
{
return 0;
}
maxsock = sockfd;
LDEBUG("%s start to listen\n",argv[0]);
while(1)
{
//init file desc set
FD_ZERO(&fdsr);
FD_SET(sockfd, &fdsr);
// timeout setting
tv.tv_sec = 30;
tv.tv_usec = 0;
ret = select(maxsock + 1, &fdsr, NULL, NULL, &tv);
if(ret < 0)
{
printf("select error");
break;
}
else if(ret == 0)
{
LDEBUG("timeout\n");
continue;
}
if(FD_ISSET(sockfd, &fdsr))
{
handleRequest(sockfd,url);
}
}
return 0;
}
int main() //@ : main_full(MockKernel)
//@ requires module(MockKernel, true);
//@ ensures true;
{
struct server_socket *serverSocket = 0;
//@ open_module();
//@ int modulesId = create_ghost_set<struct module *>();
//@ int devicesId = create_ghost_set<struct device *>();
//@ close lseg(0, 0, nil, kernel_module(modulesId, devicesId));
//@ close lseg(0, 0, nil, device(modulesId, devicesId));
//@ close kernel_inv(modulesId, devicesId)();
//@ close create_lock_ghost_args(kernel_inv(modulesId, devicesId), nil, nil);
kernelLock = create_lock();
//@ assert pointer(&kernelLock, ?kernelLock_);
//@ leak pointer(&kernelLock, kernelLock_);
//@ leak lock(kernelLock_, _, kernel_inv(modulesId, devicesId));
serverSocket = create_server_socket(12345);
while (true)
//@ invariant [_]pointer(&kernelLock, kernelLock_) &*& [_]lock(kernelLock_, _, kernel_inv(modulesId, devicesId)) &*& server_socket(serverSocket);
{
struct socket *socket = server_socket_accept(serverSocket);
//@ close kernel_inv_info(modulesId, devicesId);
//@ close thread_run_data(handle_connection)(socket);
thread_start(handle_connection, socket);
}
}
int main(int argc, char **argv)
{
int server_sock;
int client_sock;
pthread_t thread_id;
struct thread_args_t *thread_args;
server_sock = create_server_socket(SERVERPORT);
for (;;) {
client_sock = accept_connection(server_sock);
// Create separate memory for client argument
if ((thread_args = (struct thread_args_t *)malloc(sizeof(struct thread_args_t))) == 0)
die_with_error("malloc() failed");
thread_args->client_sock = client_sock;
// Create client thread
if (pthread_create(&thread_id, 0, thread_main, (void *)thread_args) != 0)
die_with_error("pthread_create() failed");
printf("...with thread %lu\n", (unsigned long)thread_id);
}
/* This point is never reached. */
return 0;
}
int main(int argc, char* argv[]) {
// check input data
if (argc < 4) {
printf("usage: cproxy [-u] <host> <port> <host> <port>\n");
return -1;
}
int protocol;
char* hostname_from;
int port_from;
char* hostname_to;
int port_to;
if (strcmp(argv[1], "-u") == 0) {
protocol = IPPROTO_UDP;
hostname_from = argv[2];
port_from = atoi(argv[3]);
hostname_to = argv[4];
port_to = atoi(argv[5]);
} else {
protocol = IPPROTO_TCP;
hostname_from = argv[1];
port_from = atoi(argv[2]);
hostname_to = argv[3];
port_to = atoi(argv[4]);
}
// not buffering stdout
setbuf(stdout, NULL);
// create sockets
int socket_fd_server = create_server_socket(protocol, hostname_from, port_from);
if (socket_fd_server < 0) {
return -1;
}
printf("\n");
int socket_fd_client = create_client_socket(protocol, hostname_to, port_to);
if (socket_fd_client < 0) {
return -1;
}
// create proxy
if (protocol == IPPROTO_TCP) {
if (create_tcp_proxy(socket_fd_server, socket_fd_client) < 0) {
return -1;
}
} else {
if (create_udp_proxy(socket_fd_server, socket_fd_client) < 0) {
return -1;
}
}
return 0;
}
int server_start()
{
thread_state_t *state = NULL;
struct sockaddr_in cli_addr;
int cli_fd;
socklen_t clilen = sizeof (cli_addr);
/* Allocate new configuration */
if ((server_config = config_new()) == NULL)
{
ERROR_MSG("Internal error: Can not allocate configuration\n");
return 1;
}
/* Creating socket */
if ((server_config->socket_fd = create_server_socket(get_port())) < 0)
{
ERROR_MSG("Error: Can not create socket\n");
config_free(&server_config);
return 1;
}
while (1)
{
cli_fd = accept(server_config->socket_fd, (struct sockaddr *)&cli_addr,
&clilen);
if (cli_fd < 0)
{
ERROR_MSG("ERROR on accept\n");
continue;
}
if (check_overload() < 0)
{
ERROR_MSG("ERROR close\n");
close(cli_fd);
continue;
}
state = thread_state_new();
state->cli_fd = cli_fd;
INCR_SERVER_LOAD;
pthread_create(&(state->thread), NULL, compile_file, state);
}
config_free(&server_config);
return 0;
}
int main(int argc, char *argv[])
{
if ( argc != 2 )
error("usage: server port");
short port = atoi(argv[1]);
int server_socket = create_server_socket(port);
accept_client_requests(server_socket);
shutdown(server_socket, 2);
return 0;
}
int
init_udprelay(const char *server_host, const char *server_port,
#ifdef MODULE_LOCAL
const struct sockaddr *remote_addr, const int remote_addr_len,
#ifdef MODULE_TUNNEL
const ss_addr_t tunnel_addr,
#endif
#endif
int mtu, crypto_t *crypto, int timeout, const char *iface)
{
// Initialize ev loop
struct ev_loop *loop = EV_DEFAULT;
// Initialize MTU
if (mtu > 0) {
packet_size = mtu - 1 - 28 - 2 - 64;
buf_size = packet_size * 2;
}
// Initialize cache
struct cache *conn_cache;
cache_create(&conn_cache, MAX_UDP_CONN_NUM, free_cb);
// ////////////////////////////////////////////////
// Setup server context
// Bind to port
int serverfd = create_server_socket(server_host, server_port);
if (serverfd < 0) {
FATAL("[udp] bind() error");
}
setnonblocking(serverfd);
server_ctx_t *server_ctx = new_server_ctx(serverfd);
#ifdef MODULE_REMOTE
server_ctx->loop = loop;
#endif
server_ctx->timeout = max(timeout, MIN_UDP_TIMEOUT);
server_ctx->crypto = crypto;
server_ctx->iface = iface;
server_ctx->conn_cache = conn_cache;
#ifdef MODULE_LOCAL
server_ctx->remote_addr = remote_addr;
server_ctx->remote_addr_len = remote_addr_len;
#ifdef MODULE_TUNNEL
server_ctx->tunnel_addr = tunnel_addr;
#endif
#endif
ev_io_start(loop, &server_ctx->io);
server_ctx_list[server_num++] = server_ctx;
return serverfd;
}
/* Run on bear */
int main(int argc, char const *argv[])
{
signal(SIGPIPE, SIG_IGN);
/* code */
int peer_main_socket = create_server_socket(PEER_PORT);
pthread_t thread;
pthread_create(&thread, NULL, peer_handler_multi_thread,&peer_main_socket);
pthread_join(thread,NULL);
return 0;
}
void belle_sip_stream_listening_point_setup_server_socket(belle_sip_stream_listening_point_t *obj, belle_sip_source_func_t on_new_connection_cb ){
int port=belle_sip_uri_get_port(obj->base.listening_uri);
obj->server_sock=create_server_socket(belle_sip_uri_get_host(obj->base.listening_uri),
&port, &obj->base.ai_family);
if (obj->server_sock==(belle_sip_socket_t)-1) return;
belle_sip_uri_set_port(((belle_sip_listening_point_t*)obj)->listening_uri,port);
if (obj->base.stack->dscp)
belle_sip_socket_set_dscp(obj->server_sock,obj->base.ai_family,obj->base.stack->dscp);
obj->source=belle_sip_socket_source_new(on_new_connection_cb,obj,obj->server_sock,BELLE_SIP_EVENT_READ,-1);
belle_sip_main_loop_add_source(obj->base.stack->ml,obj->source);
}
int udprelay_init(const char *server_host, const char *server_port,
#ifdef UDPRELAY_LOCAL
const char *remote_host, const char *remote_port,
#ifdef UDPRELAY_TUNNEL
const ss_addr_t tunnel_addr,
#endif
#endif
#ifdef UDPRELAY_REMOTE
asyncns_t *asyncns,
#endif
int method, int timeout, const char *iface)
{
// Inilitialize ev loop
struct ev_loop *loop = EV_DEFAULT;
// Inilitialize cache
struct cache *conn_cache;
cache_create(&conn_cache, MAX_UDP_CONN_NUM, free_cb);
//////////////////////////////////////////////////
// Setup server context
// Bind to port
int serverfd = create_server_socket(server_host, server_port);
if (serverfd < 0)
{
FATAL("udprelay bind() error..");
}
setnonblocking(serverfd);
struct server_ctx *server_ctx = new_server_ctx(serverfd);
server_ctx->timeout = timeout;
server_ctx->method = method;
server_ctx->iface = iface;
server_ctx->conn_cache = conn_cache;
#ifdef UDPRELAY_LOCAL
server_ctx->remote_host = remote_host;
server_ctx->remote_port = remote_port;
#ifdef UDPRELAY_TUNNEL
server_ctx->tunnel_addr = tunnel_addr;
#endif
#endif
#ifdef UDPRELAY_REMOTE
server_ctx->asyncns = asyncns;
#endif
ev_io_start(loop, &server_ctx->io);
return 0;
}
int main() {
int port = 7680;
int serversock;
int clientsock;
struct sockaddr_in clientname;
size_t size = 0;
char buffer[10000];
int received;
char* cmd_step_into = "step_into";
char* cmd_step_over = "step_over";
char* cmd_step_out = "step_out";
char* cmd_continue = "continue";
char* cmd_top = "stop";
serversock = create_server_socket(port);
if(listen(serversock, 1) < 0) { //1: queue size for receiving connections
printf("server: error listening\n");
exit(EXIT_FAILURE);
}
printf("waiting...\n");
clientsock = accept(serversock, (struct sockaddr*) &clientname, &size);
printf("server: connection accepted, addr size: %d\n", size);
while(1) {
printf("waiting for data...\n");
received = recv(clientsock, buffer, sizeof(buffer), 0);
if(received < 0) {
printf("error receiving\n");
exit(EXIT_FAILURE);
} else if(received == 0) {
printf("no data received\n");
break;
} else {
printf("total pack: %d, data received: \n>>>\n%s\n<<<\n", received, buffer +1+ (strlen(buffer)*sizeof(char)));
}
printf("\n\n");
if(send(clientsock, cmd_step_into, sizeof(char)* (strlen(cmd_step_into)+1), 0) < 0) {//error
printf("client:error sending data\n");
break;
}
}
shutdown(clientsock, SHUT_RDWR);
shutdown(serversock, SHUT_RDWR); //CLOSE ALL
close(clientsock);
close(serversock);
}
/*
* Main master thread
*
* Continually loops, accepting connections. Uses the select() function to allow
* for timeouts.
*/
void *master(void *arg)
{
struct context *ctx = arg;
// Listen for incoming connections
int server_sockfd = create_server_socket(ctx);
if (listen(server_sockfd, BACKLOG) == -1) {
perror("listen");
}
// main accept() loop
fd_set read_set;
struct timeval timeout;
int max_fd, ret_val;
int stop = ctx->stop_pipe[0];
while (1) {
FD_ZERO(&read_set);
// update this if more fd's added to read set
FD_SET(server_sockfd, &read_set);
FD_SET(stop, &read_set);
max_fd = MAX(server_sockfd, stop);
timeout.tv_sec = 0;
timeout.tv_usec = 200 * 1000;
ret_val = select(max_fd + 1, &read_set, NULL, NULL, &timeout);
if (ret_val < 0) {
perror("server: select");
} else if (ret_val > 0) {
// update this if more fd's are added to read set
if (FD_ISSET(server_sockfd, &read_set)) {
trace("%s\n", "accepting a connection");
accept_connection(server_sockfd, ctx);
} else if (FD_ISSET(stop, &read_set)) {
trace("%s\n", "Stopping");
break;
}
}
}
close(server_sockfd);
trace("%s\n", "Master thread exiting");
pthread_mutex_lock(&ctx->mutex);
ctx->num_threads--;
pthread_cond_signal(&ctx->term);
pthread_mutex_unlock(&ctx->mutex);
return NULL;
}
int init_udprelay(const char *server_host, const char *server_port,
#ifdef UDPRELAY_LOCAL
const struct sockaddr *remote_addr, const int remote_addr_len,
#ifdef UDPRELAY_TUNNEL
const ss_addr_t tunnel_addr,
#endif
#endif
int method, int auth, int timeout, const char *iface)
{
// Inilitialize ev loop
struct ev_loop *loop = EV_DEFAULT;
// Inilitialize cache
struct cache *conn_cache;
cache_create(&conn_cache, MAX_UDP_CONN_NUM, free_cb);
//////////////////////////////////////////////////
// Setup server context
// Bind to port
int serverfd = create_server_socket(server_host, server_port);
if (serverfd < 0) {
FATAL("[udp] bind() error");
}
setnonblocking(serverfd);
struct server_ctx *server_ctx = new_server_ctx(serverfd);
#ifdef UDPRELAY_REMOTE
server_ctx->loop = loop;
#endif
server_ctx->auth = auth;
server_ctx->timeout = max(timeout, MIN_UDP_TIMEOUT);
server_ctx->method = method;
server_ctx->iface = iface;
server_ctx->conn_cache = conn_cache;
#ifdef UDPRELAY_LOCAL
server_ctx->remote_addr = remote_addr;
server_ctx->remote_addr_len = remote_addr_len;
#ifdef UDPRELAY_TUNNEL
server_ctx->tunnel_addr = tunnel_addr;
#endif
#endif
ev_io_start(loop, &server_ctx->io);
server_ctx_list[server_num++] = server_ctx;
return 0;
}
int main(int argc, char **argv)
{
signal(SIGCHLD, SIG_IGN);
signal(SIGUSR1, SIG_IGN);
test_mongo_connection();
int port = argc >= 2 ? atoi(argv[1]) : DEFAULT_PORT;
int server = create_server_socket(port);
while (1)
{
struct sockaddr cli_addr;
int cli_len = sizeof(cli_addr);
int client = accept(server, &cli_addr, &cli_len);
if (client < 0)
die("accept");
int pid = fork();
if (pid < 0)
die("fork");
if (pid == 0)
{
if (dup2(client, STDIN_FILENO) < 0) die("dup2 stdin");
if (dup2(client, STDOUT_FILENO) < 0) die("dup2 stdout");
D(" [%d] process started\n", getpid());
if (db_connect() == 0)
{
process_client();
db_disconnect();
}
else
{
WriteLn("DB connection problem, sorry");
D(" [%d] cannot connect to db\n", getpid());
}
D(" [%d] process finished\n", getpid());
shutdown(client, 2);
exit(0);
}
close(client);
}
close(server);
return 0;
}
static void check_port(GtkButton *button, gpointer user_data) {
gchar *valore;
valore = gtk_editable_get_chars(GTK_EDITABLE(port_entry), 0, -1);
chat_port = atoi(valore);
g_free(valore);
if (chat_port) {
serv_sock = create_server_socket();
if (serv_sock != -1) {
gtk_widget_destroy(GTK_WIDGET(user_data));
gdk_input_add(serv_sock, GDK_INPUT_READ, input_func, NULL);
}
}
}
/**
* Creates a server socket (SOCK_STREAM type) and binds it to the
* specified local port number. The socket get a ssl layer for
* data transmission.
* @param pemfilename Filename for the key/cert file
* @param port The localhost port number to open
* @param backlog The maximum queue length for incomming connections
* @param bindAddr the local address the server will bind to
* @return An ssl connection ready for accept, or NULL if an error occured.
*/
ssl_server_connection *create_ssl_server_socket(char *pemfile, int port,
int backlog,
char *bindAddr,
char *clientpemfile) {
#ifdef HAVE_OPENSSL
int socket;
ssl_server_connection *ssl_server;
ASSERT(pemfile);
ASSERT(bindAddr);
if (!ssl_initilized) {
start_ssl();
}
if ((socket= create_server_socket(port, backlog, bindAddr)) == -1) {
log("%s: create_ssl_server_socket(): Cannot connect!\n", prog);
goto sslerror;
}
if (( ssl_server= init_ssl_server(pemfile, clientpemfile)) == NULL) {
goto sslerror;
}
ssl_server->server_socket=socket;
return ssl_server;
sslerror:
return NULL;
#else
return FALSE;
#endif
}
static int init_server(dtls_listener_relay_server_type* server,
const char* ifname,
const char *local_address,
int port,
int verbose,
ioa_engine_handle e,
turn_turnserver *ts) {
if(!server) return -1;
server->dtls_ctx = e->dtls_ctx;
server->ts = ts;
server->children_ss = ur_addr_map_create(65535);
if(ifname) STRCPY(server->ifname,ifname);
if(make_ioa_addr((const u08bits*)local_address, port, &server->addr)<0) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR,"Cannot create a UDP/DTLS listener for address: %s\n",local_address);
return -1;
}
server->slen0 = get_ioa_addr_len(&(server->addr));
server->verbose=verbose;
server->e = e;
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,"IO method: %s\n",event_base_get_method(server->e->event_base));
if(server->dtls_ctx) {
#if defined(REQUEST_CLIENT_CERT)
/* If client has to authenticate, then */
SSL_CTX_set_verify(server->dtls_ctx, SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE, dtls_verify_callback);
#endif
SSL_CTX_set_read_ahead(server->dtls_ctx, 1);
#if !defined(TURN_NO_DTLS)
SSL_CTX_set_cookie_generate_cb(server->dtls_ctx, generate_cookie);
SSL_CTX_set_cookie_verify_cb(server->dtls_ctx, verify_cookie);
#endif
}
return create_server_socket(server);
}
int main(int argc, char** argv) {
if(argc!=2) {
printf(ANSI_COLOR_BOLDRED "Cantidad erronea de parametros. Este proceso recibe un parametro \n" ANSI_COLOR_RESET);
return EXIT_FAILURE;
}
/*Tratamiento del ctrl+c en el proceso */
if(signal(SIGINT, ifProcessDie) == SIG_ERR ) log_error(loggerError, ANSI_COLOR_RED"Error con la señal SIGINT"ANSI_COLOR_RESET);
/*Se genera el struct con los datos del archivo de config.- */
char* path = argv[1];
crear_estructura_config(path);
/*Se genera el archivo de log, to-do lo que sale por pantalla */
crearArchivoDeLog();
/*Se inicializan todos los semaforos necesarios */
inicializoSemaforos();
/*Se inicializan todos los semaforos necesarios */
creoEstructuraSwap();
socketServidor = create_server_socket(arch->puerto_escucha);
int32_t resultado = listen_connections(socketServidor);
if(resultado == ERROR_OPERATION) {
log_error(loggerError, ANSI_COLOR_RED "Error al escuchar nuevas conexiones"ANSI_COLOR_RESET);
exit(EXIT_FAILURE);
}
sock_t* socketCliente = accept_connection(socketServidor);
log_debug(loggerDebug, "Memoria conectada");
recibir_operaciones_memoria(socketCliente);
limpiar_estructuras_swap();
return EXIT_SUCCESS;
}
int create_gateway(gateway_handle* handle, gateway_create_params *params)
{
gateway_context *gateway = NULL;
int return_value = 0;
gateway = (gateway_context*)malloc(sizeof(gateway_context));
if(NULL == gateway)
{
LOG_ERROR(("ERROR: Out of memory\n"));
return (E_OUT_OF_MEMORY);
}
gateway->client_count = 0;
/* create network read thread */
return_value = create_network_thread(&gateway->network_thread, params->gateway_ip_address);
if(E_SUCCESS != return_value)
{
LOG_ERROR(("ERROR: Error in creating n/w read thread\n"));
delete_gateway((gateway_handle)gateway);
return (return_value);
}
/* create connection to server */
return_value = create_server_socket(&gateway->server_socket_fd, params->gateway_ip_address, params->gateway_port_no);
if(E_SUCCESS != return_value)
{
LOG_ERROR(("ERROR: Error in creating the socket\n"));
delete_gateway((gateway_handle)gateway);
return (return_value);
}
/* add socket to network read thread */
return_value = add_socket(gateway->network_thread, gateway->server_socket_fd, (void*)gateway, &accept_callback);
if(E_SUCCESS != return_value)
{
LOG_ERROR(("ERROR: add_socket() failed\n"));
delete_gateway((gateway_handle)gateway);
return (return_value);
}
*handle = gateway;
return (E_SUCCESS);
}
int
main(){
void **value_ptr = NULL;
short host_numbers[16];
short sockfd = create_server_socket();
int i;
if(sockfd < 0){
printf("\n Arbiter Error. Arbiter closing ...\n");
return -1;
}
hostsockfd_init();
sigemptyset(&set);
sigaddset(&set, SIGINT);
pthread_sigmask(SIG_BLOCK, &set, NULL);
//printf("\n Going to Signal Handling .....\n");
pthread_create(&signal_thread, 0, (void *)&signal_handler, &sockfd);
open_log_files();
//printf("\n accept_connections thread ---------------\n");
pthread_create(&accept_connections_thread, 0, (void *)&accept_connections, &sockfd);
//printf("\n get_demands thread -------------------");
for(i=0; i<16; i++){
host_numbers[i] = i+1;
pthread_create(&recieve_request_thread[i], 0, (void *)&get_demands, &(host_numbers[i]));
}
//printf("\n process_demands thread ----------------------");
pthread_create(&process_request_thread, 0, (void *)&process_demands, NULL);
// pthread_create(&send_response_thread, 0, (void *)&send_demands_to_host, NULL);
//pthread_create(&send_response_thread, 0, (void *)&get_demands, NULL);
pthread_join (accept_connections_thread, value_ptr);
for(i=0; i<16; i++)
pthread_join (recieve_request_thread[i], value_ptr);
// pthread_join (process_request_thread, value_ptr);
// pthread_join (send_response_thread, value_ptr);
//close_log_files();
return 0;
}
int main() //@ : main
//@ requires true;
//@ ensures false;
{
struct room *room = create_room();
//@ close room_ctor(room)();
//@ close create_lock_ghost_args(room_ctor(room), nil, nil);
struct lock *roomLock = create_lock();
//@ leak lock(roomLock, _, _);
struct server_socket *serverSocket = create_server_socket(12345);
for (;;)
//@ invariant [_]lock(roomLock, _, room_ctor(room)) &*& server_socket(serverSocket);
{
struct socket *socket = server_socket_accept(serverSocket);
struct session *session = create_session(room, roomLock, socket);
//@ close thread_run_data(session_run)(session);
thread_start(session_run, session);
}
}
int main(int argc, char **argv)
{
if(argc != 2)
{
printf("***Usage: %s <port to bind>\n", argv[0]);
return -1;
}
int port = atoi(argv[1]);
char hostname[100] = {0,};
gethostname(hostname, 100);
printf("***Proxy server(%s:%d) starting...\n", hostname, port);
int sockfd_proxy = create_server_socket(port);
main_loop(sockfd_proxy);
return 0;
}
static
void do_tcp_server_start(void* userdata)
{
tcp_server_t *server = (tcp_server_t*)userdata;
do
{
server->fd = create_server_socket(server->addr.port, server->addr.ip);
if (server->fd < 0)
{
log_error("do_tcp_server_start: create_server_socket() failed, local addr: %s:%u", server->addr.ip, server->addr.port);
break;
}
server->channel = channel_new(server->fd, server->loop, server_onevent, server);
if (listen(server->fd, 512) != 0)
{
log_error("do_tcp_server_start: listen() failed, errno: %d, local addr: %s:%u", errno, server->addr.ip, server->addr.port);
break;
}
if (channel_setevent(server->channel, EPOLLIN))
{
log_error("do_tcp_server_start: channel_setevent() failed, local addr: %s:%u", server->addr.ip, server->addr.port);
break;
}
return;
} while(0);
if (server->fd >= 0)
{
close(server->fd);
server->fd = -1;
}
channel_destroy(server->channel);
server->channel = NULL;
server->is_started = 0;
return;
}
static void *pipe_thread(void*p) {
char tmp[250];
server_sock=create_server_socket();
if (server_sock==ORTP_PIPE_INVALID) return NULL;
while(pipe_reader_run) {
while(client_sock!=ORTP_PIPE_INVALID) { /*sleep until the last command is finished*/
#ifndef WIN32
usleep(20000);
#else
Sleep(20);
#endif
}
client_sock=ortp_server_pipe_accept_client(server_sock);
if (client_sock!=ORTP_PIPE_INVALID) {
int len;
/*now read from the client */
if ((len=ortp_pipe_read(client_sock,(uint8_t*)tmp,sizeof(tmp)-1))>0) {
ortp_mutex_lock(&prompt_mutex);
tmp[len]='\0';
strcpy(received_prompt,tmp);
printf("Receiving command '%s'\n",received_prompt);
fflush(stdout);
have_prompt=TRUE;
ortp_mutex_unlock(&prompt_mutex);
} else {
printf("read nothing\n");
fflush(stdout);
ortp_server_pipe_close_client(client_sock);
client_sock=ORTP_PIPE_INVALID;
}
} else {
if (pipe_reader_run) fprintf(stderr,"accept() failed: %s\n",strerror(errno));
}
}
ms_message("Exiting pipe_reader_thread.");
fflush(stdout);
return NULL;
}
int connect_to_client() {
// The socket on which the server receives
// all incoming connections
int server_socket;
// The socket for unique communication with the client
int client_socket;
server_socket = create_server_socket();
client_socket = accept_client(server_socket);
// Don't need the server socket anymore (only have one connection)
// close(client_socket);
if (fork() != (pid_t)0) {
// Don't need the server socket anymore (only have one connection)
close(client_socket);
close(server_socket);
exit(EXIT_SUCCESS);
}
return client_socket;
}
int main()
{
calc_message_t* request; // Client's request message
message_t* response; // Server response message
host_t client; // Client's address
// Create a socket to listen on port 5000
int sockfd = create_server_socket("5000");
// Read the request message and generate the response
request = (calc_message_t*)receive_message(sockfd, &client);
response = create_response_message(request);
// Send the response and free the memory allocated to the messages
send_message(sockfd, response, &client);
free(request);
free(response);
// Close the socket
close(sockfd);
exit(EXIT_SUCCESS);
}
