int handle_command(char* cmd, struct client_state* client) {
char temp_name[255];
char message[255];
char recipient[255];
char send_msg[500];
if(sscanf(cmd, "name %s\r\n", temp_name)) {
sprintf(send_msg, "%s set name to %s\n", client->name, temp_name);
printf("%s",send_msg);
strcpy(client->name, temp_name);
broadcast_msg(send_msg, client);
}
else if(sscanf(cmd, "say %[^\r\n]", message)) {
printf("%s said: %s\n",client->name,message);
sprintf(send_msg, "%s> %s\n", client->name, message);
broadcast_msg(send_msg,client);
}
else if(sscanf(cmd, "whisper %[^ ] %[^\r\n]", recipient, message)==2) {
printf("%s whispered to %s: %s\n",client->name,recipient,message);
sprintf(send_msg, "~%s> %s\n", client->name, message);
unicast_msg(send_msg,recipient);
}
}
int run()
{
timer_srv.reset(new boost::asio::io_service());
the_net.reset(new net_server<koko_socket>(2));
boost::system::error_code ec;
the_config.load_from_file();
db_.reset(new utf8_data_base(the_config.accdb_host_, the_config.accdb_user_,the_config.accdb_pwd_, the_config.accdb_name_));
if(!db_->grabdb()){
glb_log.write_log("database start failed!!!!");
return -1;
}
db_delay_helper_[0].set_db_ptr(db_);
if (start_network() != 0){
goto _EXIT;
}
{
boost::shared_ptr<boost::thread> td(new boost::thread(boost::bind(db_thread_func, db_delay_helper_)));
cache_persistent_threads.push_back(td);
}
int idle_count = 0;
task_on_5sec* ptask = new task_on_5sec(*timer_srv);
task.reset(ptask);
ptask->schedule(1000);
ptask->routine();
while(!glb_exit)
{
bool busy = false;
timer_srv->reset();
timer_srv->poll();
the_net->ios_.reset();
the_net->ios_.poll();
handle_pending_logins();
pickup_player_msgs(busy);
handle_player_msgs();
update_players();
smsg_ptr pmsg;
broadcast_msg_.pop_front(pmsg);
if(pmsg.get())
broadcast_msg(pmsg);
boost::posix_time::milliseconds ms(20);
boost::this_thread::sleep(ms);
}
_EXIT:
return 0;
}
void* IpStreamReceiverTask(void* _context){
struct Context* context = (struct Context*)_context;
unsigned char *dataPtr, name_id[SENDERNAMESIZE] = {context->task_id,UNUSED,UNUSED};
unsigned char *buffer;
char printbuffer[DATASIZE];
int len;
puts("SReceiverTask: Started");
while(communication_needed) {
buffer = (unsigned char *)calloc(1, DATASIZE);
dataPtr = buffer;
buffer[0]=0xFF;
if(sslegacymode) {len = use_ipstream_server( "RESV" , buffer+2 , 1);
buffer[1] = len;
if (len < 0) break;
}
else len = use_ipstream_server( "RESV" , buffer+2 , 1);
printf("SReceiverTask: data from serial port [%s]\n", binary_to_hexbinaryString(dataPtr,dataPtr[1]+2,printbuffer));
printf("SReceiverTask: Sender: [%s]\n", binary_to_hexbinaryString(name_id,SENDERNAMESIZE,printbuffer));
puts("broadcast: SReceiverTask");
broadcast_msg(name_id, Out1, dataPtr);
}
return NULL;
}
int ethernet_demuxer (mach_msg_header_t *inp,
mach_msg_header_t *outp)
{
struct net_rcv_msg *msg = (struct net_rcv_msg *) inp;
if (inp->msgh_id != NET_RCV_MSG_ID)
return 0;
broadcast_msg (msg);
/* The data from the underlying network is inside the message,
* so we don't need to deallocate the data. */
return 1;
}
static void search_ipcam(void)
{
int ret;
struct ipcam_search_msg send_msg;
memset(&send_msg, 0, sizeof(send_msg));
send_msg.type = 0x4;
send_msg.ssrc = SSRC;
ret = broadcast_msg(IPCAM_SERVER_PORT, &send_msg, sizeof(send_msg));
if (ret < 0)
debug_print("fail: sendto return %d", ret);
return;
}
/**
Thread function that handles an individual client
**/
void * handle_client (void *arg)
{
int connfd;
char buffer[MAXMSG];
int i=0, n;
while (!quit)
{
/*read a message from this client*/
connfd = *(int*)arg; /*should cast the "connfd_arg" to an integer to use in recv function */
/* if EOF quit, otherwise broadcast it using broadcast_msg() */
n = recv(connfd,buffer,MAXMSG,0);
if(n==0){
perror("A client has sihned out");
break;
}
buffer[n] = 0;
/** lock the broadcast_msg() function **/
pthread_mutex_lock(&mutex);
broadcast_msg(buffer);
pthread_mutex_unlock(&mutex);
}
/* Cleanup resources and free the client_t memory used by this client */
while(i<MAXCLIENTS){
if(clients[i]!=NULL){
if(clients[i]->sd==connfd){
free(clients[i]);
clients[i]=NULL;
}
i++;
}
}
perror("Client disconnected");
close(connfd);
return NULL;
}
void multiplexer(int listener)
{
fd_set readfds, masterfd;
FD_ZERO(&readfds);
FD_ZERO(&masterfd);
FD_SET(listener, &masterfd);
FD_SET(STDIN, &masterfd);
int fdmax;
socklen_t addrsize;
struct sockaddr_storage their_addr;
int inbytes, new_fd, var;
char outmsg[1024], inmsg[1024];
char incoming_IP[INET6_ADDRSTRLEN]; //Extra size doesn't hurt
fdmax = listener;
while(1)
{
readfds = masterfd;
if (select(fdmax+1, &readfds, NULL, NULL, NULL) == -1)
{
perror("select");
exit(4);
}
for(int i=0; i<=fdmax; i++)
{
if(FD_ISSET(i, &readfds))
{
if(i==listener)
{
addrsize = sizeof their_addr;
if((new_fd = accept(listener, (struct sockaddr *)&their_addr, &addrsize)) == -1)
{
perror("server: accept error");
}
else
{
char c[1024];
FD_SET(new_fd, &masterfd); // add to master set
if (new_fd > fdmax)
fdmax = new_fd;
inet_ntop(their_addr.ss_family, get_in_addr(&their_addr), incoming_IP, INET6_ADDRSTRLEN);
printf("Server received a connection from %s on socket %d\n",incoming_IP, new_fd);
getnick(new_fd, c);
client_t *cli = (client_t *)malloc(sizeof(client_t));
cli->connfd = new_fd;
cli->uid = uid++;
sprintf(cli->name, "%s", c);
/* Add client to the queue */
queue_add(cli);
var = get_index(new_fd);
sprintf(outmsg, "%s %s %s", "||| WELCOME",clients[var]->name, "|||\n");
send_private(new_fd, outmsg);
sprintf(outmsg, "%s joined the room\n",clients[var]->name);
printf("%s", outmsg); //display on server
broadcast_msg(new_fd, outmsg, &masterfd, fdmax, listener);
}
}
else if(i == 0)
{
if(fgets(outmsg, 1023, stdin)==NULL)
return ;
else
{
char out[1024];
sprintf(out, "%s %s","[Server] : ", outmsg);
broadcast_msg(i, out, &masterfd, fdmax, listener);
}
}
else //Only case left is that a client got some data
{
var = get_index(i);
if(readmsg(i, 1023, inmsg))
{
printf("[%s] : %s", clients[var]->name, inmsg); //display on server
sprintf(outmsg, "[%s] : %s",clients[var]->name, inmsg);
broadcast_msg(i, outmsg, &masterfd, fdmax, listener);
}
else
{
printf("%s left the room\n", clients[var]->name); //display on server
sprintf(outmsg, "%s %s",clients[var]->name, "left the room\n");
broadcast_msg(i, outmsg, &masterfd, fdmax, listener);
FD_CLR(i, &masterfd);
close(i);
queue_delete(i);
}
}
}
}
}
}
// Receives from another IP server and sends reply back
void* IPTask(void* _IP_data_task) {
struct IP_data* IP_data_task = (struct IP_data*) _IP_data_task;
struct Context* context = (struct Context*) IP_data_task->ptr_context;
unsigned char VPS = IP_data_task->VPS, *dataPtr, msgFlag;
char printbuffer[DATASIZE];
///////////////////////////////////////
// task_id needs to be made generic! //
//name_id[SENDERNAMESIZE] = {IPTask1_id,UNUSED,UNUSED};
///////////////////////////////////////
unsigned char name_id[SENDERNAMESIZE] = { context->task_id, UNUSED,UNUSED };
int server_port = IP_data_task->port;
printf("IPTask%i: Started\n", VPS);
// Initialize socket and port
int s, client;
unsigned int tmp;
fd_set fdset;
struct timeval timer;
struct sockaddr_in c_addr;
//unsigned char *pointer;
if ((s = server_init(server_port)) < 0)
//return(s);
FD_ZERO(&fdset);
FD_SET(s, &fdset);
timer.tv_sec = 30;
timer.tv_usec = 0;
pthread_mutex_lock(context->mutex);
while (communication_needed) {
//Wait for IP packet
if (select(s + 1, &fdset, NULL, NULL, NULL)> 0 ) {
//#ifdef _DEBUG_VERBOSE
printf("IPTask%i: SELECT has continued\n",VPS);
//#endif
tmp = sizeof(c_addr);
client = accept(s, (struct sockaddr *)&c_addr, &tmp);
if (client < 0) {
printf("FAIL1: %s\n", strerror(errno));
}
if (PRINT_STATUS) {
printf("IPTask%i: client connect from %s\n",VPS,
inet_ntoa(c_addr.sin_addr));
}
usleep(10000);
if ( (dataPtr = receive_cmd(client, VPS)) != NULL )
{
//#ifdef _DEBUG_VERBOSE
printf("IPTask%i: Got [%s] from receive_cmd (ASCII)\n", VPS,binary_to_hexbinaryString(dataPtr,dataPtr[1]+2,printbuffer));
//#endif
dataPtr[1] = strlen((char*)dataPtr+2); // TODO remove warning
// Convert hexbinary to binary if first char is a hexbin char else skip conv
if( ((0x30 <= dataPtr[2]) && (dataPtr[2] <= 0x39)) || (('a' <= dataPtr[2] ) && (dataPtr[2] <= 'f')) || (('A' <= dataPtr[2]) && (dataPtr[2] <= 'F')))
{ dataPtr[1] = hexbinary_to_binary( &dataPtr[2], &dataPtr[2]);}
printf("IPTask%i: Receiving from port %i: [",VPS, server_port);
printf("%s]\n", binary_to_hexbinaryString(dataPtr,dataPtr[1]+2,printbuffer));
//printf("IPTask%i: Has data after strcat: [%s]\n",VPS,binary_to_hexbinaryString(dataPtr,dataPtr[1]+2,printbuffer));
// Pass message on
//#ifdef _DEBUG_VERBOSE
printf("broadcast: IPTask%i\n",VPS);
//#endif
broadcast_msg(name_id, Out1, dataPtr);
// DEBUG: Must wait for receiver to pass data on
//sleep(1.5);
// Begin listening on Condition for reply
//#ifdef _DEBUG_VERBOSE
printf("IPTask%i: calling receive()\n",VPS);
//#endif
//msgFlag = receive(IPTask1_id, context->condition, context->mutex);
msgFlag = receive(VPS, context->condition, context->mutex);
dataPtr = context->holder;
printf(" *** IPTask%i: Sending on port %i: [%s] ***\n", VPS, server_port, binary_to_hexbinaryString(dataPtr,dataPtr[1]+2,printbuffer));
//#ifdef _DEBUG_VERBOSE
printf("IPTask%i: received from sender: [%s]\n", VPS, binary_to_hexbinaryString(context->sender,SENDERNAMESIZE,printbuffer));
//#endif
// Send reply back thru open connection
// dataPtr+2 to avoid sending the VPS and length
//if(server_port==MANAGEMENTPORT) IP_send_server_String(client, dataPtr+2, dataPtr[1]);
//else IP_send_server_hexbinaryString(client, dataPtr+2, dataPtr[1]);
IP_send_server_hexbinaryString(client, dataPtr+2, dataPtr[1]);
printf("IPTask%i: ip send server func: \n", VPS);
}
else printf("IPTask%i: no data in client \n", VPS);
// Shutdown connection
if ((shutdown(client, 0) < 0) || (close(client) < 0)) {
printf("FAIL2: %s\n", strerror(errno));
}
} // end select
} // while-end
// Shutdown listening server
if (s> 0)
server_end(s);
printf("IPTask%i: unlocking mutex and stopping\n",VPS);
pthread_mutex_unlock(context->mutex);
return NULL;
}
int main(int argc, char **argv)
{
user_chat_box_t user_list[MAX_USERS];
server_ctrl_t server_shell;
char arg1[MSG_SIZE];
char arg2[MSG_SIZE];
char command[MSG_SIZE];
int cmd_num;
char* str_pid;
char* user_name;
int k;
int i;
int idx;
/* open non-blocking bi-directional pipes for communication with server shell */
initialize_users(user_list);
pipe(server_shell.ptoc);
pipe(server_shell.ctop);
fcntl(server_shell.ptoc[0],F_SETFL,O_NONBLOCK);
fcntl(server_shell.ctop[0],F_SETFL,O_NONBLOCK);
/* Fork the server shell */
pid_t pid = fork();
if (pid < 0)
printf("Fork error.\n");
else if (pid == 0)
{
sprintf(arg1, "%d", server_shell.ptoc[0]);
sprintf(arg2, "%d", server_shell.ctop[1]);
if(execl("./shell", "shell", arg1, arg2, "Server", (char *)0) < 0){
perror("execl error");
}
}
/*
* Inside the child.
* Start server's shell.
* exec the SHELL program with the required program arguments.
*/
/* Inside the parent. This will be the most important part of this program. */
/* Start a loop which runs every 1000 usecs.
* The loop should read messages from the server shell, parse them using the
* parse_command() function and take the appropriate actions. */
else
{
server_shell.pid = pid;
while (1)
{
/* Let the CPU breathe */
usleep(1000);
/*
* 1. Read the message from server's shell, if any
* 2. Parse the command
* 3. Begin switch statement to identify command and take appropriate action
*
* List of commands to handle here:
* CHILD_PID
* LIST_USERS
* ADD_USER
* KICK
* EXIT
* BROADCAST
*/
/* Fork a process if a user was added (ADD_USER) */
/* Inside the child */
/*
* Start an xterm with shell program running inside it.
* execl(XTERM_PATH, XTERM, "+hold", "-e", <path for the SHELL program>, ..<rest of the arguments for the shell program>..);
*/
if (read(server_shell.ctop[0], command, MSG_SIZE) > 0)
{
cmd_num = parse_command(command);
switch (cmd_num)
{
case CHILD_PID:
str_pid = extract_name(CHILD_PID, command);
server_shell.child_pid = atoi(str_pid);
break;
case LIST_USERS:
list_users(user_list, server_shell.ptoc[1]);
break;
case ADD_USER:
add_user(user_list, command, server_shell.ptoc[1]);
break;
case KICK:
user_name = extract_name(KICK, command);
if ((idx = find_user_index(user_list, user_name)) == -1)
break;
cleanup_user(idx, user_list);
break;
case EXIT:
cleanup_users(user_list);
cleanup_server(server_shell);
break;
case BROADCAST:
broadcast_msg(user_list, command, server_shell.ptoc[1], "Server");
break;
}
if(cmd_num == EXIT)break;
}
/* Back to our main while loop for the "parent" */
/*
* Now read messages from the user shells (ie. LOOP) if any, then:
* 1. Parse the command
* 2. Begin switch statement to identify command and take appropriate action
*
* List of commands to handle here:
* CHILD_PID
* LIST_USERS
* P2P
* EXIT
* BROADCAST
*
* 3. You may use the failure of pipe read command to check if the
* user chat windows has been closed. (Remember waitpid with WNOHANG
* from recitations?)
* Cleanup user if the window is indeed closed.
*/
int nsize;
for (i = 0; i < MAX_USERS; i++)
{
if (user_list[i].status == SLOT_EMPTY)
continue;
if ((nsize = read(user_list[i].ctop[0], command, MSG_SIZE)) > 0)
{
cmd_num = parse_command(command);
switch (cmd_num)
{
case CHILD_PID:
str_pid = extract_name(CHILD_PID, command);
user_list[i].child_pid = atoi(str_pid);
break;
case LIST_USERS:
list_users(user_list, user_list[i].ptoc[1]);
break;
case P2P:
send_p2p_msg(i, user_list, command);
break;
case EXIT:
cleanup_user(i, user_list);
break;
case BROADCAST:
broadcast_msg(user_list, command, server_shell.ptoc[1], user_list[i].name);
break;
}
} else if(nsize == 0) {
int status;
if(waitpid(user_list[i].child_pid, &status, WNOHANG) < 0) {
cleanup_user(i, user_list);
}
}
}
}
} /* while loop ends when server shell sees the \exit command */
return 0;
}
int main(int argc, char **argv) {
int port;
if(argc==2) {
port=atoi(argv[1]);
}
setlinebuf(stdout);
int server_sock = socket(AF_INET, SOCK_STREAM, 0);
if(server_sock < 0) {
perror("Creating socket failed: ");
exit(1);
}
struct sockaddr_in addr; // internet socket address data structure
addr.sin_family = AF_INET;
addr.sin_port = htons(port); // byte order is significant
addr.sin_addr.s_addr = INADDR_ANY; // listen to all interfaces
int res = bind(server_sock, (struct sockaddr*)&addr, sizeof(addr));
if(res < 0) {
perror("Error binding to port");
exit(1);
}
int yes=1;
if (setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
perror("setsockopt");
exit(1);
}
/* workaround for funny OS X bug - need to start listening without select */
res=fcntl(server_sock, F_SETFL, O_NONBLOCK);
if(res<0) { perror("fcntl"); }
if (listen (server_sock, 1) < 0) { perror ("listen"); exit(1); }
fcntl(server_sock, F_SETFL, 0);
/* initializing data structure for select call */
fd_set readset;
FD_ZERO(&readset);
FD_SET(server_sock,&readset);
while(1) {
fd_set rdyset;
FD_COPY(&readset,&rdyset);
int rdy = select(FD_SETSIZE,&rdyset,0,0,0);
/* if the server_sock has a new connection coming in, accept it */
if(FD_ISSET(server_sock,&rdyset)) {
int sock;
struct sockaddr_in remote_addr;
unsigned int socklen = sizeof(remote_addr);
sock = accept(server_sock, (struct sockaddr*)&remote_addr, &socklen);
if(res < 0) { perror("Error accepting connection"); exit(1); }
/* allocate and initialize new client state */
struct client_state *state=
(struct client_state*)malloc(sizeof(struct client_state));
state->next=clients;
if(clients)
clients->prev=state;
state->prev=0;
state->message_count=0;
clients=state;
state->socket=sock;
client_count++;
// added
sprintf(state->name,"Client %d",client_count);
printf("Got connection (%s)\n",state->name);
// added
/* add new socket to fd_set for select */
FD_SET(sock,&readset);
}
/* if any of the active clients are ready to deliver a message,
read it and print it */
struct client_state *clstate = clients;
while(clstate) {
if(FD_ISSET(clstate->socket,&rdyset)) {
char buf[255];
memset(buf,0,255);
int rec_count = recv(clstate->socket,buf,255,0);
if(rec_count > 0) {
clstate->message_count++;
// added
clstate->byte_count+=rec_count;
handle_command(buf,clstate);
// added
}
/* if we got nothing, that means the connection is closed */
else {
printf("closing connection...\n");
if(clstate->prev == 0) {
clients = clstate->next;
if(clients)
clients->prev = 0;
}
else {
clstate->prev->next = clstate->next;
if(clstate->next)
clstate->next->prev = clstate->prev;
}
client_count--;
// tell the others
char send_msg[255];
sprintf(send_msg, "%s disconnected.\n", clstate->name);
broadcast_msg(send_msg, clstate);
printf("%s disconnected. A total of %d bytes received from %s.\n",clstate->name, clstate->byte_count, clstate->name);
// clean up the rest of the state
shutdown(clstate->socket,SHUT_RDWR);
close(clstate->socket);
FD_CLR(clstate->socket,&readset);
struct client_state *tofree = clstate;
clstate = clstate->next;
free(tofree);
continue;
}
} // end if(FD_ISSET...
clstate=clstate->next;
} // end while
}
shutdown(server_sock,SHUT_RDWR);
}
