/** * @brief Thread to handle WebService requests * @return never returns until shutdown * * Receives requests over a web socket and acts on them. */ void *WebServiceThread( void *arg ) { char *port; char *logdir; char buf[1024]; char **options; struct mg_context *ctx; pthread_mutex_lock( startupMutex ); port = pb_get_setting( "webServicePort" ); if( !port || !atoi(port) ) { LogPrintNoArg( LOG_CRIT, "No WebService Port defined. Aborting!" ); return; } logdir = pb_get_setting( "webServiceLogDir" ); if( !logdir ) { logdir = memstrlink( "/tmp" ); } LogPrint( LOG_DEBUG, "Web Service listening on port %s", port ); LogPrint( LOG_DEBUG, "Web Logs in %s", logdir ); options = CREATEN(char *, 7); options[0] = memstrlink("ports"); options[1] = memstrdup(port); options[2] = memstrlink("access_log"); sprintf( buf, "%s/access.log", logdir ); options[3] = memstrdup(buf); options[4] = memstrlink("error_log"); sprintf( buf, "%s/error.log", logdir ); options[5] = memstrdup(buf); options[6] = NULL; memfree( port ); memfree( logdir ); mg_set_allocs( &webServiceAllocs ); /* * Initialize mongoose context. * Start listening on port specified. */ ctx = mg_start(webServiceCallback, NULL, (const char **)options); while( !GlobalAbort ) { sleep(1); } mg_stop(ctx); LogPrintNoArg(LOG_INFO, "Ending WebServiceThread"); return( NULL ); }
/** * @brief Handles all network connections * @param arg a pointer to a structure containing port number and timeout * @return never returns until shutdown * * @todo be sure this handles linkdead without removing all player structures * so the player can log back in and be where they were * * Brings up a TCP listener on the MUD's assigned port and accepts connections. * Also reads all data from connected clients and hands the data off to the * Input thread. When there is output to be sent, this thread handles writing * to the sockets after the first write has completed. This thread also * handles the disconnection of clients gracefully. */ void *ConnectionThread( void *arg ) { connectThreadArgs_t *argStruct; int portNum; char *port; struct sockaddr_in6 sa; int count; int fdCount; int newFd; socklen_t salen; struct timeval timeout; ConnectionItem_t *item; PlayerStruct_t *player; ConnInputItem_t *connItem; ConnDnsItem_t *dnsItem; uint32 i; int on; int retval; char ch; argStruct = (connectThreadArgs_t *)arg; portNum = argStruct->port; pthread_mutex_lock( startupMutex ); if( portNum == -1 ) { port = pb_get_setting( "listenPort" ); if( !port ) { portNum = 4000; } else { portNum = atoi(port); memfree(port); } } /* * Start listening */ listenFd = socket( AF_INET6, SOCK_STREAM, 0 ); if( listenFd < 0 ) { perror("Opening listener socket"); exit(1); } on = 1; if( setsockopt( listenFd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) ) ) { perror("Setting socket to reuse"); exit(1); } memset(&sa, 0, sizeof(sa)); sa.sin6_family = AF_INET6; sa.sin6_port = htons(portNum); sa.sin6_addr = in6addr_any; if (bind(listenFd, (struct sockaddr *)&sa, sizeof(sa)) < 0) { perror("Binding listener socket"); close(listenFd); exit(1); } if (listen(listenFd, 10)) { perror("Listening to socket"); close(listenFd); exit(1); } FD_ZERO(&saveReadFds); FD_ZERO(&saveWriteFds); FD_ZERO(&saveExceptFds); connAddFd(listenFd, &saveReadFds); ConnectionList = LinkedListCreate(NULL); LogPrint( LOG_NOTICE, "Listening on port %d", portNum ); pthread_mutex_unlock( startupMutex ); while( !GlobalAbort ) { /* * Select on connected and listener */ readFds = saveReadFds; writeFds = saveWriteFds; exceptFds = saveExceptFds; timeout.tv_sec = argStruct->timeout_sec; timeout.tv_usec = argStruct->timeout_usec; fdCount = select(maxFd+1, &readFds, &writeFds, &exceptFds, &timeout); if( GlobalAbort ) { continue; } recalcMaxFd = FALSE; /* * Open a connection for listener */ if( FD_ISSET(listenFd, &readFds) ) { salen = sizeof(struct sockaddr_in6); newFd = accept(listenFd, (struct sockaddr *)&sa, &salen); connAddFd(newFd, &saveReadFds); connAddFd(newFd, &saveExceptFds); item = CREATE(ConnectionItem_t); if( !item ) { /* * No memory! */ LogPrintNoArg( LOG_EMERG, "Out of memory!" ); close(newFd); } else { item->fd = newFd; item->buffer = BufferCreate(MAX_BUFSIZE); item->hostName = ProtectedDataCreate(); ProtectedDataLock( item->hostName ); item->hostName->data = CREATEN(char, 50); inet_ntop(AF_INET6, &sa.sin6_addr, item->hostName->data, 50); if( !strncmp(item->hostName->data, "::ffff:", 7) ) { bcopy((char *)item->hostName->data + 7, item->hostName->data, 43); } ProtectedDataUnlock( item->hostName ); if (!IS_SET(SystemFlags, SYS_SKIPDNS)) { dnsItem = CREATE(ConnDnsItem_t); if( dnsItem ) { dnsItem->connection = item; memcpy(dnsItem->ipAddr, &sa.sin6_addr, 16); QueueEnqueueItem(ConnectDnsQ, dnsItem); } } player = CREATE(PlayerStruct_t); if( !player ) { /* * No memory! */ LogPrintNoArg( LOG_EMERG, "Out of memory!" ); BufferDestroy(item->buffer); close(newFd); memfree(item); } else { item->player = player; player->connection = item; player->in_buffer = item->buffer; LinkedListAdd( ConnectionList, (LinkedListItem_t *)item, UNLOCKED, AT_TAIL ); /* * Pass the info on to the other threads... */ #ifdef DEBUG_CONNECT LogPrint( LOG_INFO, "New connection: %p", player ); #endif connItem = CREATE(ConnInputItem_t); if( connItem ) { connItem->type = CONN_NEW_CONNECT; connItem->player = player; QueueEnqueueItem(ConnectInputQ, (QueueItem_t)connItem); } } } fdCount--; } if( fdCount ) { LinkedListLock( ConnectionList ); for( item = (ConnectionItem_t *)(ConnectionList->head); item && fdCount; item = (item ? (ConnectionItem_t *)item->link.next : (ConnectionItem_t *)ConnectionList->head) ) { if( FD_ISSET( item->fd, &exceptFds ) ) { /* * This connection's borked, close it, remove it, move on */ if( FD_ISSET( item->fd, &readFds ) ) { fdCount--; } if( FD_ISSET( item->fd, &writeFds ) ) { fdCount--; } BufferLock( item->buffer ); item = connRemove(item); fdCount--; continue; } if( item && FD_ISSET( item->fd, &readFds ) ) { /* * This connection has data ready */ count = BufferAvailWrite( item->buffer, TRUE ); if( !count ) { /* * No buffer space, the buffer's unlocked, move on */ LogPrint( LOG_INFO, "No buffer space: %p", item ); continue; } /* * The buffer's locked */ count = read( item->fd, BufferGetWrite( item->buffer ), count ); if( !count ) { LogPrint( LOG_DEBUG, "EOF on %d", item->fd ); /* * We hit EOF, close and remove */ if( FD_ISSET( item->fd, &writeFds ) ) { fdCount--; } item = connRemove(item); fdCount--; continue; } BufferWroteBytes( item->buffer, count ); BufferUnlock( item->buffer ); /* * Tell the input thread */ connItem = CREATE(ConnInputItem_t); if( connItem ) { #ifdef DEBUG_INPUT LogPrint( LOG_INFO, "New data: %p", item->player ); #endif connItem->type = CONN_INPUT_AVAIL; connItem->player = item->player; QueueEnqueueItem(ConnectInputQ, (QueueItem_t)connItem); } } if( item && FD_ISSET( item->fd, &writeFds ) ) { /* * We have space to output, so write if we have anything * to write */ #ifdef DEBUG_OUTPUT LogPrint( LOG_INFO, "Output sent to: %p", item ); #endif if( item->outBufDesc ) { /* TODO: deal with partial block writes */ retval = write( item->fd, item->outBufDesc->buf, item->outBufDesc->len ); memfree( item->outBufDesc->buf ); memfree( item->outBufDesc ); item->outBufDesc = NULL; } /* * Kick the next output */ connKickOutput( item ); fdCount--; } } LinkedListUnlock( ConnectionList ); } if( recalcMaxFd ) { LinkedListLock( ConnectionList ); maxFd = listenFd; for( item = (ConnectionItem_t *)(ConnectionList->head); item; item = (ConnectionItem_t *)item->link.next ) { if( item->fd > maxFd ) { maxFd = item->fd; } } LinkedListUnlock( ConnectionList ); } }