示例#1
0
void chain_save_pc( MYSQL_RES *res, QueryItem_t *item )
{
    int                 count;
    MYSQL_BIND         *data;
    MYSQL_BIND          temp[1];
    ProtectedData_t    *protect;
    int                *id;
    
    data = item->queryData;
    if( !res || !(count = mysql_num_rows(res)) ) {
        count = 0;
    }

    protect = (ProtectedData_t *)data[3].buffer;
    id  = (int *)protect->data;
    *id = *(int *)data[0].buffer;

    /* swap argument order */
    memcpy(  temp,     &data[0], sizeof(MYSQL_BIND) );
    memmove( &data[0], &data[1], sizeof(MYSQL_BIND) * 2 );
    memcpy(  &data[2], temp,     sizeof(MYSQL_BIND) );
    
    if( count ) {
        /* update */
        ProtectedDataUnlock( protect );
        LogPrint(LOG_DEBUG, "Updating id %d", *id);
        db_queue_query( 11, QueryTable, data, 3, NULL, NULL, NULL );
    } else {
        /* insert */
        *id = 0;
        LogPrintNoArg(LOG_DEBUG, "Inserting");
        db_queue_query( 12, QueryTable, data, 2, result_insert_id, protect, 
                        NULL );
    }
}
示例#2
0
void chain_save_account( MYSQL_RES *res, QueryItem_t *item )
{
    int                 count;
    MYSQL_BIND         *data;
    MYSQL_BIND          temp[1];
    ProtectedData_t    *protect;
    int                *id;
    
    data = item->queryData;
    if( !res || !(count = mysql_num_rows(res)) ) {
        count = 0;
    }

    protect = (ProtectedData_t *)data[6].buffer;
    id  = (int *)protect->data;
    *id = *(int *)data[0].buffer;

    /* swap argument order */
    memcpy(  temp,     &data[0], sizeof(MYSQL_BIND) );
    memmove( &data[0], &data[1], sizeof(MYSQL_BIND) * 5 );
    memcpy(  &data[5], temp,     sizeof(MYSQL_BIND) );
    
    if( count ) {
        /* update */
        ProtectedDataUnlock( protect );
        db_queue_query( 6, QueryTable, data, 6, NULL, NULL, NULL );
    } else {
        /* insert */
        db_queue_query( 7, QueryTable, data, 5, result_insert_id, protect,
                        NULL );
    }
}
示例#3
0
void result_insert_id( MYSQL_RES *res, MYSQL_BIND *input, void *arg,
                       long insertid )
{
    ProtectedData_t    *protect;
    int                *id;

    if( !arg ) {
        return;
    }

    protect = (ProtectedData_t *)arg;
    id = (int *)protect->data;
    *id = insertid;
    LogPrint(LOG_CRIT, "New ID: %d", insertid);
    ProtectedDataUnlock( protect );
}
示例#4
0
/**
 * @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 );
        }
    }
示例#5
0
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 );
}