TConn

struct _TConn {
    struct _TConn * nextOutstandingP;
        /* Link to the next connection in the list of outstanding
           connections
        */
    TServer * server;
    uint32_t buffersize;
        /* Index into the connection buffer (buffer[],below) where
           the next byte read on the connection will go.
        */
    uint32_t bufferpos;
        /* Index into the connection buffer (buffer[],below) where
           the next byte to be delivered to the user is.
        */
    uint32_t inbytes,outbytes;  
    TChannel * channelP;
    void * channelInfoP;
        /* Information about the channel,such as who is on the other end.
           Format depends on the type of channel.  The user of the connection
           is expected to know that type,because he supplied the channel
           when he created the channel.

           NULL means no channel info is available.
        */
    bool hasOwnThread;
    TThread * threadP;
    bool finished;
        /* We have done all the processing there is to do on this
           connection,other than possibly notifying someone that we're
           done.  One thing this signifies is that any thread or process
           that the connection spawned is dead or will be dead soon,so
           one could reasonably wait for it to be dead,e.g. with
           pthread_join().  Note that one can scan a bunch of processes
           for 'finished' status,but sometimes can't scan a bunch of
           threads for liveness.
        */
    const char * trace;
    TThreadProc * job;
    TThreadDoneFn * done;
    char buffer[BUFFER_SIZE];
};

我们可以再次看看TChannel的声明。implP是个指向无类型的指针，即可以指向任何类型。在分析socket_win.c文件时提到过它将指向socketWin结构体变量。设计成无类型指针的目的是为了让库的核心处理框架代码可以在多个操作系统平台下都可以运作良好。vtbl保存了几个静态函数指针，包括接收数据和发送数据等。也就是说，TChannel保存的都是与特定操作系统平台相关的信息：特定操作系统平台下socket的实现函数，以及特定操作系统平台下socket及其相关对象（例如windows事件句柄）的信息。

struct _TChannel {
    uint                signature;
        /* With both background and foreground use of sockets,and
           background being both fork and pthread,it is very easy to
           screw up socket lifetime and try to destroy twice.  We use
           this signature to help catch such bugs.
        */
    void *              implP;
    struct TChannelVtbl vtbl;
};

struct abyss_win_chaninfo {
    size_t peerAddrLen;
    struct sockaddr peerAddr;
};

TChannel和abyss_win_chaninfo两个结构体属于客户端连接这一概念中较低层的数据，但又由于它们与特定操作系统平台相关，因此abyss库将它们单独封装成一类结构体。其他更抽象一点、与操作系统不太相关的信息，例如接收、发送缓冲区等，与TChannel结构体作为同一级别的信息组合成TConn结构体。在研究thread_windows.c文件时，也指出与线程相关的代码也是与平台特定相关的，因此也将其封装成了一个结构体TThread，针对不同平台都有各自平台下的TThread实现。

ConnCreate

void
ConnCreate(TConn **            const connectionPP,TServer *           const serverP,TChannel *          const channelP,void *              const channelInfoP,TThreadProc *       const job,TThreadDoneFn *     const done,enum abyss_foreback const foregroundBackground,bool                const useSigchld,const char **       const errorP) {
/*----------------------------------------------------------------------------
   Create an HTTP connection.

   A connection carries one or more HTTP transactions (request/response).

   *channelP transports the requests and responses.

   The connection handles those HTTP requests.

   The connection handles the requests primarily by running the
   function 'job' once.  Some connections can do that autonomously,as
   soon as the connection is created.  Others don't until Caller
   subsequently calls ConnProcess.  Some connections complete the
   processing before ConnProcess return,while others may run the
   connection asynchronously to the creator,in the background,via a
   TThread thread.  'foregroundBackground' determines which.

   'job' calls methods of the connection to get requests and send
   responses.

   Some time after the HTTP transactions are all done,'done' gets
   called in some context.

   'channelInfoP' == NULL means no channel info supplied.
-----------------------------------------------------------------------------*/
    TConn * connectionP;

    MALLOCVAR(connectionP);

    if (connectionP == NULL)
        xmlrpc_asprintf(errorP,"Unable to allocate memory for a connection "
                        "descriptor.");
    else {
        connectionP->server       = serverP;
        connectionP->channelP     = channelP;
        connectionP->channelInfoP = channelInfoP;
        connectionP->buffer[0]    = '';
        connectionP->buffersize   = 0;
        connectionP->bufferpos    = 0;
        connectionP->finished     = FALSE;
        connectionP->job          = job;
        connectionP->done         = done;
        connectionP->inbytes      = 0;
        connectionP->outbytes     = 0;
        connectionP->trace        = getenv("ABYSS_TRACE_CONN");

        makeThread(connectionP,foregroundBackground,useSigchld,errorP);
    }
    *connectionPP = connectionP;
}

