void*
child_comm_thread (void* chld)
{
ASSERT (chld != NULL);
struct server_child* child = (struct server_child*) chld;
server_log ("New thread for child %u, before lock", child->pid);
/* Once this call returns, the thread is good to go */
pthread_mutex_lock (&child->init_lock);
server_log ("%u, beginning loop", child->pid);
/* Main loop */
while (true)
{
struct message msg;
/* Wait for the child to send us something */
read (child->parentread, &msg, sizeof msg);
enum command cmd = msg.message;
/* Now run the child's command or otherwise interpret its message */
int result = runcommand[cmd](child, &message);
}
pthread_mutex_unlock (&child->init_lock);
pthread_exit ((void*) NULL);
};
void* server_thread(void* sockfd)
{
pthread_t thread;
pthread_attr_t attr;
int connfd;
thread_t *t_data;
struct sockaddr_in dest;
socklen_t dest_size = sizeof(struct sockaddr_in);
char *salt;
if(pthread_attr_init(&attr))
{
server_log(LOG_ERR, "server_thread: pthread_attr_init");
exit(EXIT_FAILURE);
}
if(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED))
{
server_log(LOG_ERR, "server_thread: pthread_attr_setdetachstate");
exit(EXIT_FAILURE);
}
#ifdef __WIN32__
while((connfd = accept((int)(intptr_t)sockfd, (struct sockaddr *)&dest, &dest_size)) >= 0)
#else
while((connfd = accept4((int)(intptr_t)sockfd, (struct sockaddr *)&dest, &dest_size, SOCK_CLOEXEC)) >= 0)
#endif
{
if(server.online >= server.maxusers)
{
socket_close(connfd);
continue;
}
if(!(salt = auth_salt()))
{
socket_close(connfd);
continue;
}
t_data = malloc(sizeof(thread_t));
t_data->fd = connfd;
t_data->salt = salt;
t_data->ip = strdup(inet_ntoa(dest.sin_addr));
t_data->port = ntohs(dest.sin_port);
if(pthread_create(&thread, &attr, server_conn, (void*)t_data))
{
server_log(LOG_ERR, "server_thread: pthread_create");
exit(EXIT_FAILURE);
}
}
pthread_attr_destroy(&attr);
server_log(LOG_ERR, "server_thread: accept");
exit(EXIT_FAILURE);
return NULL;
}
void player_set_timeout(player *p, time_t sec){
struct timeval tv;
tv.tv_usec = 0;
tv.tv_sec = sec;
if (setsockopt(p->fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct timeval)) < 0)
server_log(FATAL, "%s:%d [player_set_timeout] SO_RCVTIMEO", __FILE__, __LINE__);
if (setsockopt(p->fd, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(struct timeval)) < 0)
server_log(FATAL, "%s:%d [player_set_timeout] SO_SNDTIMEO" , __FILE__, __LINE__);
}
void localTcpServer_thread(void *inContext)
{
server_log_trace();
OSStatus err = kUnknownErr;
int i, j;
Context = inContext;
struct sockaddr_t addr;
int sockaddr_t_size;
fd_set readfds;
char ip_address[16];
int localTcpListener_fd = -1;
for(i=0; i < MAX_Local_Client_Num; i++)
Context->appStatus.loopBack_PortList[i] = 0;
/*Establish a TCP server fd that accept the tcp clients connections*/
localTcpListener_fd = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
require_action(IsValidSocket( localTcpListener_fd ), exit, err = kNoResourcesErr );
addr.s_ip = INADDR_ANY;
addr.s_port = Context->flashContentInRam.appConfig.localServerPort;
err = bind(localTcpListener_fd, &addr, sizeof(addr));
require_noerr( err, exit );
err = listen(localTcpListener_fd, 0);
require_noerr( err, exit );
server_log("Server established at port: %d, fd: %d", Context->flashContentInRam.appConfig.localServerPort, localTcpListener_fd);
FD_ZERO(&readfds);
FD_SET(localTcpListener_fd, &readfds);
while(1){
select(1, &readfds, NULL, NULL, NULL);
/*Check tcp connection requests */
if(FD_ISSET(localTcpListener_fd, &readfds)){
sockaddr_t_size = sizeof(struct sockaddr_t);
j = accept(localTcpListener_fd, &addr, &sockaddr_t_size);
if (j > 0) {
inet_ntoa(ip_address, addr.s_ip );
server_log("Client %s:%d connected, fd: %d", ip_address, addr.s_port, j);
if(kNoErr != mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "Local Clients", localTcpClient_thread, 0x500, &j) )
SocketClose(&j);
}
}
}
exit:
server_log("Exit: Local controller exit with err = %d", err);
mico_rtos_delete_thread(NULL);
return;
}
void send_pilot_joined_message (entity *en)
{
int
player_count;
char
text [200];
//
// Client now joined in..... send system message to other players
//
player_count = get_session_pilot_count ();
if (player_count == 1)
{
sprintf (text, "%s %s - 1 %s",
get_local_entity_string (en, STRING_TYPE_PILOTS_NAME),
get_trans ("joined"),
get_trans ("player connected"));
}
else
{
sprintf (text, "%s %s - %d %s",
get_local_entity_string (en, STRING_TYPE_PILOTS_NAME),
get_trans ("joined"),
player_count,
get_trans ("players connected"));
}
send_text_message (en, NULL, MESSAGE_TEXT_SYSTEM_NEW_PILOT, text);
server_log (text); // Jabberwock Server log
}
user_t* user_add(server_t* LIST, int fd, int auth)
{
user_t* u = malloc(sizeof(user_t));
u->fd = fd;
u->auth = auth;
u->prev = NULL;
pthread_mutex_lock(&LIST->mutex);
u->next = LIST->head;
if(LIST->head)
{
(LIST->head)->prev = u;
}
LIST->head = u;
LIST->online++;
LIST->online_auth += auth;
if(server.f_exec && LIST->online_auth == 1)
{
server_log(LOG_INFO, "executing: %s", server.f_exec);
system(server.f_exec);
}
pthread_mutex_unlock(&LIST->mutex);
return u;
}
void user_remove(server_t* LIST, user_t* USER)
{
pthread_mutex_lock(&LIST->mutex);
if(USER->prev)
{
(USER->prev)->next = USER->next;
}
else
{
LIST->head = USER->next;
}
if(USER->next)
{
(USER->next)->prev = USER->prev;
}
LIST->online--;
LIST->online_auth -= USER->auth;
if(server.l_exec && LIST->online_auth == 0)
{
server_log(LOG_INFO, "executing: %s", server.l_exec);
system(server.l_exec);
}
pthread_mutex_unlock(&LIST->mutex);
socket_close(USER->fd);
free(USER);
}
void handle_new_connexion(t_server *server)
{
socklen_t socklen;
if (FD_ISSET(server->sfd, &(server->rfds)))
{
socklen = sizeof(struct sockaddr_in);
server->cfd = accept(server->sfd, (struct sockaddr *) &(server->cin),
&socklen);
if (server->cfd != -1)
create_client(server);
else
server_log(4, 1, "Error on accept");
server_log(1, 0, "New connexion accepted\n");
}
}
char player_getc(player *p){
char ch;
int resp = 0;
size_t i;
/*
* TODO: make this configurable
* 60/3*8 = (min/h)/(socket timeout)(8 hours) = 160 number of iterations
* before you get to 8 hours, no one needs to spectate for 8 hours
*/
for(i=0; i<160; i++){
if ( read(p->fd, &ch, 1) != -1 ) return ch;
if ( errno != EAGAIN ){
/* something bad? */
server_log(ERROR, "%s:%d [player_getc] Timeout passed and socketerr for player \"%s\":%p:",
__FILE__, __LINE__,
(p->name != NULL) ? p->name : "", p
);
return 0x00;
}
/* please respond */
player_write(p,
"\xff\xfb\xf6" /* IAC WILL AYT*/
);
if ( read(p->fd, &resp, 3) < 0 )
return 0x00; /* enough waiting */
/* did they answer politely? */
if ( resp != 0xf6feff ){
server_log(ERROR, "%s:%d [player_getc] Player \"%s\":%p did not respond to AYT properly (resp = 0x%0x)!",
__FILE__, __LINE__,
(p->name != NULL) ? p->name : "", p, resp
);
return 0x00;
}
}
server_log(ERROR, "%s:%d [player_getc] Player \"%s\":%p was hanging out far too long %zu iterations",
__FILE__, __LINE__,
(p->name != NULL) ? p->name : "", p,
i
);
return 0x00;
}
static void
sigint_handler (int sig)
{
server_log ("SIGINT received, exiting... \n");
/* Exit gracefully... */
run = false;
};
void draw_snake(player *p){
int i;
point pos;
for ( i=0; i<p->slen; i++){
if ( num_to_cord(p->pix[i], &pos) != 1)
server_log(ERROR, "[draw_snake]: num_to_cord(%d, head) != 1", p->pix[i]);
place_str(pos.x, pos.y, NULL, "\e[48;5;%dm \e[0m", p->color);
}
void server_init(int port)
{
int sockfd;
struct sockaddr_in addr;
pthread_t thread;
#ifdef __WIN32__
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
#else
if((sockfd = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0)) < 0)
#endif
{
server_log(LOG_ERR, "server_init: socket");
exit(EXIT_FAILURE);
}
#ifndef __WIN32__
int value = 1;
if(setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&value, sizeof(value)) < 0)
{
server_log(LOG_ERR, "server_init: SO_REUSEADDR");
exit(EXIT_FAILURE);
}
#endif
memset((char*)&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(port);
if(bind(sockfd, (struct sockaddr*)&addr, sizeof(addr)) < 0)
{
server_log(LOG_ERR, "server_init: bind");
exit(EXIT_FAILURE);
}
listen(sockfd, 4);
if(pthread_create(&thread, NULL, server_thread, (void*)(intptr_t)sockfd))
{
server_log(LOG_ERR, "server_init: pthread_create");
exit(EXIT_FAILURE);
}
}
void log_connection(t_net *sock, char *message)
{
t_net *tmp;
char *ip;
if (sock && (tmp = sock->peer))
{
if ((ip = get_ip_addr(tmp)))
server_log(WARNING, "%s %s:%d", message, ip, port_number(tmp));
free(ip);
}
}
void send_pilot_quit_message (entity *en)
{
int
player_count;
char
text [200];
//
// Client now joined in..... send system message to other players
//
player_count = get_session_pilot_count () - 1;
if (player_count == 1)
{
sprintf (text, "%s %s - 1 %s",
get_local_entity_string (en, STRING_TYPE_PILOTS_NAME),
get_trans ("quit"),
get_trans ("player connected"));
}
else
{
sprintf (text, "%s %s - %d %s",
get_local_entity_string (en, STRING_TYPE_PILOTS_NAME),
get_trans ("quit"),
player_count,
get_trans ("players connected"));
}
send_text_message (en, NULL, MESSAGE_TEXT_SYSTEM_NEW_PILOT, text);
server_log (text); // Jabberwock Server log
if ((command_line_pause_server) && (player_count <= 1)) // 040220 Jabberwock Pause server, changed to <=1 by Werewolf
{
force_pause_acceleration();
server_log ("Server paused");
}
}
void handle_food_pop(t_server *server)
{
int i;
int x;
int y;
i = 0;
server_log(1, 0, "Don't worry, be happy ! Food pop !\n");
x = rand() % server->game_infos.size_x;
y = rand() % server->game_infos.size_y;
new_object_list(new_object(FOOD), &(server->map[y][x]));
update_food_gra(server, x, y);
i++;
}
static void graphe_log(t_server *srv, int type, t_gfx *gfx)
{
char *log;
if ((type < 3 && asprintf(&log, "%s", g_sgm[type]))
|| (type > 2 && asprintf(&log, g_sgm[type],
inet_ntoa(gfx->sin.sin_addr),
ntohs(gfx->sin.sin_port),
gfx->socket)))
{
server_log(srv, log);
ft_memdel((void **)&log);
}
}
void send_client_action(t_server *srv, t_client *clt, bool ok)
{
char *msg;
msg = NULL;
if (clt && clt->socket)
{
send(clt->socket, ok ? "ok\n" : "ko\n", 3, 0);
asprintf(&msg, "Result of command from player #%i is %s",
clt->name, ok ? "ok\n" : "ko\n");
server_log(srv, msg);
ft_memdel((void **)&msg);
}
}
/* size is tottal size of the buffer to fill at most size-1 of them */
size_t player_get_str(player *p, char *buff, size_t size, int flags){
size_t len = 0;
int bot_flag = 0;
char ch;
while (len < size-1){
ch = player_getc(p);
server_log(DEBUG, "[player_get_str] p:%p on char %d: 0x%02x", p, len, (ch & 0xff));
/*
* valid characters add it on
*/
if (
( ch >= (int) *"a" && ch <= (int) *"z" ) ||
( ch >= (int) *"A" && ch <= (int) *"Z" ) ||
( ch >= (int) *"0" && ch <= (int) *"9" ) ||
( ch == (int) *"_" ) ||
( ch == (int) *" " )
){
server_log(DEBUG, "[player_get_str] %p on char %d, ACCEPTED", p, len);
if ( ! ( flags & NO_FLIP_SPACE ) && ch == (int) *" " ) ch = *"_";
buff[len] = ch;
if ( flags & SHADOW_CHARS )
write(p->fd, "*", 1);
else
write(p->fd, &ch, 1);
len++;
/*
* backspace
*/ /* thx patrick */
}else if ( ( ch & 0xff ) == 0x7f && len > 0){
len--;
if ( player_write(p, "\e[1D \e[1D") == -1 ) destroy_player(p);
/*
* ctrl+u
*/
}else if ( ( ch & 0xff ) == 0x15 ){
char* auth_salt()
{
static const char chars[] = "QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm0123456789_-";
const int len = strlen(chars);
unsigned char random_data[XDR_TCP_SALT_LENGTH];
char* output;
int i;
if(!RAND_bytes(random_data, sizeof(random_data)))
{
server_log(LOG_ERR, "RAND_bytes failed!");
return NULL;
}
output = (char*)malloc(sizeof(char)*(XDR_TCP_SALT_LENGTH+1));
for(i=0; i<XDR_TCP_SALT_LENGTH; i++)
{
output[i] = chars[random_data[i]%len];
}
output[i] = 0;
return output;
}
void send_graphe_action(t_server *srv, char *msg,
int spec, t_client *clt)
{
t_gfx *gfx;
if (!msg)
return ;
gfx = srv->gfx;
while (msg && gfx)
{
if (gfx->isgfx && gfx->socket > 0)
{
send(gfx->socket, msg, strlen(msg), 0);
if (spec == 1 && clt)
{
command_box_content(gfx, clt->pos.x, clt->pos.y,
srv->map[clt->pos.y][clt->pos.x]);
}
}
gfx = gfx->next;
}
server_log(srv, msg);
ft_memdel((void **)&msg);
}
void validate_connections (void)
{
connection_list_type
*destroy_connection,
*this_connection;
unsigned int
timeout_limit;
this_connection = connection_list_head;
while (this_connection)
{
destroy_connection = this_connection;
this_connection = this_connection->next;
if (get_comms_model () == COMMS_MODEL_SERVER) // Jabberwock 040603 cvc turned off for clients
{
// added count_limit for connecting players
if (destroy_connection->pilot_entity)
{
timeout_limit = command_line_comms_timeout;
}
else
{
timeout_limit = command_line_comms_timeout + 15;
}
if ((get_system_time () - destroy_connection->connection_validation_time) > timeout_limit * TIME_1_SECOND)
{
if (destroy_connection->validation_count > 2) // Jabberwock 040603 Three passes
{
// Jabberwock 031107 MP bug search - this is where original crash occurs, but it's symptom, not the cause!
/* if (destroy_connection->pilot_entity)
{
entity
*gunship;
gunship = get_local_entity_parent (destroy_connection->pilot_entity, LIST_TYPE_AIRCREW);
if (gunship)
{
set_client_server_entity_int_value (gunship, INT_TYPE_PLAYER, ENTITY_PLAYER_AI);
debug_log ("SERVER: TIMEOUT: Resetting clients gunship to AI");
}
*/
// below is the replacement code for the above: sets back the helo to AI - OK
if (destroy_connection->gunship_entity)
{
set_client_server_entity_int_value (destroy_connection->gunship_entity, INT_TYPE_PLAYER, ENTITY_PLAYER_AI);
}
// the original destroy pilot_entity - may cause invalid assignment? (random entity)
// destroy_client_server_entity (destroy_connection->pilot_entity);
// debug_log ("SERVER: TIMEOUT: destroying clients pilot entity");
// }
if (destroy_connection->pilot_entity)
{
server_log("%s removed by cvc", get_local_entity_string (destroy_connection->pilot_entity, STRING_TYPE_PILOTS_NAME));
destroy_client_server_entity (destroy_connection->pilot_entity);
destroy_connection->pilot_entity = NULL;
}
else
{
server_log("Unknown player removed");
}
// Jabberwock 031108 - ends - seems to work!
if (get_comms_model () == COMMS_MODEL_SERVER)
{
debug_log ("SERVER: TIMEOUT: Unregistering connection %d", destroy_connection->connection_id);
free_connection_packets (destroy_connection->connection_id); // Jabberwock 040602 Maybe this will clear DP groups...
// Jabberwock 0312073 MP bug search - Not working - DP timeout kills the player first....
//direct_play_remove_player_from_group (destroy_connection->connection_id);
unregister_connection (destroy_connection->connection_id);
}
else
{
debug_log ("SERVER: TIMEOUT: Quitting game", destroy_connection->connection_id); // Jabberwock 040603 cvc removed for clients - DP will crash anyway...
start_game_exit (GAME_EXIT_KICKOUT, FALSE);
}
}
else
{
debug_log ("SERVER: sending %d CONNECTION_VALIDATION", destroy_connection->connection_id);
send_packet (destroy_connection->connection_id, PACKET_TYPE_CONNECTION_VALIDATION, NULL, 0, SEND_TYPE_PERSONAL);
destroy_connection->connection_validation_time = get_system_time (); // Jabberwock 040603 Restored
destroy_connection->validation_count ++;
}
}
}
}
}
void player_unlock(player *p){
/* should not unlock a player that is NULL? */
if (p->flags & DEAD) server_log(ERROR, "unlocking a dead snake");
pthread_mutex_unlock(&p->lock);
}
void serial_loop()
{
char buff[SERIAL_BUFFER];
int pos = 0;
#ifdef __WIN32__
DWORD state, len_in = 0;
BOOL fWaitingOnRead = FALSE;
OVERLAPPED osReader = {0};
osReader.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if(osReader.hEvent == NULL)
{
server_log(LOG_ERR, "serial_loop: CreateEvent");
exit(EXIT_FAILURE);
}
while(1)
{
if(!fWaitingOnRead)
{
if(!ReadFile(server.serialfd, &buff[pos], 1, &len_in, &osReader))
{
if(GetLastError() != ERROR_IO_PENDING)
{
CloseHandle(osReader.hEvent);
break;
}
else
fWaitingOnRead = TRUE;
}
}
if(fWaitingOnRead)
{
state = WaitForSingleObject(osReader.hEvent, 200);
if(state == WAIT_TIMEOUT)
continue;
if(state != WAIT_OBJECT_0 ||
!GetOverlappedResult(server.serialfd, &osReader, &len_in, FALSE))
{
CloseHandle(osReader.hEvent);
break;
}
fWaitingOnRead = FALSE;
}
if(len_in != 1)
continue;
#else
fd_set input;
FD_ZERO(&input);
FD_SET(server.serialfd, &input);
while(select(server.serialfd+1, &input, NULL, NULL, NULL) > 0)
{
if(read(server.serialfd, &buff[pos], 1) <= 0)
break;
#endif
if(buff[pos] != '\n') /* If this command is too long to fit into a buffer, clip it */
{
if(pos != SERIAL_BUFFER-1)
pos++;
continue;
}
buff[pos] = 0;
if(pos)
msg_parse_serial(buff[0], buff+1);
buff[pos] = '\n';
msg_send(buff, pos+1);
pos = 0;
}
#ifdef __WIN32__
CloseHandle(server.serialfd);
#else
close(server.serialfd);
#endif
}
void serial_write(char* msg, int len)
{
pthread_mutex_lock(&server.mutex_s);
#ifdef __WIN32__
OVERLAPPED osWrite = {0};
DWORD dwWritten;
osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if(osWrite.hEvent == NULL)
{
server_log(LOG_ERR, "server_conn: CreateEvent");
exit(EXIT_FAILURE);
}
if(!WriteFile(server.serialfd, msg, len, &dwWritten, &osWrite))
if(GetLastError() == ERROR_IO_PENDING)
if(WaitForSingleObject(osWrite.hEvent, INFINITE) == WAIT_OBJECT_0)
GetOverlappedResult(server.serialfd, &osWrite, &dwWritten, FALSE);
CloseHandle(osWrite.hEvent);
#else
write(server.serialfd, msg, len);
#endif
pthread_mutex_unlock(&server.mutex_s);
}
void serial_init(char* path)
{
#ifdef __WIN32__
server.serialfd = CreateFile(path, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
if(server.serialfd == INVALID_HANDLE_VALUE)
{
server_log(LOG_ERR, "serial_init: CreateFile");
exit(EXIT_FAILURE);
}
DCB dcbSerialParams = {0};
if(!GetCommState(server.serialfd, &dcbSerialParams))
{
CloseHandle(server.serialfd);
server_log(LOG_ERR, "serial_init: GetCommState");
exit(EXIT_FAILURE);
}
dcbSerialParams.BaudRate = CBR_115200;
dcbSerialParams.ByteSize = 8;
dcbSerialParams.StopBits = ONESTOPBIT;
dcbSerialParams.Parity = NOPARITY;
if(!SetCommState(server.serialfd, &dcbSerialParams))
{
CloseHandle(server.serialfd);
server_log(LOG_ERR, "serial_init: SetCommState");
exit(EXIT_FAILURE);
}
#else
if((server.serialfd = open(path, O_RDWR | O_NOCTTY | O_NDELAY | O_CLOEXEC)) < 0)
{
server_log(LOG_ERR, "serial_init: open");
exit(EXIT_FAILURE);
}
fcntl(server.serialfd, F_SETFL, 0);
tcflush(server.serialfd, TCIOFLUSH);
struct termios options;
if(tcgetattr(server.serialfd, &options))
{
close(server.serialfd);
server_log(LOG_ERR, "serial_init: tcgetattr");
exit(EXIT_FAILURE);
}
if(cfsetispeed(&options, B115200) || cfsetospeed(&options, B115200))
{
close(server.serialfd);
server_log(LOG_ERR, "serial_init: cfsetspeed");
exit(EXIT_FAILURE);
}
options.c_iflag &= ~(BRKINT | ICRNL | IXON | IMAXBEL);
options.c_iflag |= IGNBRK;
options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG | IEXTEN | ECHOK | ECHOCTL | ECHOKE);
options.c_oflag &= ~(OPOST | ONLCR);
options.c_oflag |= NOFLSH;
options.c_cflag |= CS8;
options.c_cflag &= ~(CRTSCTS);
if(tcsetattr(server.serialfd, TCSANOW, &options))
{
close(server.serialfd);
server_log(LOG_ERR, "serial_init: tcsetattr");
exit(EXIT_FAILURE);
}
#endif
tuner_reset();
}
void* server_conn(void* t_data)
{
int connfd = ((thread_t*)t_data)->fd;
char* salt = ((thread_t*)t_data)->salt;
char* ip = ((thread_t*)t_data)->ip;
uint16_t port = ((thread_t*)t_data)->port;
user_t *u;
fd_set input;
char buffer[100];
int pos = 0, auth = 0;
free(t_data);
snprintf(buffer, sizeof(buffer), "%s\n", salt);
send(connfd, buffer, strlen(buffer), MSG_NOSIGNAL);
if(recv(connfd, buffer, 41, MSG_NOSIGNAL) == 41)
{
buffer[40] = 0;
auth = auth_hash(salt, server.password, buffer);
}
free(salt);
if(!auth && !server.guest)
{
snprintf(buffer, sizeof(buffer), "a0\n");
send(connfd, buffer, strlen(buffer), MSG_NOSIGNAL);
#ifdef __WIN32__
Sleep(2000);
#endif
socket_close(connfd);
free(ip);
return NULL;
}
if(!auth && server.guest)
{
snprintf(buffer, sizeof(buffer), "a1\n");
send(connfd, buffer, strlen(buffer), MSG_NOSIGNAL);
}
#ifdef __WIN32__
unsigned long on = 1;
if (ioctlsocket(connfd, FIONBIO, &on) != NO_ERROR)
{
server_log(LOG_ERR, "server_conn: ioctlsocket");
free(ip);
exit(EXIT_FAILURE);
}
#else
fcntl(connfd, F_SETFL, O_NONBLOCK);
#endif
server_log(LOG_INFO, "user connected: %s:%u%s", ip, port, (auth ? "" : " (guest)"));
if(server.online_auth)
{
snprintf(buffer, sizeof(buffer),
"M%d\nY%d\nT%d\nD%d\nA%d\nF%d\nZ%d\nG%02d\nV%d\nQ%d\nC%d\nI%d,%d\n",
server.mode,
server.volume,
server.freq,
server.deemphasis,
server.agc,
server.filter,
server.ant,
server.gain,
server.daa,
server.squelch,
server.rotator,
server.sampling,
server.detector);
send(connfd, buffer, strlen(buffer), MSG_NOSIGNAL);
}
u = user_add(&server, connfd, auth);
snprintf(buffer, sizeof(buffer), "o%d,%d\n",
server.online_auth,
server.online - server.online_auth);
msg_send(buffer, strlen(buffer));
FD_ZERO(&input);
FD_SET(u->fd, &input);
while(select(u->fd+1, &input, NULL, NULL, NULL) > 0)
{
if(recv(u->fd, &buffer[pos], 1, MSG_NOSIGNAL) <= 0)
break;
/* If this command is too long to
* fit into a buffer, clip it */
if(buffer[pos] != '\n')
{
if(pos != sizeof(buffer)-1)
pos++;
continue;
}
if(buffer[0] == XDR_P_SHUTDOWN)
break;
if(u->auth)
serial_write(buffer, pos+1);
pos = 0;
}
user_remove(&server, u);
server_log(LOG_INFO, "user disconnected: %s:%u", ip, port);
free(ip);
if(server.online)
{
snprintf(buffer, sizeof(buffer), "o%d,%d\n",
server.online_auth,
server.online - server.online_auth);
msg_send(buffer, strlen(buffer));
}
if(!server.online_auth && server.poweroff)
{
if(server.online)
{
/* tell unauthenticated users that XDR has been powered off */
sprintf(buffer, "X\n");
msg_send(buffer, strlen(buffer));
}
server_log(LOG_INFO, "tuner shutdown");
tuner_reset();
}
return NULL;
}
void destroy_player(player *p){
/*
* called twice, per snake to exit, once per each thread first call marks
* snake as dead, second call cleans up the mess
*
* only called once for spectators and bots
*/
/* it is a snake, and is alive. kill it and exit thread */
if ( ( p->flags & ( DEAD | SPECTATOR ) ) == 0 ){
server_log(DEBUG, "part1 destroying player %p:%s", p,p->name);
pthread_mutex_lock(&p->lock);
p->flags |= DEAD;
/* get a response to kill controle thread if it is still there*/
player_write(p,
"\xff\xfb\xf6" /* IAC WILL AYT*/
);
pthread_mutex_unlock(&p->lock);
pthread_exit(0);
return;
}
/* snake is dead...
* you are the only one who remembers him
* clean him up and exit
* it is what he would of wanted.
* at least he won't be in our memory
*/
if ( p->score > 0 ){
server_log(INFO, "Player \"%s\" %p %s:%d scored %d",
p->name, p,
inet_ntoa(p->addr.sin_addr), ntohs(p->addr.sin_port),
p->score
);
if ( serv_check_highscore(p) )
serv_notify_all(p->color, "NEW HIGH SCORE %s: %d", p->name, p->score);
}else{
if ( p->flags & SPECTATOR )
serv_notify_all(1, "A watcher has decided to leave...");
}
if ( p->name == NULL )
server_log(FATAL, "%s line %d p->name == NULL", __FILE__, __LINE__);
pthread_mutex_destroy(&p->lock);
/* delete player from server list */
if ( serv_del_player(p) == -1 && serv_get_flags() & RANDOM_MODES )
serv_set_flags( serv_get_flags() & ( ~ ALL_MODES ) );
if ( p->flags & BOT )
server_log(INFO, "FILTHY STINKING BOT %p:%s destroyed", p, p->name);
else if ( p->flags & SPECTATOR )
server_log(INFO, "Spectator %p:%s destroyed", p, p->name);
else
server_log(INFO, "Player %p:%s destroyed", p, p->name);
free(p->name);
close(p->fd);
free(p->pix);
free(p);
pthread_exit(0);
}
int main(int argc, char* argv[])
{
char serial[250] = DEFAULT_SERIAL;
int port = XDR_TCP_DEFAULT_PORT;
int c;
server.background = 0;
server.guest = 0;
server.password = NULL;
server.maxusers = DEFAULT_USERS;
server.f_exec = NULL;
server.l_exec = NULL;
server.online = 0;
server.online_auth = 0;
server.head = NULL;
tuner_defaults();
pthread_mutex_init(&server.mutex, NULL);
pthread_mutex_init(&server.mutex_s, NULL);
#ifdef __WIN32__
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2,2), &wsaData))
{
server_log(LOG_ERR, "main: WSAStartup");
exit(EXIT_FAILURE);
}
#else
if(getuid() == 0)
{
fprintf(stderr, "error: running the server as root is a bad idea, giving up!\n");
exit(EXIT_FAILURE);
}
#endif
while((c = getopt(argc, argv, "hbgxt:s:u:p:f:l:")) != -1)
{
switch(c)
{
case 'h':
show_usage(argv[0]);
#ifndef __WIN32__
case 'b':
server.background = 1;
break;
#endif
case 'g':
server.guest = 1;
break;
case 'x':
server.poweroff = 1;
break;
case 't':
port = atoi(optarg);
break;
case 's':
#ifdef __WIN32__
snprintf(serial, sizeof(serial), "\\\\.\\%s", optarg);
#else
snprintf(serial, sizeof(serial), "%s", optarg);
#endif
break;
case 'u':
server.maxusers = atoi(optarg);
break;
case 'p':
server.password = optarg;
break;
case 'f':
server.f_exec = prepare_cmd(optarg);
break;
case 'l':
server.l_exec = prepare_cmd(optarg);
break;
case ':':
case '?':
show_usage(argv[0]);
}
}
if(port < 1024 || port > 65535)
{
fprintf(stderr, "error: the tcp port must be in 1024-65535 range\n");
show_usage(argv[0]);
}
if(!server.password || !strlen(server.password))
{
fprintf(stderr, "error: no password specified\n");
show_usage(argv[0]);
}
#ifndef __WIN32__
if(server.background)
{
switch(fork())
{
case -1:
server_log(LOG_ERR, "fork");
exit(EXIT_FAILURE);
case 0:
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
umask(0);
break;
default:
exit(EXIT_SUCCESS);
}
if(open("/dev/null", O_RDONLY) == -1 ||
open("/dev/null", O_WRONLY) == -1 ||
open("/dev/null", O_RDWR) == -1)
{
server_log(LOG_ERR, "open /dev/null");
exit(EXIT_FAILURE);
}
if(setsid() < 0)
{
server_log(LOG_ERR, "setsid");
exit(EXIT_FAILURE);
}
if(chdir("/") < 0)
{
server_log(LOG_ERR, "chdir");
exit(EXIT_FAILURE);
}
}
#endif
server_log(LOG_INFO, "xdrd " VERSION " is starting using %s and TCP port: %d", serial, port);
server_init(port);
serial_init(serial);
serial_loop();
#ifdef __WIN32__
WSACleanup();
#endif
server_log(LOG_ERR, "lost connection with tuner");
return EXIT_FAILURE;
}
void localTcpClient_thread(void *inFd)
{
OSStatus err;
int i;
int indexForPortTable;
int clientFd = *(int *)inFd;
int currentRecved = 0;
int clientLoopBackFd = -1;
uint8_t *inDataBuffer = NULL;
uint8_t *outDataBuffer = NULL;
int len;
struct sockaddr_t addr;
fd_set readfds;
struct timeval_t t;
inDataBuffer = malloc(wlanBufferLen);
require_action(inDataBuffer, exit, err = kNoMemoryErr);
outDataBuffer = malloc(wlanBufferLen);
require_action(outDataBuffer, exit, err = kNoMemoryErr);
for(i=0; i < MAX_Local_Client_Num; i++) {
if( Context->appStatus.loopBack_PortList[i] == 0 ){
Context->appStatus.loopBack_PortList[i] = loopBackPortTable[clientFd];
indexForPortTable = i;
break;
}
}
/*Loopback fd, recv data from other thread */
clientLoopBackFd = socket( AF_INET, SOCK_DGRM, IPPROTO_UDP );
require_action(IsValidSocket( clientLoopBackFd ), exit, err = kNoResourcesErr );
addr.s_ip = IPADDR_LOOPBACK;
addr.s_port = Context->appStatus.loopBack_PortList[indexForPortTable];
err = bind( clientLoopBackFd, &addr, sizeof(addr) );
require_noerr( err, exit );
t.tv_sec = 4;
t.tv_usec = 0;
while(1){
FD_ZERO(&readfds);
FD_SET(clientFd, &readfds);
FD_SET(clientLoopBackFd, &readfds);
select(1, &readfds, NULL, NULL, &t);
/*recv UART data using loopback fd*/
if (FD_ISSET( clientLoopBackFd, &readfds )) {
len = recv( clientLoopBackFd, outDataBuffer, wlanBufferLen, 0 );
SocketSend( clientFd, outDataBuffer, len );
}
/*Read data from tcp clients and process these data using HA protocol */
if (FD_ISSET(clientFd, &readfds)) {
len = recv(clientFd, inDataBuffer+currentRecved, wlanBufferLen-currentRecved, 0);
require_action_quiet(len>0, exit, err = kConnectionErr);
currentRecved += len;
haWlanCommandProcess(inDataBuffer, ¤tRecved, clientFd, Context);
}
}
exit:
server_log("Exit: Client exit with err = %d", err);
Context->appStatus.loopBack_PortList[indexForPortTable] = 0;
if(clientLoopBackFd != -1)
SocketClose(&clientLoopBackFd);
SocketClose(&clientFd);
if(inDataBuffer) free(inDataBuffer);
if(outDataBuffer) free(outDataBuffer);
mico_rtos_delete_thread(NULL);
return;
}
void localTcpClient_thread(void *inFd)
{
OSStatus err;
int clientFd = *(int *)inFd;
uint8_t *inDataBuffer = NULL;
int len;
int len_temp;
fd_set readfds;
fd_set writeSet;
struct timeval_t t;
int eventFd = -1;
mico_queue_t queue;
socket_msg_t *msg;
int sent_len, errno;
inDataBuffer = malloc(wlanBufferLen);
require_action(inDataBuffer, exit, err = kNoMemoryErr);
err = socket_queue_create(context, &queue);
require_noerr( err, exit );
eventFd = mico_create_event_fd(queue);
if (eventFd < 0) {
server_log("create event fd error");
goto exit_with_queue;
}
t.tv_sec = 4;
t.tv_usec = 0;
while(1){
FD_ZERO(&readfds);
FD_SET(clientFd, &readfds);
FD_SET(eventFd, &readfds);
select(24, &readfds, NULL, NULL, &t);
/* send UART data */
if (FD_ISSET( eventFd, &readfds )) { // have data and can write
FD_ZERO(&writeSet );
FD_SET(clientFd, &writeSet );
t.tv_usec = 100*1000; // max wait 100ms.
select(1, NULL, &writeSet, NULL, &t);
if((FD_ISSET( clientFd, &writeSet )) &&
(kNoErr == mico_rtos_pop_from_queue( &queue, &msg, 0))) {
sent_len = write(clientFd, msg->data, msg->len);
if (sent_len <= 0) {
len = sizeof(errno);
getsockopt(clientFd, SOL_SOCKET, SO_ERROR, &errno, &len);
socket_msg_free(msg);
server_log("write error, fd: %d, errno %d", clientFd, errno );
if (errno != ENOMEM) {
goto exit_with_queue;
}
} else {
socket_msg_free(msg);
}
}
}
/*Read data from tcp clients and process these data using HA protocol */
if (FD_ISSET(clientFd, &readfds)) {
len = recv(clientFd, inDataBuffer, wlanBufferLen, 0);
len_temp=len;
tcp_date_num+=len;
require_action_quiet(len>0, exit_with_queue, err = kConnectionErr);
// sppWlanCommandProcess(inDataBuffer, &len, clientFd, context);
// MicoUartSend(MFG_TEST, inDataBuffer, len_temp);//wcz wcz_add
}
}
exit_with_queue:
len = sizeof(errno);
getsockopt(clientFd, SOL_SOCKET, SO_ERROR, &errno, &len);
server_log("Exit: Client exit with err = %d, socket errno %d", err, errno);
if (eventFd >= 0) {
mico_delete_event_fd(eventFd);
}
socket_queue_delete(context, &queue);
exit:
SocketClose(&clientFd);
if(inDataBuffer) free(inDataBuffer);
mico_rtos_delete_thread(NULL);
return;
}
int main(int argc, char **argv)
{
int port_n, sockfd;
struct sockaddr_in server, client;
char message[512];
if(argc != 2){
printMsg("Incorrect number of arguments.");
return 0;
}
/* Read in port number */
if(!sscanf(&argv[1][0], "%d", &port_n)){
printMsg("Needs port number.");
return 0;
}
/* Create and bind a TCP socket */
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
perror("cannot create socket");
return 0;
}
memset(&server, 0, sizeof(server));
server = configureServerStruct(server, port_n);
if(bind(sockfd, (struct sockaddr *) &server, (socklen_t) sizeof(server))){
perror("bind failed");
return 0;
}
/* Before we can accept messages, we have to listen to the port. We allow one
* 40 connections to queue.
*/
if(listen(sockfd, 40) == -1){
perror("listen()");
return 0;
}
while(1) {
fd_set rfds;
struct timeval tv;
int retval;
/* Check whether there is data on the socket fd. */
FD_ZERO(&rfds);
FD_SET(sockfd, &rfds);
/* Wait for 30 seconds. */
tv.tv_sec = 30;
tv.tv_usec = 0;
if ((retval = select(sockfd + 1, &rfds, NULL, NULL, &tv)) == -1) {
perror("select()");
} else if (retval > 0) {
/* declare variables */
int connfd, pid, childstatus;
socklen_t len;
/* Data is available, receive it. */
assert(FD_ISSET(sockfd, &rfds));
/* Copy to len, since recvfrom may change it. */
len = (socklen_t) sizeof(client);
/* For TCP connectios, we first have to accept. */
if((connfd = accept(sockfd, (struct sockaddr *) &client,
&len)) == -1){
perror("accept()");
return 0;
}
/* Fork a handler to manage request */
if((pid = fork()) < 0){
perror("fork()");
close(connfd);
}else if(pid > 0){
/* Parent: close connection to request and go listen for more */
close(connfd);
}else{
/* Child: close connection to listner and process request */
close(sockfd);
int i = 0, j = 0;
char *payload = NULL, *token, *cookieValue = NULL;
ssize_t n;
Log requestData;
while(1){
/*
* set timeout for request connections
* http://stackoverflow.com/questions/4181784/how-to-set-socket-timeout-in-c-when-making-multiple-connections
*/
if (setsockopt (connfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)) < 0){
perror("setsockopt()");
}
/* Receive one byte less than declared,
because it will be zero-termianted
below. */
if((n = read(connfd, message, sizeof(message) - 1)) == -1){
perror("read()");
return 0;
}
/* Zero terminate the message, otherwise
printf may access memory outside of the
string. */
message[n] = '\0';
/* Print the message to stdout and flush. */
//fprintf(stdout, "Received:\n%s\n", message);
//fflush(stdout);
/* find payload */
while(message[i] != '\0'){
if(message[i] == '\n'){
if(message[i+1] == '\r'){ //found payload
i+=3;
payload = &message[i];
break;
}
}
i++;
}
/* read input to log data struct */
requestData.requestMethod = strtok(message, " \r\n");
requestData.requestURL = strtok(NULL, " \r\n");
/* variable filter to contain uri arguments */
char *filter = NULL;
i = 0;
while(requestData.requestURL[i] != '\0'){
if(requestData.requestURL[i] == '/'){
j = i;
}
if(requestData.requestURL[i] == '?'){
filter = strdup(&requestData.requestURL[j + 1]);
break;
}
i++;
}
/* find and record relevant information */
do{
token = strtok(NULL, " \n");
if(token != NULL && strcmp(token, "Host:") == 0){
token = strtok(NULL, " \r\n");
requestData.host = token;
}
if(token != NULL && strcmp(token, "Connection:") == 0){
token = strtok(NULL, " \r\n");
requestData.keepAlive = strcmp(token, "keep-alive") ? 1 : 0;
}
if(token != NULL && strcmp(token, "Cookie:") == 0){
token = strtok(NULL, " \r\n");
cookieValue = token;
}
}while(token != NULL);
requestData.clientIP = inet_ntoa(client.sin_addr);
requestData.clientPort = ntohs(client.sin_port);
time_t now = time(NULL);
struct tm *t = localtime(&now);
strftime(requestData.timestamp, sizeof(requestData.timestamp)-1, "%Y-%m-%dT%H:%M:%S%z", t);
token = requestData.requestMethod;
sendReply(connfd, requestData, payload, token, filter, cookieValue);
if(!strcmp(token, "HEAD") || !strcmp(token, "POST") || !strcmp(token, "GET")){
requestData.resCode = 200;
}else{
requestData.resCode = 400;
}
server_log(requestData);
/* Close connection */
if(!requestData.keepAlive){
shutdown(connfd, SHUT_RDWR);
close(connfd);
return 0;
}
}
}
/* Reap children */
while((pid = waitpid(-1, &childstatus, WNOHANG)) != 0){
if(pid < 0) {
perror("waitpid()");
break;
}
}
} else {
/* Listner */
fprintf(stdout, "No message in five seconds.\n");
fflush(stdout);
}
}
}
