text: /*
   * 读取和写入网络数据的处理方法，主要负责redis协议的解析。
   */
  
  #include "redis.h"
  #include <sys/uio.h>
  
  static void setProtocolError(redisClient *c, int pos);
  
  /* To evaluate the output buffer size of a client we need to get size of
   * allocated objects, however we can't used zmalloc_size() directly on sds
   * strings because of the trick they use to work (the header is before the
   * returned pointer), so we use this helper function. */
  size_t zmalloc_size_sds(sds s) {
      return zmalloc_size(s-sizeof(struct sdshdr));
  }
  
  void *dupClientReplyValue(void *o) {
      incrRefCount((robj*)o);
      return o;
  }
  
  int listMatchObjects(void *a, void *b) {
      return equalStringObjects(a,b);
  }
  
  /*
   * 创建新的客户端连接
   * 当有客户端请求到来时，首先调用此方法
   */
  redisClient *createClient(int fd) {
      redisClient *c = zmalloc(sizeof(redisClient));
  
      /* passing -1 as fd it is possible to create a non connected client.
       * This is useful since all the Redis commands needs to be executed
       * in the context of a client. When commands are executed in other
       * contexts (for instance a Lua script) we need a non connected client. */
      // 因为 Redis 命令总在客户端的上下文中执行，
      // 有时候为了在服务器内部执行命令，需要使用伪客户端来执行命令
      // 在 fd == -1 时，创建的客户端为伪终端
      if (fd != -1) {
          anetNonBlock(NULL,fd);
          anetTcpNoDelay(NULL,fd);
          if (aeCreateFileEvent(server.el,fd,AE_READABLE, readQueryFromClient, c) == AE_ERR)
          {
              close(fd);
              zfree(c);
              return NULL;
          }
      }
  
      // 选择数据库
      selectDb(c,0);
  
      // 文件描述符
      c->fd = fd;
      
      // 查询缓存相关的设置
      c->bufpos = 0;
      c->querybuf = sdsempty();
      c->querybuf_peak = 0;
      c->reqtype = 0;
  
      // 命令及参数
      c->argc = 0;
      c->argv = NULL;
      c->cmd = c->lastcmd = NULL;
  
  
      c->multibulklen = 0;
      c->bulklen = -1;
      c->sentlen = 0;
  
      // 状态
      c->flags = 0;
  
      // 用于 LRU 和 IDLE 计算
      c->ctime = c->lastinteraction = server.unixtime;
  
      // 身份验证
      c->authenticated = 0;
  
      // REPL 状态
      c->replstate = REDIS_REPL_NONE;
  
      // 附属监听端口
      c->slave_listening_port = 0;
  
      // 回复
      c->reply = listCreate();
      c->reply_bytes = 0;
  
      // 软缓存超限提醒
      c->obuf_soft_limit_reached_time = 0;
  
      // 回复处理函数
      listSetFreeMethod(c->reply,decrRefCount);
      listSetDupMethod(c->reply,dupClientReplyValue);
  
      // 阻塞 POP 相关
      c->bpop.keys = dictCreate(&setDictType,NULL);
      c->bpop.timeout = 0;
      c->bpop.target = NULL;
  
      //
      c->io_keys = listCreate();
  
      // 所有被监视的键
      c->watched_keys = listCreate();
      listSetFreeMethod(c->io_keys,decrRefCount);
  
      // pubsub
      c->pubsub_channels = dictCreate(&setDictType,NULL);
      c->pubsub_patterns = listCreate();
      listSetFreeMethod(c->pubsub_patterns,decrRefCount);
      listSetMatchMethod(c->pubsub_patterns,listMatchObjects);
  
      // 如果不是伪客户端，那么将客户端加入到服务器客户端列表中
      if (fd != -1) listAddNodeTail(server.clients,c);
  
      // 初始化事务状态
      initClientMultiState(c);
  
      return c;
  }
  
  /* This function is called every time we are going to transmit new data
   * to the client. The behavior is the following:
   *
   * 这个函数在每次发送新数据到客户端时调用。它的行为如下：
   *
   * If the client should receive new data (normal clients will) the function
   * returns REDIS_OK, and make sure to install the write handler in our event
   * loop so that when the socket is writable new data gets written.
   *
   * 如果客户端允许接受新数据（通常情况下都是这样），那么函数返回 REDIS_OK 。
   * 并将写处理器装入到事件处理循环中，从而在套接字可用时将新数据写入。
   *
   * If the client should not receive new data, because it is a fake client
   * or a slave, or because the setup of the write handler failed, the function
   * returns REDIS_ERR.
   *
   * 当客户端为伪客户端、附属节点，或者设置事件写处理器失败时，
   * 函数返回 REDIS_ERR 。
   *
   * Typically gets called every time a reply is built, before adding more
   * data to the clients output buffers. If the function returns REDIS_ERR no
   * data should be appended to the output buffers. 
   *
   * 这个函数通常在新回复被创建，并将新回复添加到客户端之前调用。
   * 如果函数返回 REDIS_ERR ，那么没有任何缓存会被追加到缓存。
   */
  int prepareClientToWrite(redisClient *c) {
      if (c->flags & REDIS_LUA_CLIENT) return REDIS_OK;
      if (c->fd <= 0) return REDIS_ERR; /* Fake client */
      if (c->bufpos == 0 && listLength(c->reply) == 0 &&
          (c->replstate == REDIS_REPL_NONE || c->replstate == REDIS_REPL_ONLINE) &&
          aeCreateFileEvent(server.el, c->fd, AE_WRITABLE, sendReplyToClient, c) == AE_ERR)
          return REDIS_ERR;
      return REDIS_OK;
  }
  
  /* Create a duplicate of the last object in the reply list when
   * it is not exclusively owned by the reply list. */
  robj *dupLastObjectIfNeeded(list *reply) {
      robj *new, *cur;
      listNode *ln;
      redisAssert(listLength(reply) > 0);
      ln = listLast(reply);
      cur = listNodeValue(ln);
      if (cur->refcount > 1) {
          new = dupStringObject(cur);
          decrRefCount(cur);
          listNodeValue(ln) = new;
      }
      return listNodeValue(ln);
  }
  
  /* -----------------------------------------------------------------------------
   * Low level functions to add more data to output buffers.
   * -------------------------------------------------------------------------- */
  
  /*
   * 仅当 c->reply 链表中没有节点时，
   * 将回复 s 追加到 c->buf 的后部。
   *
   * 添加成功返回 REDIS_OK ，添加失败返回 REDIS_ERR 。
   */
  int _addReplyToBuffer(redisClient *c, char *s, size_t len) {
      // 可用的缓存字节数
      size_t available = sizeof(c->buf)-c->bufpos;
  
      // 客户端将被关闭，无须回复
      if (c->flags & REDIS_CLOSE_AFTER_REPLY) return REDIS_OK;
  
      /* If there already are entries in the reply list, we cannot
       * add anything more to the static buffer. */
      // 回复列表中已节点存在，不将内容添加到缓存
      if (listLength(c->reply) > 0) return REDIS_ERR;
  
      /* Check that the buffer has enough space available for this string. */
      // 如果缓存的空间不足以保存回复，直接返回
      if (len > available) return REDIS_ERR;
  
      // 追加到缓存中
      memcpy(c->buf+c->bufpos,s,len);
      c->bufpos+=len;
  
      return REDIS_OK;
  }
  
  /*
   * 将回复对象所保存的值添加到回复列表 c->reply 末尾
   */
  void _addReplyObjectToList(redisClient *c, robj *o) {
      robj *tail;
  
      // 服务端已被关闭
      if (c->flags & REDIS_CLOSE_AFTER_REPLY) return;
  
      // 空链表
      if (listLength(c->reply) == 0) {
          // 创建新表尾
          incrRefCount(o);
          listAddNodeTail(c->reply,o);
          // 更新总字节数
          c->reply_bytes += zmalloc_size_sds(o->ptr);
  
      // 非空链表
      } else {
          // 取出原有表尾
          tail = listNodeValue(listLast(c->reply));
  
          /* Append to this object when possible. */
          // 如果最后一个节点所保存的回复，加上新回复，
          // 内容总长度小于等于 REDIS_REPLY_CHUNK_BYTES 
          // 那么将新回复追加到节点回复当中。
          if (tail->ptr != NULL &&
              sdslen(tail->ptr)+sdslen(o->ptr) <= REDIS_REPLY_CHUNK_BYTES)
          {
              c->reply_bytes -= zmalloc_size_sds(tail->ptr);
              tail = dupLastObjectIfNeeded(c->reply);
              tail->ptr = sdscatlen(tail->ptr,o->ptr,sdslen(o->ptr));
              c->reply_bytes += zmalloc_size_sds(tail->ptr);
          
          // 否则，为新回复单独创建一个节点
          } else {
              incrRefCount(o);
              listAddNodeTail(c->reply,o);
              c->reply_bytes += zmalloc_size_sds(o->ptr);
          }
      }
  
      // 如果突破了客户端的最大缓存限制，那么关闭客户端
      asyncCloseClientOnOutputBufferLimitReached(c);
  }
  
  /* This method takes responsibility over the sds. When it is no longer
   * needed it will be free'd, otherwise it ends up in a robj. */
  /*
   * 将 sds 添加到回复列表末尾
   */
  void _addReplySdsToList(redisClient *c, sds s) {
      robj *tail;
  
      if (c->flags & REDIS_CLOSE_AFTER_REPLY) {
          sdsfree(s);
          return;
      }
  
      // 添加到列表
      if (listLength(c->reply) == 0) {
          listAddNodeTail(c->reply,createObject(REDIS_STRING,s));
          c->reply_bytes += zmalloc_size_sds(s);
      } else {
          tail = listNodeValue(listLast(c->reply));
  
          /* Append to this object when possible. */
          if (tail->ptr != NULL &&
              sdslen(tail->ptr)+sdslen(s) <= REDIS_REPLY_CHUNK_BYTES)
          {
              c->reply_bytes -= zmalloc_size_sds(tail->ptr);
              tail = dupLastObjectIfNeeded(c->reply);
              tail->ptr = sdscatlen(tail->ptr,s,sdslen(s));
              c->reply_bytes += zmalloc_size_sds(tail->ptr);
              sdsfree(s);
          } else {
              listAddNodeTail(c->reply,createObject(REDIS_STRING,s));
              c->reply_bytes += zmalloc_size_sds(s);
          }
      }
  
      // 检查缓存大小限制
      asyncCloseClientOnOutputBufferLimitReached(c);
  }
  
  /*
   * 将字符串添加到列表表尾
   */
  void _addReplyStringToList(redisClient *c, char *s, size_t len) {
      robj *tail;
  
      if (c->flags & REDIS_CLOSE_AFTER_REPLY) return;
  
      // 添加到列表
      if (listLength(c->reply) == 0) {
          robj *o = createStringObject(s,len);
  
          listAddNodeTail(c->reply,o);
          c->reply_bytes += zmalloc_size_sds(o->ptr);
      } else {
          tail = listNodeValue(listLast(c->reply));
  
          /* Append to this object when possible. */
          if (tail->ptr != NULL &&
              sdslen(tail->ptr)+len <= REDIS_REPLY_CHUNK_BYTES)
          {
              c->reply_bytes -= zmalloc_size_sds(tail->ptr);
              tail = dupLastObjectIfNeeded(c->reply);
              tail->ptr = sdscatlen(tail->ptr,s,len);
              c->reply_bytes += zmalloc_size_sds(tail->ptr);
          } else {
              robj *o = createStringObject(s,len);
  
              listAddNodeTail(c->reply,o);
              c->reply_bytes += zmalloc_size_sds(o->ptr);
          }
      }
  
      // 检查缓存大小限制
      asyncCloseClientOnOutputBufferLimitReached(c);
  }
  
  /* -----------------------------------------------------------------------------
   * Higher level functions to queue data on the client output buffer.
   * The following functions are the ones that commands implementations will call.
   * -------------------------------------------------------------------------- */
  
  /*
   * 将对象 obj 的内容添加到客户端回复
   *
   * 被其他回复函数所调用
   */
  void addReply(redisClient *c, robj *obj) {
      // 伪客户端，附属节点或创建写事件处理器失败
      if (prepareClientToWrite(c) != REDIS_OK) return;
  
      /* This is an important place where we can avoid copy-on-write
       * when there is a saving child running, avoiding touching the
       * refcount field of the object if it's not needed.
       *
       * If the encoding is RAW and there is room in the static buffer
       * we'll be able to send the object to the client without
       * messing with its page. */
      if (obj->encoding == REDIS_ENCODING_RAW) {
          // 如果 c->reply 链表中没有节点，并且缓存空间足够，
          // 那么将内容追加到 c->buf 的后部
          if (_addReplyToBuffer(c,obj->ptr,sdslen(obj->ptr)) != REDIS_OK)
              // 否则，将内容添加到 c->reply 链表
              _addReplyObjectToList(c,obj);
      } else if (obj->encoding == REDIS_ENCODING_INT) {
          /* Optimization: if there is room in the static buffer for 32 bytes
           * (more than the max chars a 64 bit integer can take as string) we
           * avoid decoding the object and go for the lower level approach. */
          // 如果回复列表未使用，并且缓冲区有足够空间
          // 那么将字符串形式的 32 位整数添加到缓冲区的末尾
          if (listLength(c->reply) == 0 && (sizeof(c->buf) - c->bufpos) >= 32) {
              char buf[32];
              int len;
  
              len = ll2string(buf,sizeof(buf),(long)obj->ptr);
              if (_addReplyToBuffer(c,buf,len) == REDIS_OK)
                  return;
              /* else... continue with the normal code path, but should never
               * happen actually since we verified there is room. */
          }
  
          // 超过 32 位的整数需要解码之后才能添加到回复
          obj = getDecodedObject(obj);
          if (_addReplyToBuffer(c,obj->ptr,sdslen(obj->ptr)) != REDIS_OK)
              _addReplyObjectToList(c,obj);
          decrRefCount(obj);
  
      } else {
          redisPanic("Wrong obj->encoding in addReply()");
      }
  }
  
  /*
   * 添加 sds 回复
   *
   * 格式：
   *
   *  content\r\n
   */
  void addReplySds(redisClient *c, sds s) {
      if (prepareClientToWrite(c) != REDIS_OK) {
          /* The caller expects the sds to be free'd. */
          sdsfree(s);
          return;
      }
      if (_addReplyToBuffer(c,s,sdslen(s)) == REDIS_OK) {
          sdsfree(s);
      } else {
          /* This method free's the sds when it is no longer needed. */
          _addReplySdsToList(c,s);
      }
  }
  
  /*
   * 添加字符串回复
   *
   * 格式：
   *
   *  content\r\n
   */
  void addReplyString(redisClient *c, char *s, size_t len) {
      if (prepareClientToWrite(c) != REDIS_OK) return;
      if (_addReplyToBuffer(c,s,len) != REDIS_OK)
          _addReplyStringToList(c,s,len);
  }
  
  void addReplyErrorLength(redisClient *c, char *s, size_t len) {
      addReplyString(c,"-ERR ",5);
      addReplyString(c,s,len);
      addReplyString(c,"\r\n",2);
  }
  
  /*
   * 添加出错信息到回复
   *
   * 格式：
   *
   *  -ERR content\r\n
   */
  void addReplyError(redisClient *c, char *err) {
      addReplyErrorLength(c,err,strlen(err));
  }
  
  /*
   * 添加多个出错信息到回复
   *
   * 格式：
   *
   *  -Err err_1_content err_2_content ... err_n_content \r\n
   *
   *  错误内容中不包含 \r 或 \n
   */
  void addReplyErrorFormat(redisClient *c, const char *fmt, ...) {
      size_t l, j;
      va_list ap;
      va_start(ap,fmt);
      sds s = sdscatvprintf(sdsempty(),fmt,ap);
      va_end(ap);
      /* Make sure there are no newlines in the string, otherwise invalid protocol
       * is emitted. */
      l = sdslen(s);
      for (j = 0; j < l; j++) {
          if (s[j] == '\r' || s[j] == '\n') s[j] = ' ';
      }
      addReplyErrorLength(c,s,sdslen(s));
      sdsfree(s);
  }
  
  void addReplyStatusLength(redisClient *c, char *s, size_t len) {
      addReplyString(c,"+",1);
      addReplyString(c,s,len);
      addReplyString(c,"\r\n",2);
  }
  
  /*
   * 添加状态信息到回复
   *
   * 格式：
   *
   *  +content\r\n
   */
  void addReplyStatus(redisClient *c, char *status) {
      addReplyStatusLength(c,status,strlen(status));
  }
  
  /*
   * 添加多个状态信息到回复
   */
  void addReplyStatusFormat(redisClient *c, const char *fmt, ...) {
      va_list ap;
      va_start(ap,fmt);
      sds s = sdscatvprintf(sdsempty(),fmt,ap);
      va_end(ap);
      addReplyStatusLength(c,s,sdslen(s));
      sdsfree(s);
  }
  
  /* Adds an empty object to the reply list that will contain the multi bulk
   * length, which is not known when this function is called. */
  // 将一个空字符串添加到回复中，当作多条信息的占位符
  void *addDeferredMultiBulkLength(redisClient *c) {
      /* Note that we install the write event here even if the object is not
       * ready to be sent, since we are sure that before returning to the
       * event loop setDeferredMultiBulkLength() will be called. */
      if (prepareClientToWrite(c) != REDIS_OK) return NULL;
      listAddNodeTail(c->reply,createObject(REDIS_STRING,NULL));
      return listLast(c->reply);
  }
  
  /* Populate the length object and try glueing it to the next chunk. */
  // 设置多条回复的长度到回复
  void setDeferredMultiBulkLength(redisClient *c, void *node, long length) {
      listNode *ln = (listNode*)node;
      robj *len, *next;
  
      /* Abort when *node is NULL (see addDeferredMultiBulkLength). */
      if (node == NULL) return;
  
      len = listNodeValue(ln);
      len->ptr = sdscatprintf(sdsempty(),"*%ld\r\n",length);
      c->reply_bytes += zmalloc_size_sds(len->ptr);
      if (ln->next != NULL) {
          next = listNodeValue(ln->next);
  
          /* Only glue when the next node is non-NULL (an sds in this case) */
          if (next->ptr != NULL) {
              c->reply_bytes -= zmalloc_size_sds(len->ptr);
              c->reply_bytes -= zmalloc_size_sds(next->ptr);
              len->ptr = sdscatlen(len->ptr,next->ptr,sdslen(next->ptr));
              c->reply_bytes += zmalloc_size_sds(len->ptr);
              listDelNode(c->reply,ln->next);
          }
      }
      asyncCloseClientOnOutputBufferLimitReached(c);
  }
  
  /* Add a duble as a bulk reply */
  // 添加一条浮点数信息到多条回复
  void addReplyDouble(redisClient *c, double d) {
      char dbuf[128], sbuf[128];
      int dlen, slen;
      dlen = snprintf(dbuf,sizeof(dbuf),"%.17g",d);
      slen = snprintf(sbuf,sizeof(sbuf),"$%d\r\n%s\r\n",dlen,dbuf);
      addReplyString(c,sbuf,slen);
  }
  
  /* Add a long long as integer reply or bulk len / multi bulk count.
   * Basically this is used to output <prefix><long long><crlf>. */
  // 添加一个带前缀为整数长度的整数信息到多条回复
  void addReplyLongLongWithPrefix(redisClient *c, long long ll, char prefix) {
      char buf[128];
      int len;
  
      /* Things like $3\r\n or *2\r\n are emitted very often by the protocol
       * so we have a few shared objects to use if the integer is small
       * like it is most of the times. */
      // 添加前缀
      if (prefix == '*' && ll < REDIS_SHARED_BULKHDR_LEN) {
          addReply(c,shared.mbulkhdr[ll]);
          return;
      } else if (prefix == '$' && ll < REDIS_SHARED_BULKHDR_LEN) {
          addReply(c,shared.bulkhdr[ll]);
          return;
      }
  
      // 添加正文
      buf[0] = prefix;
      len = ll2string(buf+1,sizeof(buf)-1,ll);
      buf[len+1] = '\r';
      buf[len+2] = '\n';
      addReplyString(c,buf,len+3);
  }
  
  /*
   * 添加整数回复
   */
  void addReplyLongLong(redisClient *c, long long ll) {
      if (ll == 0)
          addReply(c,shared.czero);
      else if (ll == 1)
          addReply(c,shared.cone);
      else
          addReplyLongLongWithPrefix(c,ll,':');
  }
  
  /*
   *  将多条回复的长度添加到回复中
   */
  void addReplyMultiBulkLen(redisClient *c, long length) {
      addReplyLongLongWithPrefix(c,length,'*');
  }
  
  /* Create the length prefix of a bulk reply, example: $2234 */
  // 为多条回复添加长度前缀
  void addReplyBulkLen(redisClient *c, robj *obj) {
      size_t len;
  
      if (obj->encoding == REDIS_ENCODING_RAW) {
          len = sdslen(obj->ptr);
      } else {
          long n = (long)obj->ptr;
  
          /* Compute how many bytes will take this integer as a radix 10 string */
          len = 1;
          if (n < 0) {
              len++;
              n = -n;
          }
          while((n = n/10) != 0) {
              len++;
          }
      }
      addReplyLongLongWithPrefix(c,len,'$');
  }
  
  /* Add a Redis Object as a bulk reply */
  void addReplyBulk(redisClient *c, robj *obj) {
      addReplyBulkLen(c,obj);
      addReply(c,obj);
      addReply(c,shared.crlf);
  }
  
  /* Add a C buffer as bulk reply */
  void addReplyBulkCBuffer(redisClient *c, void *p, size_t len) {
      addReplyLongLongWithPrefix(c,len,'$');
      addReplyString(c,p,len);
      addReply(c,shared.crlf);
  }
  
  /* Add a C nul term string as bulk reply */
  void addReplyBulkCString(redisClient *c, char *s) {
      if (s == NULL) {
          addReply(c,shared.nullbulk);
      } else {
          addReplyBulkCBuffer(c,s,strlen(s));
      }
  }
  
  /* Add a long long as a bulk reply */
  void addReplyBulkLongLong(redisClient *c, long long ll) {
      char buf[64];
      int len;
  
      len = ll2string(buf,64,ll);
      addReplyBulkCBuffer(c,buf,len);
  }
  
  /* Copy 'src' client output buffers into 'dst' client output buffers.
   *
   * 将 src 客户端的输出缓存复制到 dst 客户端的输出缓存中。
   *
   * The function takes care of freeing the old output buffers of the
   * destination client. 
   *
   * 对原有缓存的释放工作由这个函数负责。
   *
   */
  void copyClientOutputBuffer(redisClient *dst, redisClient *src) {
      // 清空目标客户端原有回复列表
      listRelease(dst->reply);
  
      // 复制源列表到目标列表
      dst->reply = listDup(src->reply);
      // 设置列表大小
      dst->reply_bytes = src->reply_bytes;
  
      // 同步源缓存内容到目标缓存
      memcpy(dst->buf,src->buf,src->bufpos);
      // 同步偏移量
      dst->bufpos = src->bufpos;
  }
  
  static void acceptCommonHandler(int fd, int flags) {
      redisClient *c;
  
      // 创建新客户端
      if ((c = createClient(fd)) == NULL) {
          redisLog(REDIS_WARNING,"Error allocating resources for the client");
          close(fd); /* May be already closed, just ignore errors */
          return;
      }
  
      /* If maxclient directive is set and this is one client more... close the
       * connection. Note that we create the client instead to check before
       * for this condition, since now the socket is already set in nonblocking
       * mode and we can send an error for free using the Kernel I/O */
      // 如果超过最大打开客户端数量，那么关闭这个客户端
      // 先打开再检查是为了方便发送错误
      if (listLength(server.clients) > server.maxclients) {
          char *err = "-ERR max number of clients reached\r\n";
  
          /* That's a best effort error message, don't check write errors */
          // 发送错误信息到客户端
          if (write(c->fd,err,strlen(err)) == -1) {
              /* Nothing to do, Just to avoid the warning... */
          }
          server.stat_rejected_conn++;
          // 释放客户端
          freeClient(c);
          return;
      }
      server.stat_numconnections++;
      c->flags |= flags;
  }
  
  void acceptTcpHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
      int cport, cfd;
      char cip[128];
      REDIS_NOTUSED(el);
      REDIS_NOTUSED(mask);
      REDIS_NOTUSED(privdata);
  
      // 连接
      cfd = anetTcpAccept(server.neterr, fd, cip, &cport);
      if (cfd == AE_ERR) {
          redisLog(REDIS_WARNING,"Accepting client connection: %s", server.neterr);
          return;
      }
      redisLog(REDIS_VERBOSE,"Accepted %s:%d", cip, cport);
  
      // 创建客户端
      acceptCommonHandler(cfd,0);
  }
  
  void acceptUnixHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
      int cfd;
      REDIS_NOTUSED(el);
      REDIS_NOTUSED(mask);
      REDIS_NOTUSED(privdata);
  
      cfd = anetUnixAccept(server.neterr, fd);
      if (cfd == AE_ERR) {
          redisLog(REDIS_WARNING,"Accepting client connection: %s", server.neterr);
          return;
      }
      redisLog(REDIS_VERBOSE,"Accepted connection to %s", server.unixsocket);
      acceptCommonHandler(cfd,REDIS_UNIX_SOCKET);
  }
  
  
  /*
   * 释放客户端参数
   */
  static void freeClientArgv(redisClient *c) {
      int j;
  
      for (j = 0; j < c->argc; j++)
          decrRefCount(c->argv[j]);
  
      c->argc = 0;
      c->cmd = NULL;
  }
  
  /* Close all the slaves connections. This is useful in chained replication
   * when we resync with our own master and want to force all our slaves to
   * resync with us as well. */
  void disconnectSlaves(void) {
      while (listLength(server.slaves)) {
          listNode *ln = listFirst(server.slaves);
          freeClient((redisClient*)ln->value);
      }
  }
  
  /*
   * 释放客户端
   */
  void freeClient(redisClient *c) {
      listNode *ln;
  
      /* If this is marked as current client unset it */
      if (server.current_client == c) server.current_client = NULL;
  
      /* Note that if the client we are freeing is blocked into a blocking
       * call, we have to set querybuf to NULL *before* to call
       * unblockClientWaitingData() to avoid processInputBuffer() will get
       * called. Also it is important to remove the file events after
       * this, because this call adds the READABLE event. */
      sdsfree(c->querybuf);
      c->querybuf = NULL;
      if (c->flags & REDIS_BLOCKED)
          unblockClientWaitingData(c);
      dictRelease(c->bpop.keys);
  
      /* UNWATCH all the keys */
      unwatchAllKeys(c);
      listRelease(c->watched_keys);
      /* Unsubscribe from all the pubsub channels */
      pubsubUnsubscribeAllChannels(c,0);
      pubsubUnsubscribeAllPatterns(c,0);
      dictRelease(c->pubsub_channels);
      listRelease(c->pubsub_patterns);
      /* Obvious cleanup */
      aeDeleteFileEvent(server.el,c->fd,AE_READABLE);
      aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
      listRelease(c->reply);
      freeClientArgv(c);
      close(c->fd);
      /* Remove from the list of clients */
      ln = listSearchKey(server.clients,c);
      redisAssert(ln != NULL);
      listDelNode(server.clients,ln);
      /* When client was just unblocked because of a blocking operation,
       * remove it from the list with unblocked clients. */
      if (c->flags & REDIS_UNBLOCKED) {
          ln = listSearchKey(server.unblocked_clients,c);
          redisAssert(ln != NULL);
          listDelNode(server.unblocked_clients,ln);
      }
      listRelease(c->io_keys);
      /* Master/slave cleanup.
       * Case 1: we lost the connection with a slave. */
      if (c->flags & REDIS_SLAVE) {
          if (c->replstate == REDIS_REPL_SEND_BULK && c->repldbfd != -1)
              close(c->repldbfd);
          list *l = (c->flags & REDIS_MONITOR) ? server.monitors : server.slaves;
          ln = listSearchKey(l,c);
          redisAssert(ln != NULL);
          listDelNode(l,ln);
      }
  
      /* Case 2: we lost the connection with the master. */
      if (c->flags & REDIS_MASTER) {
          server.master = NULL;
          server.repl_state = REDIS_REPL_CONNECT;
          server.repl_down_since = server.unixtime;
          /* We lost connection with our master, force our slaves to resync
           * with us as well to load the new data set.
           *
           * If server.masterhost is NULL the user called SLAVEOF NO ONE so
           * slave resync is not needed. */
          if (server.masterhost != NULL) disconnectSlaves();
      }
  
      /* If this client was scheduled for async freeing we need to remove it
       * from the queue. */
      if (c->flags & REDIS_CLOSE_ASAP) {
          ln = listSearchKey(server.clients_to_close,c);
          redisAssert(ln != NULL);
          listDelNode(server.clients_to_close,ln);
      }
  
      /* Release memory */
      zfree(c->argv);
      freeClientMultiState(c);
      zfree(c);
  }
  
  /* Schedule a client to free it at a safe time in the serverCron() function.
   * This function is useful when we need to terminate a client but we are in
   * a context where calling freeClient() is not possible, because the client
   * should be valid for the continuation of the flow of the program. */
  void freeClientAsync(redisClient *c) {
      if (c->flags & REDIS_CLOSE_ASAP) return;
      c->flags |= REDIS_CLOSE_ASAP;
      listAddNodeTail(server.clients_to_close,c);
  }
  
  void freeClientsInAsyncFreeQueue(void) {
      while (listLength(server.clients_to_close)) {
          listNode *ln = listFirst(server.clients_to_close);
          redisClient *c = listNodeValue(ln);
  
          c->flags &= ~REDIS_CLOSE_ASAP;
          freeClient(c);
          listDelNode(server.clients_to_close,ln);
      }
  }
  
  /*
   * 将所有回复发送到客户端
   */
  void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) {
      redisClient *c = privdata;
      int nwritten = 0, totwritten = 0, objlen;
      size_t objmem;
      robj *o;
      REDIS_NOTUSED(el);
      REDIS_NOTUSED(mask);
  
      while(c->bufpos > 0 || listLength(c->reply)) {
          if (c->bufpos > 0) {
              if (c->flags & REDIS_MASTER) {
                  /* Don't reply to a master */
                  nwritten = c->bufpos - c->sentlen;
              } else {
                  nwritten = write(fd,c->buf+c->sentlen,c->bufpos-c->sentlen);
                  if (nwritten <= 0) break;
              }
              c->sentlen += nwritten;
              totwritten += nwritten;
  
              /* If the buffer was sent, set bufpos to zero to continue with
               * the remainder of the reply. */
              if (c->sentlen == c->bufpos) {
                  c->bufpos = 0;
                  c->sentlen = 0;
              }
          } else {
              o = listNodeValue(listFirst(c->reply));
              objlen = sdslen(o->ptr);
              objmem = zmalloc_size_sds(o->ptr);
  
              if (objlen == 0) {
                  listDelNode(c->reply,listFirst(c->reply));
                  continue;
              }
  
              if (c->flags & REDIS_MASTER) {
                  /* Don't reply to a master */
                  nwritten = objlen - c->sentlen;
              } else {
                  nwritten = write(fd, ((char*)o->ptr)+c->sentlen,objlen-c->sentlen);
                  if (nwritten <= 0) break;
              }
              c->sentlen += nwritten;
              totwritten += nwritten;
  
              /* If we fully sent the object on head go to the next one */
              if (c->sentlen == objlen) {
                  listDelNode(c->reply,listFirst(c->reply));
                  c->sentlen = 0;
                  c->reply_bytes -= objmem;
              }
          }
          /* Note that we avoid to send more than REDIS_MAX_WRITE_PER_EVENT
           * bytes, in a single threaded server it's a good idea to serve
           * other clients as well, even if a very large request comes from
           * super fast link that is always able to accept data (in real world
           * scenario think about 'KEYS *' against the loopback interface).
           *
           * However if we are over the maxmemory limit we ignore that and
           * just deliver as much data as it is possible to deliver. */
          // 为了避免一个巨大的回复独占服务器
          // 如果写入字节数已经超过事件设定的最大每次可写字节数
          // 那么中断回复的发送
          if (totwritten > REDIS_MAX_WRITE_PER_EVENT &&
              (server.maxmemory == 0 ||
               zmalloc_used_memory() < server.maxmemory)) break;
      }
  
      // 写入出错
      if (nwritten == -1) {
          // 被中断
          if (errno == EAGAIN) {
              nwritten = 0;
          // 处理出错
          } else {
              redisLog(REDIS_VERBOSE,
                  "Error writing to client: %s", strerror(errno));
              freeClient(c);
              return;
          }
      }
  
      // 更新服务器的最后动作时间
      if (totwritten > 0) c->lastinteraction = server.unixtime;
  
      // 回复全部发送完毕，删除事件处理器
      if (c->bufpos == 0 && listLength(c->reply) == 0) {
          c->sentlen = 0;
          aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
  
          /* Close connection after entire reply has been sent. */
          // 如果状态为“回复完毕之后关闭”，那么关闭客户端
          if (c->flags & REDIS_CLOSE_AFTER_REPLY) freeClient(c);
      }
  }
  
  /* resetClient prepare the client to process the next command */
  /*
   * 重置客户端的参数信息，等待下次命令
   */
  void resetClient(redisClient *c) {
      // 清空上一次执行的命令
      freeClientArgv(c);
  
      c->reqtype = 0;
      c->multibulklen = 0;
      c->bulklen = -1;
  
      /* We clear the ASKING flag as well if we are not inside a MULTI. */
      if (!(c->flags & REDIS_MULTI)) c->flags &= (~REDIS_ASKING);
  }
  /**
   * 处理非*开头的请求
   *
   */
  int processInlineBuffer(redisClient *c) {
      char *newline = strstr(c->querybuf,"\r\n");
      int argc, j;
      sds *argv;
      size_t querylen;
  
      /* Nothing to do without a \r\n */
      if (newline == NULL) {
          if (sdslen(c->querybuf) > REDIS_INLINE_MAX_SIZE) {
              addReplyError(c,"Protocol error: too big inline request");
              setProtocolError(c,0);
          }
          return REDIS_ERR;
      }
  
      /* Split the input buffer up to the \r\n */
      querylen = newline-(c->querybuf);
      /**
       * 对本行的内容按照空格进行切分，将划分后的字符串数组
       * 的大小存入argc
       */
      argv = sdssplitlen(c->querybuf,querylen," ",1,&argc);
  
      /* Leave data after the first line of the query in the buffer */
      c->querybuf = sdsrange(c->querybuf,querylen+2,-1);
  
      /* Setup argv array on client structure */
      if (c->argv) zfree(c->argv);
      c->argv = zmalloc(sizeof(robj*)*argc);
  
      /* Create redis objects for all arguments.
       * 将切分后的字符串转成redisObj后存储到c->argv */
      for (c->argc = 0, j = 0; j < argc; j++) {
          if (sdslen(argv[j])) {
              c->argv[c->argc] = createObject(REDIS_STRING,argv[j]);
              c->argc++;
          } else {
              sdsfree(argv[j]);
          }
      }
      zfree(argv);
      return REDIS_OK;
  }
  
  /* Helper function. Trims query buffer to make the function that processes
   * multi bulk requests idempotent. */
  static void setProtocolError(redisClient *c, int pos) {
      if (server.verbosity >= REDIS_VERBOSE) {
          sds client = getClientInfoString(c);
          redisLog(REDIS_VERBOSE,
              "Protocol error from client: %s", client);
          sdsfree(client);
      }
      c->flags |= REDIS_CLOSE_AFTER_REPLY;
      c->querybuf = sdsrange(c->querybuf,pos,-1);
  }
  /**
   * 开始对客户端请求大块字符串数组的每个元素进行解析，如果解析完毕querybuf并且请求的数据已经完整，则调用相应的
   * redis内部命令
   * 与processInlineBuffer的区别是这个处理的参数属于multibulk参数。即以*开头的请求
   * @return REDIS_OK 参数已经解析完毕。
   * @return REDIS_ERR 参数还没有解析完整。
   */
  int processMultibulkBuffer(redisClient *c) {
      char *newline = NULL;
      int pos = 0, ok;
      long long ll;
  
      if (c->multibulklen == 0) {
      	//multibulklen代表本次请求中，有多少个参数(bulk string)等待解析。这个值初始化为0
          /* The client should have been reset */
          redisAssertWithInfo(c,NULL,c->argc == 0);
  
          /* Multi bulk length cannot be read without a \r\n */
          newline = strchr(c->querybuf,'\r');
          if (newline == NULL) {
              if (sdslen(c->querybuf) > REDIS_INLINE_MAX_SIZE) {
                  addReplyError(c,"Protocol error: too big mbulk count string");
                  setProtocolError(c,0);
              }
              return REDIS_ERR;
          }
  
          /* Buffer should also contain \n
  		  * 判断本行数据有没有接收完毕。第一行内容接收完毕的标记是遇到\R\N。
  		  * 假设目前querybuf="*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n"
  		  * 则newline-(c->querybuf)==2
  		  * (signed)sdslen(c->querybuf)-2)==20,条件不成立，此时状态是正常的，可以正常往下走
  		  * 假设接收的querybuf="*2\r"
  		  * 则newline-(c->querybuf)==2
  		  * (signed)sdslen(c->querybuf)-2)==1,条件成立。此时状态是错误的，直接返回REDIS_ERR
  		  *
  		  * 因此这个判断的主要用途是判断第一个参数是否接收完毕。
  		  * 即判断请求数据第一行的内容是否已经接收完整
  		  * */
          if (newline-(c->querybuf) > ((signed)sdslen(c->querybuf)-2))
              return REDIS_ERR;
  
          /* We know for sure there is a whole line since newline != NULL,
           * so go ahead and find out the multi bulk length. */
          redisAssertWithInfo(c,NULL,c->querybuf[0] == '*');
          /** 计算客户端请求中大块字符串(Bulk Strings)的个数，并将结果存储到ll变量中 */
          ok = string2ll(c->querybuf+1,newline-(c->querybuf+1),&ll);
          if (!ok || ll > 1024*1024) {
          	//如果请求中的大块字符串（bulk string)个数大于1024*024，则直接回复错误信息
              addReplyError(c,"Protocol error: invalid multibulk length");
              setProtocolError(c,pos);
              return REDIS_ERR;
          }
          //这个变量是为下一步解析每个大块字符串（bulk string)做准备
          pos = (newline-c->querybuf)+2;
          if (ll <= 0) {
          	//？这是什么情况？什么时候会进这个代码？
          	/**
          	 * 当数组的这个元素是空的时候，ll==-1,此时表示后面已经不会出现value行。
          	 * 可以直接将已经解析掉的字符清理掉。
          	 */
              c->querybuf = sdsrange(c->querybuf,pos,-1);
              //如果请求的参数个数为0或者小于0，则没有必要继续解析
              return REDIS_OK;
          }
          //将本客户端请求中大块字符串(bulk string)的个数记录下
          c->multibulklen = ll;
  
          /* Setup argv array on client structure
           * 为后面进一步的解析分配内存空间，因为已经明确后面会有多少个大块字符串，
           * 所以内存空间直接使用robj结构体乘以multibulklen */
          if (c->argv) zfree(c->argv);
          c->argv = zmalloc(sizeof(robj*)*c->multibulklen);
      }
  
      redisAssertWithInfo(c,NULL,c->multibulklen > 0);
      /**
       * 下面逐个解析请求中的大块字符串(bulk string)
       */
      while(c->multibulklen) {
          /* Read bulk length if unknown */
          if (c->bulklen == -1) {
          	//进入这里，说明对应数组元素的长度还未解析出来
              newline = strchr(c->querybuf+pos,'\r');
              if (newline == NULL) {
                  if (sdslen(c->querybuf) > REDIS_INLINE_MAX_SIZE) {
                      addReplyError(c,"Protocol error: too big bulk count string");
                      setProtocolError(c,0);
                  }
                  break;
              }
  
              /* Buffer should also contain \n
               * 确保本行内容已经接收完毕 */
              if (newline-(c->querybuf) > ((signed)sdslen(c->querybuf)-2))
                  break;
              /**
               * 大块字符串的第一个参数为大块字符串的长度
               */
              if (c->querybuf[pos] != '$') {
              	//客户端请求格式错误
                  addReplyErrorFormat(c,
                      "Protocol error: expected '$', got '%c'",
                      c->querybuf[pos]);
                  setProtocolError(c,pos);
                  return REDIS_ERR;
              }
              //读取大块字符串的长度，并将值设置到ll变量中
              ok = string2ll(c->querybuf+pos+1,newline-(c->querybuf+pos+1),&ll);
              if (!ok || ll < 0 || ll > 512*1024*1024) {
              	//大块字符串的长度不能超过512M
                  addReplyError(c,"Protocol error: invalid bulk length");
                  setProtocolError(c,pos);
                  return REDIS_ERR;
              }
              //pos继续往后移动
              pos += newline-(c->querybuf+pos)+2;
              if (ll >= REDIS_MBULK_BIG_ARG) {
                  /* If we are going to read a large object from network
                   * try to make it likely that it will start at c->querybuf
                   * boundary so that we can optimized object creation
                   * avoiding a large copy of data. */
                  c->querybuf = sdsrange(c->querybuf,pos,-1);
                  pos = 0;
                  /* Hint the sds library about the amount of bytes this string is
                   * going to contain. */
                  c->querybuf = sdsMakeRoomFor(c->querybuf,ll+2);
              }
              c->bulklen = ll;
          }
  
          /* Read bulk argument */
          if (sdslen(c->querybuf)-pos < (unsigned)(c->bulklen+2)) {
              /* Not enough data (+2 == trailing \r\n)
               * 根据前面已经收到的长度和后面的数据的长度相比，判断数据是否已经读取完毕 */
              break;
          } else {
              /* Optimization: if the buffer contanins JUST our bulk element
               * instead of creating a new object by *copying* the sds we
               * just use the current sds string. */
              if (pos == 0 &&
                  c->bulklen >= REDIS_MBULK_BIG_ARG &&
                  (signed) sdslen(c->querybuf) == c->bulklen+2)
              {
                  c->argv[c->argc++] = createObject(REDIS_STRING,c->querybuf);
                  sdsIncrLen(c->querybuf,-2); /* remove CRLF */
                  c->querybuf = sdsempty();
                  /* Assume that if we saw a fat argument we'll see another one
                   * likely... */
                  c->querybuf = sdsMakeRoomFor(c->querybuf,c->bulklen+2);
                  pos = 0;
              } else {
              	//走到这里，说明大块字符串的值已经明确，然后将字符串的值放入c->argv数组中
              	/*
              	 * 从这里可以推断，c->argc放着c->argv的数组的长度
              	 * c->argv的内容应该是类似这样的[{"get"}, {"somekey"}]
              	 * 或者[{"set"},{"somekey"},{"hello"}]
              	 */
                  c->argv[c->argc++] =
                      createStringObject(c->querybuf+pos,c->bulklen);
                  pos += c->bulklen+2;
              }
              c->bulklen = -1;
              //每当解析完毕一个数组元素，将c->multibulklen减少一次
              c->multibulklen--;
          }
      }
  
      /* Trim to pos */
      if (pos) c->querybuf = sdsrange(c->querybuf,pos,-1);
  
      /* We're done when c->multibulk == 0 */
      if (c->multibulklen == 0) return REDIS_OK;
  
      /* Still not read to process the command
       * 客户端请求的参数还没有完全接收到*/
      return REDIS_ERR;
  }
  /**
   * 大部分情况，到这里的时候，请求数据已经读取完毕，并已经存入querybuf。
   * 以下情况，到这个函数的时候，请求的数据可能还没有接收完毕
   * 1、请求的数据比较多，超过16k
   */
  void processInputBuffer(redisClient *c) {
      /* Keep processing while there is something in the input buffer
       * redis 每次解析完一个参数后，会将已经解析过的buffer给清理，这样
       * 当querybuf==0的时候，表示已经解析完毕，不用再进行解析*/
      while(sdslen(c->querybuf)) {
          /* Immediately abort if the client is in the middle of something. */
          if (c->flags & REDIS_BLOCKED) return;
  
          /* REDIS_CLOSE_AFTER_REPLY closes the connection once the reply is
           * written to the client. Make sure to not let the reply grow after
           * this flag has been set (i.e. don't process more commands). */
          if (c->flags & REDIS_CLOSE_AFTER_REPLY) return;
  
          /* Determine request type when unknown. */
          if (!c->reqtype) { //如果reqtype==0
              if (c->querybuf[0] == '*') {
              	//请求参数是数组形式，大部分的请求应该属于这种类型
                  c->reqtype = REDIS_REQ_MULTIBULK;
              } else {
              	//请求参数不是数组。
                  c->reqtype = REDIS_REQ_INLINE;
              }
          }
  
          if (c->reqtype == REDIS_REQ_INLINE) {
              if (processInlineBuffer(c) != REDIS_OK) break;
          } else if (c->reqtype == REDIS_REQ_MULTIBULK) {
          	/**
          	 * 返回REDIS_OK,表示参数解析正确，并且已经
          	 * 解析完整（请求参数已经读取完毕）相关的客户端命令都已经写入
          	 * c->argv字符串数组；否则的话说明数据还没有接收完毕，比如，请求的参数可能只接收到一半
          	 * 此时不应继续往下循环。
          	 */
              if (processMultibulkBuffer(c) != REDIS_OK) break;
          } else {
              redisPanic("Unknown request type");
          }
  
          /* Multibulk processing could see a <= 0 length. */
          if (c->argc == 0) {
              resetClient(c);
          } else {
              /* Only reset the client when the command was executed.
               * 根据客户端的请求命令，调用服务器的内部相应函数
               * 执行内部的业务逻辑 */
              if (processCommand(c) == REDIS_OK)
                  resetClient(c);
          }
      }
  }
  /**
   * 从客户端读取请求数据，并对收到的数据进行解析，转换为redis对应的命令
   */
  void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
      redisClient *c = (redisClient*) privdata;
      int nread, readlen;
      size_t qblen;
      REDIS_NOTUSED(el);
      REDIS_NOTUSED(mask);
  
      server.current_client = c;
      //接收缓存默认为16k
      readlen = REDIS_IOBUF_LEN;
      /* If this is a multi bulk request, and we are processing a bulk reply
       * that is large enough, try to maximize the probability that the query
       * buffer contains exactly the SDS string representing the object, even
       * at the risk of requiring more read(2) calls. This way the function
       * processMultiBulkBuffer() can avoid copying buffers to create the
       * Redis Object representing the argument. */
      if (c->reqtype == REDIS_REQ_MULTIBULK && c->multibulklen && c->bulklen != -1
          && c->bulklen >= REDIS_MBULK_BIG_ARG)
      {
          int remaining = (unsigned)(c->bulklen+2)-sdslen(c->querybuf);
  
          if (remaining < readlen) readlen = remaining;
      }
  
      // 分配空间
      qblen = sdslen(c->querybuf);
      if (c->querybuf_peak < qblen) c->querybuf_peak = qblen;
      //首次分配16k的缓存,如果是第二次读取，则扩展后，剩余的空间至少为16k
      c->querybuf = sdsMakeRoomFor(c->querybuf, readlen);
      
      // 读入到 buf
      nread = read(fd, c->querybuf+qblen, readlen);
  
      // 处理读错误值和 EOF （客户端已关闭）
      if (nread == -1) {
          if (errno == EAGAIN) {
              nread = 0;
          } else {
              redisLog(REDIS_VERBOSE, "Reading from client: %s",strerror(errno));
              freeClient(c);
              return;
          }
      } else if (nread == 0) {
          redisLog(REDIS_VERBOSE, "Client closed connection");
          freeClient(c);
          return;
      }
  
      // 根据读入情况更新客户端统计数据
      if (nread) {
      	//根据读取的字节数，更新字符串的长度
          sdsIncrLen(c->querybuf,nread);
          // 更新最后一次交互时间
          c->lastinteraction = server.unixtime;
      } else {
      	//从上面对nread的if else分支中，可以看出，可能会存在n==0的情况（比如nread==-1的时候，就把nread设置成了0
          server.current_client = NULL;
          return;
      }
  
      // 读入缓存不能超过限制，否则断开并清除客户端
      if (sdslen(c->querybuf) > server.client_max_querybuf_len) {
          sds ci = getClientInfoString(c), bytes = sdsempty();
  
          bytes = sdscatrepr(bytes,c->querybuf,64);
          redisLog(REDIS_WARNING,"Closing client that reached max query buffer length: %s (qbuf initial bytes: %s)", ci, bytes);
          sdsfree(ci);
          sdsfree(bytes);
          freeClient(c);
          return;
      }
  
      // 对已经收到的数据进行解析（decode),然后执行命令
      processInputBuffer(c);
  
      server.current_client = NULL;
  }
  
  void getClientsMaxBuffers(unsigned long *longest_output_list,
                            unsigned long *biggest_input_buffer) {
      redisClient *c;
      listNode *ln;
      listIter li;
      unsigned long lol = 0, bib = 0;
  
      listRewind(server.clients,&li);
      while ((ln = listNext(&li)) != NULL) {
          c = listNodeValue(ln);
  
          if (listLength(c->reply) > lol) lol = listLength(c->reply);
          if (sdslen(c->querybuf) > bib) bib = sdslen(c->querybuf);
      }
      *longest_output_list = lol;
      *biggest_input_buffer = bib;
  }
  
  /* Turn a Redis client into an sds string representing its state.  * 
   * 将客户端的当前状态信息保存到一个字符串中。
   */
  sds getClientInfoString(redisClient *client) {
      char ip[32], flags[16], events[3], *p;
      int port = 0; /* initialized to zero for the unix socket case. */
      int emask;
  
      if (!(client->flags & REDIS_UNIX_SOCKET))
          anetPeerToString(client->fd,ip,&port);
      p = flags;
      if (client->flags & REDIS_SLAVE) {
          if (client->flags & REDIS_MONITOR)
              *p++ = 'O';
          else
              *p++ = 'S';
      }
      if (client->flags & REDIS_MASTER) *p++ = 'M';
      if (client->flags & REDIS_MULTI) *p++ = 'x';
      if (client->flags & REDIS_BLOCKED) *p++ = 'b';
      if (client->flags & REDIS_DIRTY_CAS) *p++ = 'd';
      if (client->flags & REDIS_CLOSE_AFTER_REPLY) *p++ = 'c';
      if (client->flags & REDIS_UNBLOCKED) *p++ = 'u';
      if (client->flags & REDIS_CLOSE_ASAP) *p++ = 'A';
      if (client->flags & REDIS_UNIX_SOCKET) *p++ = 'U';
      if (p == flags) *p++ = 'N';
      *p++ = '\0';
  
      emask = client->fd == -1 ? 0 : aeGetFileEvents(server.el,client->fd);
      p = events;
      if (emask & AE_READABLE) *p++ = 'r';
      if (emask & AE_WRITABLE) *p++ = 'w';
      *p = '\0';
      return sdscatprintf(sdsempty(),
          "addr=%s:%d fd=%d age=%ld idle=%ld flags=%s db=%d sub=%d psub=%d multi=%d qbuf=%lu qbuf-free=%lu obl=%lu oll=%lu omem=%lu events=%s cmd=%s",
          (client->flags & REDIS_UNIX_SOCKET) ? server.unixsocket : ip,
          port,client->fd,
          (long)(server.unixtime - client->ctime),
          (long)(server.unixtime - client->lastinteraction),
          flags,
          client->db->id,
          (int) dictSize(client->pubsub_channels),
          (int) listLength(client->pubsub_patterns),
          (client->flags & REDIS_MULTI) ? client->mstate.count : -1,
          (unsigned long) sdslen(client->querybuf),
          (unsigned long) sdsavail(client->querybuf),
          (unsigned long) client->bufpos,
          (unsigned long) listLength(client->reply),
          getClientOutputBufferMemoryUsage(client),
          events,
          client->lastcmd ? client->lastcmd->name : "NULL");
  }
  
  /*
   * 收集并返回所有客户端的状态信息
   */
  sds getAllClientsInfoString(void) {
      listNode *ln;
      listIter li;
      redisClient *client;
      sds o = sdsempty();
  
      listRewind(server.clients,&li);
      while ((ln = listNext(&li)) != NULL) {
          sds cs;
  
          client = listNodeValue(ln);
          cs = getClientInfoString(client);
          o = sdscatsds(o,cs);
          sdsfree(cs);
          o = sdscatlen(o,"\n",1);
      }
      return o;
  }
  
  /*
   * CLIENT 命令的实现
   *
   * 列出客户端的信息，或者对客户端进行操作。
   */
  void clientCommand(redisClient *c) {
      listNode *ln;
      listIter li;
      redisClient *client;
  
      // 列出所有客户端的状态
      if (!strcasecmp(c->argv[1]->ptr,"list") && c->argc == 2) {
          sds o = getAllClientsInfoString();
          addReplyBulkCBuffer(c,o,sdslen(o));
          sdsfree(o);
  
      // 关闭给定客户端
      } else if (!strcasecmp(c->argv[1]->ptr,"kill") && c->argc == 3) {
          listRewind(server.clients,&li);
          while ((ln = listNext(&li)) != NULL) {
              char ip[32], addr[64];
              int port;
  
              client = listNodeValue(ln);
              if (anetPeerToString(client->fd,ip,&port) == -1) continue;
              snprintf(addr,sizeof(addr),"%s:%d",ip,port);
              if (strcmp(addr,c->argv[2]->ptr) == 0) {
                  addReply(c,shared.ok);
                  if (c == client) {
                      client->flags |= REDIS_CLOSE_AFTER_REPLY;
                  } else {
                      freeClient(client);
                  }
                  return;
              }
          }
          addReplyError(c,"No such client");
      } else {
          addReplyError(c, "Syntax error, try CLIENT (LIST | KILL ip:port)");
      }
  }
  
  /* Rewrite the command vector of the client. All the new objects ref count
   * is incremented. The old command vector is freed, and the old objects
   * ref count is decremented. */
  void rewriteClientCommandVector(redisClient *c, int argc, ...) {
      va_list ap;
      int j;
      robj **argv; /* The new argument vector */
  
      argv = zmalloc(sizeof(robj*)*argc);
      va_start(ap,argc);
      for (j = 0; j < argc; j++) {
          robj *a;
          
          a = va_arg(ap, robj*);
          argv[j] = a;
          incrRefCount(a);
      }
      /* We free the objects in the original vector at the end, so we are
       * sure that if the same objects are reused in the new vector the
       * refcount gets incremented before it gets decremented. */
      for (j = 0; j < c->argc; j++) decrRefCount(c->argv[j]);
      zfree(c->argv);
      /* Replace argv and argc with our new versions. */
      c->argv = argv;
      c->argc = argc;
      c->cmd = lookupCommand(c->argv[0]->ptr);
      redisAssertWithInfo(c,NULL,c->cmd != NULL);
      va_end(ap);
  }
  
  /* Rewrite a single item in the command vector.
   * The new val ref count is incremented, and the old decremented. */
  void rewriteClientCommandArgument(redisClient *c, int i, robj *newval) {
      robj *oldval;
     
      redisAssertWithInfo(c,NULL,i < c->argc);
      oldval = c->argv[i];
      c->argv[i] = newval;
      incrRefCount(newval);
      decrRefCount(oldval);
  
      /* If this is the command name make sure to fix c->cmd. */
      if (i == 0) {
          c->cmd = lookupCommand(c->argv[0]->ptr);
          redisAssertWithInfo(c,NULL,c->cmd != NULL);
      }
  }
  
  /* This function returns the number of bytes that Redis is virtually
   * using to store the reply still not read by the client.
   * It is "virtual" since the reply output list may contain objects that
   * are shared and are not really using additional memory.
   *
   * The function returns the total sum of the length of all the objects
   * stored in the output list, plus the memory used to allocate every
   * list node. The static reply buffer is not taken into account since it
   * is allocated anyway.
   *
   * Note: this function is very fast so can be called as many time as
   * the caller wishes. The main usage of this function currently is
   * enforcing the client output length limits. */
  unsigned long getClientOutputBufferMemoryUsage(redisClient *c) {
      unsigned long list_item_size = sizeof(listNode)+sizeof(robj);
  
      return c->reply_bytes + (list_item_size*listLength(c->reply));
  }
  
  /* Get the class of a client, used in order to enforce limits to different
   * classes of clients.
   *
   * The function will return one of the following:
   * REDIS_CLIENT_LIMIT_CLASS_NORMAL -> Normal client
   * REDIS_CLIENT_LIMIT_CLASS_SLAVE  -> Slave or client executing MONITOR command
   * REDIS_CLIENT_LIMIT_CLASS_PUBSUB -> Client subscribed to Pub/Sub channels
   */
  int getClientLimitClass(redisClient *c) {
      if (c->flags & REDIS_SLAVE) return REDIS_CLIENT_LIMIT_CLASS_SLAVE;
      if (dictSize(c->pubsub_channels) || listLength(c->pubsub_patterns))
          return REDIS_CLIENT_LIMIT_CLASS_PUBSUB;
      return REDIS_CLIENT_LIMIT_CLASS_NORMAL;
  }
  
  int getClientLimitClassByName(char *name) {
      if (!strcasecmp(name,"normal")) return REDIS_CLIENT_LIMIT_CLASS_NORMAL;
      else if (!strcasecmp(name,"slave")) return REDIS_CLIENT_LIMIT_CLASS_SLAVE;
      else if (!strcasecmp(name,"pubsub")) return REDIS_CLIENT_LIMIT_CLASS_PUBSUB;
      else return -1;
  }
  
  char *getClientLimitClassName(int class) {
      switch(class) {
      case REDIS_CLIENT_LIMIT_CLASS_NORMAL:   return "normal";
      case REDIS_CLIENT_LIMIT_CLASS_SLAVE:    return "slave";
      case REDIS_CLIENT_LIMIT_CLASS_PUBSUB:   return "pubsub";
      default:                                return NULL;
      }
  }
  
  /* The function checks if the client reached output buffer soft or hard
   * limit, and also update the state needed to check the soft limit as
   * a side effect.
   *
   * Return value: non-zero if the client reached the soft or the hard limit.
   *               Otherwise zero is returned. */
  int checkClientOutputBufferLimits(redisClient *c) {
      int soft = 0, hard = 0, class;
      unsigned long used_mem = getClientOutputBufferMemoryUsage(c);
  
      class = getClientLimitClass(c);
      if (server.client_obuf_limits[class].hard_limit_bytes &&
          used_mem >= server.client_obuf_limits[class].hard_limit_bytes)
          hard = 1;
      if (server.client_obuf_limits[class].soft_limit_bytes &&
          used_mem >= server.client_obuf_limits[class].soft_limit_bytes)
          soft = 1;
  
      /* We need to check if the soft limit is reached continuously for the
       * specified amount of seconds. */
      if (soft) {
          if (c->obuf_soft_limit_reached_time == 0) {
              c->obuf_soft_limit_reached_time = server.unixtime;
              soft = 0; /* First time we see the soft limit reached */
          } else {
              time_t elapsed = server.unixtime - c->obuf_soft_limit_reached_time;
  
              if (elapsed <=
                  server.client_obuf_limits[class].soft_limit_seconds) {
                  soft = 0; /* The client still did not reached the max number of
                               seconds for the soft limit to be considered
                               reached. */
              }
          }
      } else {
          c->obuf_soft_limit_reached_time = 0;
      }
      return soft || hard;
  }
  
  /* Asynchronously close a client if soft or hard limit is reached on the
   * output buffer size. The caller can check if the client will be closed
   * checking if the client REDIS_CLOSE_ASAP flag is set.
   *
   * Note: we need to close the client asynchronously because this function is
   * called from contexts where the client can't be freed safely, i.e. from the
   * lower level functions pushing data inside the client output buffers. */
  // 如果客户端的缓存限制被突破了，那么关闭这个客户端
  void asyncCloseClientOnOutputBufferLimitReached(redisClient *c) {
      redisAssert(c->reply_bytes < ULONG_MAX-(1024*64));
      if (c->reply_bytes == 0 || c->flags & REDIS_CLOSE_ASAP) return;
      if (checkClientOutputBufferLimits(c)) {
          sds client = getClientInfoString(c);
  
          freeClientAsync(c);
          redisLog(REDIS_WARNING,"Client %s scheduled to be closed ASAP for overcoming of output buffer limits.", client);
          sdsfree(client);
      }
  }
  
  /* Helper function used by freeMemoryIfNeeded() in order to flush slaves
   * output buffers without returning control to the event loop. */
  void flushSlavesOutputBuffers(void) {
      listIter li;
      listNode *ln;
  
      listRewind(server.slaves,&li);
      while((ln = listNext(&li))) {
          redisClient *slave = listNodeValue(ln);
          int events;
  
          events = aeGetFileEvents(server.el,slave->fd);
          if (events & AE_WRITABLE &&
              slave->replstate == REDIS_REPL_ONLINE &&
              listLength(slave->reply))
          {
              sendReplyToClient(server.el,slave->fd,slave,0);
          }
      }
  }
  