ConnCreate函数的作用是创建TConn变量，并初始化各项属性，最后再创建一个与此相对应的线程。

ConnProcess

bool
ConnProcess(TConn * const connectionP) {
/*----------------------------------------------------------------------------
   Drive the main processing of a connection -- run the connection's
   "job" function,which should read HTTP requests from the connection
   and send HTTP responses.

   If we succeed,we guarantee the connection's "done" function will get
   called some time after all processing is complete.  It might be before
   we return or some time after.  If we fail,we guarantee the "done"
   function will not be called.
-----------------------------------------------------------------------------*/
    bool retval;

    if (connectionP->hasOwnThread) {
        /* There's a background thread to handle this connection.  Set
           it running.
        */
        retval = ThreadRun(connectionP->threadP);
    } else {
        /* No background thread.  We just handle it here while Caller waits. */
        (connectionP->job)(connectionP);
        connDone(connectionP);
        retval = TRUE;
    }
    return retval;
}

bool
ThreadRun(TThread * const threadP) {
    return (ResumeThread(threadP->handle) != 0xFFFFFFFF);
}

ConnProcess函数的作用是启动在ConnCreate函数内创建的线程。

客户端连接线程主函数

ConnCreate函数会接收server.c文件内的serverFunc函数作为每个客户端连接的线程主函数。其实对操作系统来说，这还不是那个主函数。真正的主函数是thread_windows.c文件内的threadRun函数。因为调用beginthreadex函数传入的就是这个函数。

        threadP->handle = (HANDLE)_beginthreadex(NULL,THREAD_STACK_SIZE,threadRun,threadP,CREATE_SUSPENDED,&z);

static uint32_t WINAPI
threadRun(void * const arg) {

    struct abyss_thread * const threadP = arg;

    threadP->func(threadP->userHandle);

    threadP->threadDone(threadP->userHandle);

    return 0;
}

static void
connJob(void * const userHandle) {
/*----------------------------------------------------------------------------
   This is the root function for a thread that processes a connection
   (performs HTTP transactions).
-----------------------------------------------------------------------------*/
    TConn * const connectionP = userHandle;

    (connectionP->job)(connectionP);

    connectionP->finished = TRUE;
        /* Note that if we are running in a forked process,setting
           connectionP->finished has no effect,because it's just our own
           copy of *connectionP.  In this case,Parent must update his own
           copy based on a SIGCHLD signal that the OS will generate right
           after we exit.
        */

    //ThreadExit(0);
}

static void
connDone(TConn * const connectionP) {

    /* In the forked case,this is designed to run in the parent
       process after the child has terminated.
    */
    connectionP->finished = TRUE;

    if (connectionP->done)
        connectionP->done(connectionP);
}



static TThreadDoneFn threadDone;

static void
threadDone(void * const userHandle) {

    TConn * const connectionP = userHandle;
    
    connDone(connectionP);
}

ConnRead

