void logging_initialize( bool ncurses ) { LoggingQ = QueueCreate(1024); LogList = LinkedListCreate(); if( !ncurses ) { LogStdoutAdd(); } else { LogNcursesAdd(); } LogSyslogAdd( LOG_LOCAL7 ); if( Debug ) { LogFileAdd( DEBUG_FILE ); } thread_create( &loggingThreadId, LoggingThread, NULL, "thread_logging", 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 ); } }
void regexp_initialize( void ) { regexpList = LinkedListCreate(); versionAdd( "pcre", (char *)pcre_version() ); }
QueueObject_t * QueueCreate( uint32 numElements ) { QueueObject_t *queue; QueueItem_t *items; int status; uint32 i; if( numElements == 0 ) { return( NULL ); } /* Round the numElements to a power of 2 for efficiency */ for( i = 0; i < 32 && (uint64)numElements > (uint64)(1<<i); i++ ); if( i == 32 ) { LogPrint( LOG_CRIT, "Queue too large. Rounded from %d to %d", numElements, 1 << 31 ); i = 31; } else { if( numElements != (1<<i) ) { LogPrint( LOG_CRIT, "Queue item count rounded from %d to %d", numElements, (1 << i) ); } } numElements = 1 << i; queue = (QueueObject_t *)malloc(sizeof(QueueObject_t)); items = (QueueItem_t *)malloc(numElements * sizeof(QueueItem_t)); queue->numElements = numElements; queue->numMask = numElements - 1; queue->head = 0; queue->tail = 0; for( i = 0; i < numElements; i++ ) { items[i] = NULL; } queue->itemTable = items; /* Initialize the mutex */ queue->mutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)); status = pthread_mutex_init( queue->mutex, NULL ); /* Initialize the condition variables */ queue->full = FALSE; queue->cNotFull = (pthread_cond_t *)malloc(sizeof(pthread_cond_t)); status = pthread_cond_init( queue->cNotFull, NULL ); queue->empty = TRUE; queue->cNotEmpty = (pthread_cond_t *)malloc(sizeof(pthread_cond_t)); status = pthread_cond_init( queue->cNotEmpty, NULL ); if( !QueueList ) { QueueList = LinkedListCreate(); if( !QueueList ) { LogPrintNoArg( LOG_CRIT, "Couldn't create the list of queues!" ); exit(1); } } /* Allows us to flush all queues at shutdown */ LinkedListAdd( QueueList, (LinkedListItem_t *)queue, UNLOCKED, AT_TAIL ); return( queue ); }
LinkedList_t *pluginFindPlugins( char *prefix, char *extension ) { LinkedList_t *list; PluginItem_t *item; struct dirent **namelist; int n; int i; int len; PluginSpec_t *spec; char *name; list = LinkedListCreate(); LinkedListLock( list ); ProtectedDataLock( extBlock ); if( extBlock->data ) { spec = (PluginSpec_t *)extBlock->data; if( spec->prefix ) { free( spec->prefix ); } if( spec->extension ) { free( spec->extension ); } free( extBlock->data ); } spec = (PluginSpec_t *)malloc(sizeof(PluginSpec_t)); memset( spec, 0, sizeof(PluginSpec_t) ); extBlock->data = (void *)spec; if( prefix ) { spec->prefix = strdup( prefix ); spec->prefLen = strlen( prefix ); } spec->extension = strdup( extension ); spec->extLen = strlen( extension ); n = scandir( PLUGIN_PATH, &namelist, filterFile, alphasort ); for( i = 0; i < n; i++ ) { item = (PluginItem_t *)malloc(sizeof(PluginItem_t)); name = namelist[i]->d_name; len = strlen(name); item->plugin = strndup( &name[spec->prefLen], len - spec->prefLen - spec->extLen ); item->script = strdup( name ); LinkedListAdd( list, (LinkedListItem_t*)item, LOCKED, AT_TAIL ); free( namelist[i] ); } ProtectedDataUnlock( extBlock ); if( n >= 0 ) { free( namelist ); } LinkedListUnlock( list ); return( list ); }