/** * @brief Formats and enqueues a log message for the Logging thread * @param level the logging level to log at * @param file the sourcefile the message is from * @param line the line in the sourcefile the message is from * @param function the function the message is from * @param format the printf-style format string * * Creates a log message (up to LOGLINE_MAX) in length using vsnprintf, and * enqueues it with a timestamp, thread and sourcefile info. These messages * go onto the LoggingQ which is then read by the Logging thread. When this * function returns, all strings passed in can be reused or freed. */ void LogPrintLine( LogLevel_t level, char *file, int line, char *function, char *format, ... ) { LoggingItem_t *item; va_list arguments; if( level > LogLevel ) { return; } item = (LoggingItem_t *)malloc(sizeof(LoggingItem_t)); if( !item ) { return; } item->level = level; item->threadId = pthread_self(); item->file = file; item->line = line; item->function = function; gettimeofday( &item->tv, NULL ); item->message = (char *)malloc(LOGLINE_MAX+1); if( !item->message ) { free( item ); return; } va_start(arguments, format); vsnprintf(item->message, LOGLINE_MAX, format, arguments); va_end(arguments); QueueEnqueueItem( LoggingQ, item ); }
HavokResponse *protobufQueue( HavokRequest *request, ProtobufResFunc_t callback, void *arg, bool block ) { ProtobufItem_t *item; HavokResponse *response; if( !request ) { return; } item = CREATE(ProtobufItem_t); if( !item ) { return; } item->request = request; item->callback = callback; item->callbackArg = arg; if( block ) { item->mutex = CREATE(pthread_mutex_t); pthread_mutex_init( item->mutex, NULL ); pthread_mutex_lock( item->mutex ); } QueueEnqueueItem( ProtobufQ, item ); if( !block ) { return( NULL ); } pthread_mutex_lock( item->mutex ); response = item->response; protobufDestroyItem( item ); return( response ); }
/** * @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 ); } }