bool
ConnRead(TConn *  const connectionP,uint32_t const timeout) {
/*----------------------------------------------------------------------------
   Read some stuff on connection *connectionP from the channel.

   Don't wait more than 'timeout' seconds for data to arrive.  Fail if
   nothing arrives within that time.

   'timeout' must be before the end of time.
-----------------------------------------------------------------------------*/
    time_t const deadline = time(NULL) + timeout;

    bool cantGetData;
    bool gotData;

    cantGetData = FALSE;
    gotData = FALSE;
    
    while (!gotData && !cantGetData) {
        int const timeLeft = (int)(deadline - time(NULL));

        if (timeLeft <= 0)
            cantGetData = TRUE;
        else {
            bool const waitForRead  = TRUE;
            bool const waitForWrite = FALSE;
            
            bool readyForRead;
            bool failed;
            
            ChannelWait(connectionP->channelP,waitForRead,waitForWrite,timeLeft * 1000,&readyForRead,NULL,&failed);
            
            if (failed)
                cantGetData = TRUE;
            else {
                uint32_t bytesRead;
                bool readFailed;

                ChannelRead(connectionP->channelP,connectionP->buffer + connectionP->buffersize,bufferSpace(connectionP) - 1,&bytesRead,&readFailed);

                if (readFailed)
                    cantGetData = TRUE;
                else {
                    if (bytesRead > 0) {
                        traceChannelRead(connectionP,bytesRead);
                        connectionP->inbytes += bytesRead;
                        connectionP->buffersize += bytesRead;
                        connectionP->buffer[connectionP->buffersize] = '';
                        gotData = TRUE;
                    } else
                        /* Other end has disconnected */
                        cantGetData = TRUE;
                }
            }
        }
    }
    if (gotData)
        return TRUE;
    else
        return FALSE;
}

void
ChannelWait(TChannel * const channelP,bool       const waitForRead,bool       const waitForWrite,uint32_t   const timems,bool *     const readyToReadP,bool *     const readyToWriteP,bool *     const failedP) {

    if (ChannelTraceIsActive) {
        if (waitForRead)
            fprintf(stderr,"Waiting %u milliseconds for data from "
                    "channel %pn",timems,channelP);
        if (waitForWrite)
            fprintf(stderr,"Waiting %u milliseconds for channel %p "
                    "to be writablen",channelP);
    }
    (*channelP->vtbl.wait)(channelP,readyToReadP,readyToWriteP,failedP);
}

ConnReadInit

void
ConnReadInit(TConn * const connectionP) {

    if (connectionP->buffersize > connectionP->bufferpos) {
        connectionP->buffersize -= connectionP->bufferpos;
        memmove(connectionP->buffer,connectionP->buffer + connectionP->bufferpos,connectionP->buffersize);
        connectionP->bufferpos = 0;
    } else
        connectionP->buffersize = connectionP->bufferpos = 0;

    connectionP->buffer[connectionP->buffersize] = '';

    connectionP->inbytes = connectionP->outbytes = 0;
}

ConnReadInit函数在每次执行完processDataFromClient函数后执行。processDataFromClient函数功能正如其函数名称所表明的那样：处理客户端发来的数据。ConnReadInit函数可以理解成为下次读操作做些初始化工作。connectionP->bufferpos可以解释为上次处理数据完毕后，还未处理数据的起始地址。

if (connectionP->buffersize > connectionP->bufferpos) {

ConnWrite

bool
ConnWrite(TConn *      const connectionP,const void * const buffer,uint32_t     const size) {

    bool failed;

    ChannelWrite(connectionP->channelP,buffer,size,&failed);

    traceChannelWrite(connectionP,failed);

    if (!failed)
        connectionP->outbytes += size;

    return !failed;
}

ConnWriteFromFile

此文件内包含的都是与TConn结构体相关的函数。换种说法就是客户端连接相关的函数。包括连接到来时线程创建、读数据以及写数据等。

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!