src/networking.c

#include "redis.h"

#include <sys/uio.h>

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(*c));

    anetNonBlock(NULL,fd);
    anetTcpNoDelay(NULL,fd);
    if (!c) return NULL;
    selectDb(c,0);
    c->fd = fd;
    c->querybuf = sdsempty();
    c->argc = 0;
    c->argv = NULL;
    c->bulklen = -1;
    c->multibulk = 0;
    c->mbargc = 0;
    c->mbargv = NULL;
    c->sentlen = 0;
    c->flags = 0;
    c->lastinteraction = time(NULL);
    c->authenticated = 0;
    c->replstate = REDIS_REPL_NONE;
    c->reply = listCreate();
    listSetFreeMethod(c->reply,decrRefCount);
    listSetDupMethod(c->reply,dupClientReplyValue);
    c->blocking_keys = NULL;
    c->blocking_keys_num = 0;
    c->io_keys = listCreate();
    c->watched_keys = listCreate();
    listSetFreeMethod(c->io_keys,decrRefCount);
    c->pubsub_channels = dictCreate(&setDictType,NULL);
    c->pubsub_patterns = listCreate();
    listSetFreeMethod(c->pubsub_patterns,decrRefCount);
    listSetMatchMethod(c->pubsub_patterns,listMatchObjects);
    if (aeCreateFileEvent(server.el, c->fd, AE_READABLE,
        readQueryFromClient, c) == AE_ERR) {
        freeClient(c);
        return NULL;
    }
    listAddNodeTail(server.clients,c);
    initClientMultiState(c);
    return c;
}

void addReply(redisClient *c, robj *obj) {
    if (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;

    if (server.vm_enabled && obj->storage != REDIS_VM_MEMORY) {
        obj = dupStringObject(obj);
        obj->refcount = 0; /* getDecodedObject() will increment the refcount */
    }
    listAddNodeTail(c->reply,getDecodedObject(obj));
}

void addReplySds(redisClient *c, sds s) {
    robj *o = createObject(REDIS_STRING,s);
    addReply(c,o);
    decrRefCount(o);
}

void addReplyDouble(redisClient *c, double d) {
    char buf[128];

    snprintf(buf,sizeof(buf),"%.17g",d);
    addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n%s\r\n",
        (unsigned long) strlen(buf),buf));
}

void addReplyLongLong(redisClient *c, long long ll) {
    char buf[128];
    size_t len;

    if (ll == 0) {
        addReply(c,shared.czero);
        return;
    } else if (ll == 1) {
        addReply(c,shared.cone);
        return;
    }
    buf[0] = ':';
    len = ll2string(buf+1,sizeof(buf)-1,ll);
    buf[len+1] = '\r';
    buf[len+2] = '\n';
    addReplySds(c,sdsnewlen(buf,len+3));
}

void addReplyUlong(redisClient *c, unsigned long ul) {
    char buf[128];
    size_t len;

    if (ul == 0) {
        addReply(c,shared.czero);
        return;
    } else if (ul == 1) {
        addReply(c,shared.cone);
        return;
    }
    len = snprintf(buf,sizeof(buf),":%lu\r\n",ul);
    addReplySds(c,sdsnewlen(buf,len));
}

void addReplyBulkLen(redisClient *c, robj *obj) {
    size_t len, intlen;
    char buf[128];

    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++;
        }
    }
    buf[0] = '$';
    intlen = ll2string(buf+1,sizeof(buf)-1,(long long)len);
    buf[intlen+1] = '\r';
    buf[intlen+2] = '\n';
    addReplySds(c,sdsnewlen(buf,intlen+3));
}

void addReplyBulk(redisClient *c, robj *obj) {
    addReplyBulkLen(c,obj);
    addReply(c,obj);
    addReply(c,shared.crlf);
}

/* In the CONFIG command we need to add vanilla C string as bulk replies */
void addReplyBulkCString(redisClient *c, char *s) {
    if (s == NULL) {
        addReply(c,shared.nullbulk);
    } else {
        robj *o = createStringObject(s,strlen(s));
        addReplyBulk(c,o);
        decrRefCount(o);
    }
}

void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
    int cport, cfd;
    char cip[128];
    redisClient *c;
    REDIS_NOTUSED(el);
    REDIS_NOTUSED(mask);
    REDIS_NOTUSED(privdata);

    cfd = anetAccept(server.neterr, fd, cip, &cport);
    if (cfd == AE_ERR) {
        redisLog(REDIS_VERBOSE,"Accepting client connection: %s", server.neterr);
        return;
    }
    redisLog(REDIS_VERBOSE,"Accepted %s:%d", cip, cport);
    if ((c = createClient(cfd)) == NULL) {
        redisLog(REDIS_WARNING,"Error allocating resoures for the client");
        close(cfd); /* May be already closed, just ingore 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 (server.maxclients && 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... */
        }
        freeClient(c);
        return;
    }
    server.stat_numconnections++;
}

static void freeClientArgv(redisClient *c) {
    int j;

    for (j = 0; j < c->argc; j++)
        decrRefCount(c->argv[j]);
    for (j = 0; j < c->mbargc; j++)
        decrRefCount(c->mbargv[j]);
    c->argc = 0;
    c->mbargc = 0;
}

void freeClient(redisClient *c) {
    listNode *ln;

    /* 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);

    /* 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);
    /* Remove from the list of clients waiting for swapped keys, or ready
     * to be restarted, but not yet woken up again. */
    if (c->flags & REDIS_IO_WAIT) {
        redisAssert(server.vm_enabled);
        if (listLength(c->io_keys) == 0) {
            ln = listSearchKey(server.io_ready_clients,c);

            /* When this client is waiting to be woken up (REDIS_IO_WAIT),
             * it should be present in the list io_ready_clients */
            redisAssert(ln != NULL);
            listDelNode(server.io_ready_clients,ln);
        } else {
            while (listLength(c->io_keys)) {
                ln = listFirst(c->io_keys);
                dontWaitForSwappedKey(c,ln->value);
            }
        }
        server.vm_blocked_clients--;
    }
    listRelease(c->io_keys);
    /* Master/slave cleanup */
    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);
    }
    if (c->flags & REDIS_MASTER) {
        server.master = NULL;
        server.replstate = REDIS_REPL_CONNECT;
    }
    /* Release memory */
    zfree(c->argv);
    zfree(c->mbargv);
    freeClientMultiState(c);
    zfree(c);
}

#define GLUEREPLY_UP_TO (1024)
static void glueReplyBuffersIfNeeded(redisClient *c) {
    int copylen = 0;
    char buf[GLUEREPLY_UP_TO];
    listNode *ln;
    listIter li;
    robj *o;

    listRewind(c->reply,&li);
    while((ln = listNext(&li))) {
        int objlen;

        o = ln->value;
        objlen = sdslen(o->ptr);
        if (copylen + objlen <= GLUEREPLY_UP_TO) {
            memcpy(buf+copylen,o->ptr,objlen);
            copylen += objlen;
            listDelNode(c->reply,ln);
        } else {
            if (copylen == 0) return;
            break;
        }
    }
    /* Now the output buffer is empty, add the new single element */
    o = createObject(REDIS_STRING,sdsnewlen(buf,copylen));
    listAddNodeHead(c->reply,o);
}

void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) {
    redisClient *c = privdata;
    int nwritten = 0, totwritten = 0, objlen;
    robj *o;
    REDIS_NOTUSED(el);
    REDIS_NOTUSED(mask);

    /* Use writev() if we have enough buffers to send */
    if (!server.glueoutputbuf &&
        listLength(c->reply) > REDIS_WRITEV_THRESHOLD &&
        !(c->flags & REDIS_MASTER))
    {
        sendReplyToClientWritev(el, fd, privdata, mask);
        return;
    }

    while(listLength(c->reply)) {
        if (server.glueoutputbuf && listLength(c->reply) > 1)
            glueReplyBuffersIfNeeded(c);

        o = listNodeValue(listFirst(c->reply));
        objlen = sdslen(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;
        }
        /* Note that we avoid to send more thank 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 interfae) */
        if (totwritten > REDIS_MAX_WRITE_PER_EVENT) 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 = time(NULL);
    if (listLength(c->reply) == 0) {
        c->sentlen = 0;
        aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
    }
}

void sendReplyToClientWritev(aeEventLoop *el, int fd, void *privdata, int mask)
{
    redisClient *c = privdata;
    int nwritten = 0, totwritten = 0, objlen, willwrite;
    robj *o;
    struct iovec iov[REDIS_WRITEV_IOVEC_COUNT];
    int offset, ion = 0;
    REDIS_NOTUSED(el);
    REDIS_NOTUSED(mask);

    listNode *node;
    while (listLength(c->reply)) {
        offset = c->sentlen;
        ion = 0;
        willwrite = 0;

        /* fill-in the iov[] array */
        for(node = listFirst(c->reply); node; node = listNextNode(node)) {
            o = listNodeValue(node);
            objlen = sdslen(o->ptr);

            if (totwritten + objlen - offset > REDIS_MAX_WRITE_PER_EVENT)
                break;

            if(ion == REDIS_WRITEV_IOVEC_COUNT)
                break; /* no more iovecs */

            iov[ion].iov_base = ((char*)o->ptr) + offset;
            iov[ion].iov_len = objlen - offset;
            willwrite += objlen - offset;
            offset = 0; /* just for the first item */
            ion++;
        }

        if(willwrite == 0)
            break;

        /* write all collected blocks at once */
        if((nwritten = writev(fd, iov, ion)) < 0) {
            if (errno != EAGAIN) {
                redisLog(REDIS_VERBOSE,
                         "Error writing to client: %s", strerror(errno));
                freeClient(c);
                return;
            }
            break;
        }

        totwritten += nwritten;
        offset = c->sentlen;

        /* remove written robjs from c->reply */
        while (nwritten && listLength(c->reply)) {
            o = listNodeValue(listFirst(c->reply));
            objlen = sdslen(o->ptr);

            if(nwritten >= objlen - offset) {
                listDelNode(c->reply, listFirst(c->reply));
                nwritten -= objlen - offset;
                c->sentlen = 0;
            } else {
                /* partial write */
                c->sentlen += nwritten;
                break;
            }
            offset = 0;
        }
    }

    if (totwritten > 0)
        c->lastinteraction = time(NULL);

    if (listLength(c->reply) == 0) {
        c->sentlen = 0;
        aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
    }
}

/* resetClient prepare the client to process the next command */
void resetClient(redisClient *c) {
    freeClientArgv(c);
    c->bulklen = -1;
    c->multibulk = 0;
}

void closeTimedoutClients(void) {
    redisClient *c;
    listNode *ln;
    time_t now = time(NULL);
    listIter li;

    listRewind(server.clients,&li);
    while ((ln = listNext(&li)) != NULL) {
        c = listNodeValue(ln);
        if (server.maxidletime &&
            !(c->flags & REDIS_SLAVE) &&    /* no timeout for slaves */
            !(c->flags & REDIS_MASTER) &&   /* no timeout for masters */
            dictSize(c->pubsub_channels) == 0 && /* no timeout for pubsub */
            listLength(c->pubsub_patterns) == 0 &&
            (now - c->lastinteraction > server.maxidletime))
        {
            redisLog(REDIS_VERBOSE,"Closing idle client");
            freeClient(c);
        } else if (c->flags & REDIS_BLOCKED) {
            if (c->blockingto != 0 && c->blockingto < now) {
                addReply(c,shared.nullmultibulk);
                unblockClientWaitingData(c);
            }
        }
    }
}

void processInputBuffer(redisClient *c) {
again:
    /* Before to process the input buffer, make sure the client is not
     * waitig for a blocking operation such as BLPOP. Note that the first
     * iteration the client is never blocked, otherwise the processInputBuffer
     * would not be called at all, but after the execution of the first commands
     * in the input buffer the client may be blocked, and the "goto again"
     * will try to reiterate. The following line will make it return asap. */
    if (c->flags & REDIS_BLOCKED || c->flags & REDIS_IO_WAIT) return;
    if (c->bulklen == -1) {
        /* Read the first line of the query */
        char *p = strchr(c->querybuf,'\n');
        size_t querylen;

        if (p) {
            sds query, *argv;
            int argc, j;

            query = c->querybuf;
            c->querybuf = sdsempty();
            querylen = 1+(p-(query));
            if (sdslen(query) > querylen) {
                /* leave data after the first line of the query in the buffer */
                c->querybuf = sdscatlen(c->querybuf,query+querylen,sdslen(query)-querylen);
            }
            *p = '\0'; /* remove "\n" */
            if (*(p-1) == '\r') *(p-1) = '\0'; /* and "\r" if any */
            sdsupdatelen(query);

            /* Now we can split the query in arguments */
            argv = sdssplitlen(query,sdslen(query)," ",1,&argc);
            sdsfree(query);

            if (c->argv) zfree(c->argv);
            c->argv = zmalloc(sizeof(robj*)*argc);

            for (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);
            if (c->argc) {
                /* Execute the command. If the client is still valid
                 * after processCommand() return and there is something
                 * on the query buffer try to process the next command. */
                if (processCommand(c) && sdslen(c->querybuf)) goto again;
            } else {
                /* Nothing to process, argc == 0. Just process the query
                 * buffer if it's not empty or return to the caller */
                if (sdslen(c->querybuf)) goto again;
            }
            return;
        } else if (sdslen(c->querybuf) >= REDIS_REQUEST_MAX_SIZE) {
            redisLog(REDIS_VERBOSE, "Client protocol error");
            freeClient(c);
            return;
        }
    } else {
        /* Bulk read handling. Note that if we are at this point
           the client already sent a command terminated with a newline,
           we are reading the bulk data that is actually the last
           argument of the command. */
        int qbl = sdslen(c->querybuf);

        if (c->bulklen <= qbl) {
            /* Copy everything but the final CRLF as final argument */
            c->argv[c->argc] = createStringObject(c->querybuf,c->bulklen-2);
            c->argc++;
            c->querybuf = sdsrange(c->querybuf,c->bulklen,-1);
            /* Process the command. If the client is still valid after
             * the processing and there is more data in the buffer
             * try to parse it. */
            if (processCommand(c) && sdslen(c->querybuf)) goto again;
            return;
        }
    }
}

void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
    redisClient *c = (redisClient*) privdata;
    char buf[REDIS_IOBUF_LEN];
    int nread;
    REDIS_NOTUSED(el);
    REDIS_NOTUSED(mask);

    nread = read(fd, buf, REDIS_IOBUF_LEN);
    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) {
        c->querybuf = sdscatlen(c->querybuf, buf, nread);
        c->lastinteraction = time(NULL);
    } else {
        return;
    }
    processInputBuffer(c);
}
Commit	Line	Data
	1	#include "redis.h"
	2
	3	#include <sys/uio.h>
	4
	5	void dupClientReplyValue(void o) {
	6	incrRefCount((robj*)o);
	7	return o;
	8	}
	9
	10	int listMatchObjects(void a, void b) {
	11	return equalStringObjects(a,b);
	12	}
	13
	14	redisClient *createClient(int fd) {
	15	redisClient c = zmalloc(sizeof(c));
	16
	17	anetNonBlock(NULL,fd);
	18	anetTcpNoDelay(NULL,fd);
	19	if (!c) return NULL;
	20	selectDb(c,0);
	21	c->fd = fd;
	22	c->querybuf = sdsempty();
	23	c->argc = 0;
	24	c->argv = NULL;
	25	c->bulklen = -1;
	26	c->multibulk = 0;
	27	c->mbargc = 0;
	28	c->mbargv = NULL;
	29	c->sentlen = 0;
	30	c->flags = 0;
	31	c->lastinteraction = time(NULL);
	32	c->authenticated = 0;
	33	c->replstate = REDIS_REPL_NONE;
	34	c->reply = listCreate();
	35	listSetFreeMethod(c->reply,decrRefCount);
	36	listSetDupMethod(c->reply,dupClientReplyValue);
	37	c->blocking_keys = NULL;
	38	c->blocking_keys_num = 0;
	39	c->io_keys = listCreate();
	40	c->watched_keys = listCreate();
	41	listSetFreeMethod(c->io_keys,decrRefCount);
	42	c->pubsub_channels = dictCreate(&setDictType,NULL);
	43	c->pubsub_patterns = listCreate();
	44	listSetFreeMethod(c->pubsub_patterns,decrRefCount);
	45	listSetMatchMethod(c->pubsub_patterns,listMatchObjects);
	46	if (aeCreateFileEvent(server.el, c->fd, AE_READABLE,
	47	readQueryFromClient, c) == AE_ERR) {
	48	freeClient(c);
	49	return NULL;
	50	}
	51	listAddNodeTail(server.clients,c);
	52	initClientMultiState(c);
	53	return c;
	54	}
	55
	56	void addReply(redisClient c, robj obj) {
	57	if (listLength(c->reply) == 0 &&
	58	(c->replstate == REDIS_REPL_NONE \|\|
	59	c->replstate == REDIS_REPL_ONLINE) &&
	60	aeCreateFileEvent(server.el, c->fd, AE_WRITABLE,
	61	sendReplyToClient, c) == AE_ERR) return;
	62
	63	if (server.vm_enabled && obj->storage != REDIS_VM_MEMORY) {
	64	obj = dupStringObject(obj);
	65	obj->refcount = 0; /* getDecodedObject() will increment the refcount */
	66	}
	67	listAddNodeTail(c->reply,getDecodedObject(obj));
	68	}
	69
	70	void addReplySds(redisClient *c, sds s) {
	71	robj *o = createObject(REDIS_STRING,s);
	72	addReply(c,o);
	73	decrRefCount(o);
	74	}
	75
	76	void addReplyDouble(redisClient *c, double d) {
	77	char buf[128];
	78
	79	snprintf(buf,sizeof(buf),"%.17g",d);
	80	addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n%s\r\n",
	81	(unsigned long) strlen(buf),buf));
	82	}
	83
	84	void addReplyLongLong(redisClient *c, long long ll) {
	85	char buf[128];
	86	size_t len;
	87
	88	if (ll == 0) {
	89	addReply(c,shared.czero);
	90	return;
	91	} else if (ll == 1) {
	92	addReply(c,shared.cone);
	93	return;
	94	}
	95	buf[0] = ':';
	96	len = ll2string(buf+1,sizeof(buf)-1,ll);
	97	buf[len+1] = '\r';
	98	buf[len+2] = '\n';
	99	addReplySds(c,sdsnewlen(buf,len+3));
	100	}
	101
	102	void addReplyUlong(redisClient *c, unsigned long ul) {
	103	char buf[128];
	104	size_t len;
	105
	106	if (ul == 0) {
	107	addReply(c,shared.czero);
	108	return;
	109	} else if (ul == 1) {
	110	addReply(c,shared.cone);
	111	return;
	112	}
	113	len = snprintf(buf,sizeof(buf),":%lu\r\n",ul);
	114	addReplySds(c,sdsnewlen(buf,len));
	115	}
	116
	117	void addReplyBulkLen(redisClient c, robj obj) {
	118	size_t len, intlen;
	119	char buf[128];
	120
	121	if (obj->encoding == REDIS_ENCODING_RAW) {
	122	len = sdslen(obj->ptr);
	123	} else {
	124	long n = (long)obj->ptr;
	125
	126	/* Compute how many bytes will take this integer as a radix 10 string */
	127	len = 1;
	128	if (n < 0) {
	129	len++;
	130	n = -n;
	131	}
	132	while((n = n/10) != 0) {
	133	len++;
	134	}
	135	}
	136	buf[0] = '$';
	137	intlen = ll2string(buf+1,sizeof(buf)-1,(long long)len);
	138	buf[intlen+1] = '\r';
	139	buf[intlen+2] = '\n';
	140	addReplySds(c,sdsnewlen(buf,intlen+3));
	141	}
	142
	143	void addReplyBulk(redisClient c, robj obj) {
	144	addReplyBulkLen(c,obj);
	145	addReply(c,obj);
	146	addReply(c,shared.crlf);
	147	}
	148
	149	/* In the CONFIG command we need to add vanilla C string as bulk replies */
	150	void addReplyBulkCString(redisClient c, char s) {
	151	if (s == NULL) {
	152	addReply(c,shared.nullbulk);
	153	} else {
	154	robj *o = createStringObject(s,strlen(s));
	155	addReplyBulk(c,o);
	156	decrRefCount(o);
	157	}
	158	}
	159
	160	void acceptHandler(aeEventLoop el, int fd, void privdata, int mask) {
	161	int cport, cfd;
	162	char cip[128];
	163	redisClient *c;
	164	REDIS_NOTUSED(el);
	165	REDIS_NOTUSED(mask);
	166	REDIS_NOTUSED(privdata);
	167
	168	cfd = anetAccept(server.neterr, fd, cip, &cport);
	169	if (cfd == AE_ERR) {
	170	redisLog(REDIS_VERBOSE,"Accepting client connection: %s", server.neterr);
	171	return;
	172	}
	173	redisLog(REDIS_VERBOSE,"Accepted %s:%d", cip, cport);
	174	if ((c = createClient(cfd)) == NULL) {
	175	redisLog(REDIS_WARNING,"Error allocating resoures for the client");
	176	close(cfd); /* May be already closed, just ingore errors */
	177	return;
	178	}
	179	/* If maxclient directive is set and this is one client more... close the
	180	* connection. Note that we create the client instead to check before
	181	* for this condition, since now the socket is already set in nonblocking
	182	* mode and we can send an error for free using the Kernel I/O */
	183	if (server.maxclients && listLength(server.clients) > server.maxclients) {
	184	char *err = "-ERR max number of clients reached\r\n";
	185
	186	/* That's a best effort error message, don't check write errors */
	187	if (write(c->fd,err,strlen(err)) == -1) {
	188	/* Nothing to do, Just to avoid the warning... */
	189	}
	190	freeClient(c);
	191	return;
	192	}
	193	server.stat_numconnections++;
	194	}
	195
	196	static void freeClientArgv(redisClient *c) {
	197	int j;
	198
	199	for (j = 0; j < c->argc; j++)
	200	decrRefCount(c->argv[j]);
	201	for (j = 0; j < c->mbargc; j++)
	202	decrRefCount(c->mbargv[j]);
	203	c->argc = 0;
	204	c->mbargc = 0;
	205	}
	206
	207	void freeClient(redisClient *c) {
	208	listNode *ln;
	209
	210	/* Note that if the client we are freeing is blocked into a blocking
	211	* call, we have to set querybuf to NULL before to call
	212	* unblockClientWaitingData() to avoid processInputBuffer() will get
	213	* called. Also it is important to remove the file events after
	214	* this, because this call adds the READABLE event. */
	215	sdsfree(c->querybuf);
	216	c->querybuf = NULL;
	217	if (c->flags & REDIS_BLOCKED)
	218	unblockClientWaitingData(c);
	219
	220	/* UNWATCH all the keys */
	221	unwatchAllKeys(c);
	222	listRelease(c->watched_keys);
	223	/* Unsubscribe from all the pubsub channels */
	224	pubsubUnsubscribeAllChannels(c,0);
	225	pubsubUnsubscribeAllPatterns(c,0);
	226	dictRelease(c->pubsub_channels);
	227	listRelease(c->pubsub_patterns);
	228	/* Obvious cleanup */
	229	aeDeleteFileEvent(server.el,c->fd,AE_READABLE);
	230	aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
	231	listRelease(c->reply);
	232	freeClientArgv(c);
	233	close(c->fd);
	234	/* Remove from the list of clients */
	235	ln = listSearchKey(server.clients,c);
	236	redisAssert(ln != NULL);
	237	listDelNode(server.clients,ln);
	238	/* Remove from the list of clients waiting for swapped keys, or ready
	239	* to be restarted, but not yet woken up again. */
	240	if (c->flags & REDIS_IO_WAIT) {
	241	redisAssert(server.vm_enabled);
	242	if (listLength(c->io_keys) == 0) {
	243	ln = listSearchKey(server.io_ready_clients,c);
	244
	245	/* When this client is waiting to be woken up (REDIS_IO_WAIT),
	246	* it should be present in the list io_ready_clients */
	247	redisAssert(ln != NULL);
	248	listDelNode(server.io_ready_clients,ln);
	249	} else {
	250	while (listLength(c->io_keys)) {
	251	ln = listFirst(c->io_keys);
	252	dontWaitForSwappedKey(c,ln->value);
	253	}
	254	}
	255	server.vm_blocked_clients--;
	256	}
	257	listRelease(c->io_keys);
	258	/* Master/slave cleanup */
	259	if (c->flags & REDIS_SLAVE) {
	260	if (c->replstate == REDIS_REPL_SEND_BULK && c->repldbfd != -1)
	261	close(c->repldbfd);
	262	list *l = (c->flags & REDIS_MONITOR) ? server.monitors : server.slaves;
	263	ln = listSearchKey(l,c);
	264	redisAssert(ln != NULL);
	265	listDelNode(l,ln);
	266	}
	267	if (c->flags & REDIS_MASTER) {
	268	server.master = NULL;
	269	server.replstate = REDIS_REPL_CONNECT;
	270	}
	271	/* Release memory */
	272	zfree(c->argv);
	273	zfree(c->mbargv);
	274	freeClientMultiState(c);
	275	zfree(c);
	276	}
	277
	278	#define GLUEREPLY_UP_TO (1024)
	279	static void glueReplyBuffersIfNeeded(redisClient *c) {
	280	int copylen = 0;
	281	char buf[GLUEREPLY_UP_TO];
	282	listNode *ln;
	283	listIter li;
	284	robj *o;
	285
	286	listRewind(c->reply,&li);
	287	while((ln = listNext(&li))) {
	288	int objlen;
	289
	290	o = ln->value;
	291	objlen = sdslen(o->ptr);
	292	if (copylen + objlen <= GLUEREPLY_UP_TO) {
	293	memcpy(buf+copylen,o->ptr,objlen);
	294	copylen += objlen;
	295	listDelNode(c->reply,ln);
	296	} else {
	297	if (copylen == 0) return;
	298	break;
	299	}
	300	}
	301	/* Now the output buffer is empty, add the new single element */
	302	o = createObject(REDIS_STRING,sdsnewlen(buf,copylen));
	303	listAddNodeHead(c->reply,o);
	304	}
	305
	306	void sendReplyToClient(aeEventLoop el, int fd, void privdata, int mask) {
	307	redisClient *c = privdata;
	308	int nwritten = 0, totwritten = 0, objlen;
	309	robj *o;
	310	REDIS_NOTUSED(el);
	311	REDIS_NOTUSED(mask);
	312
	313	/* Use writev() if we have enough buffers to send */
	314	if (!server.glueoutputbuf &&
	315	listLength(c->reply) > REDIS_WRITEV_THRESHOLD &&
	316	!(c->flags & REDIS_MASTER))
	317	{
	318	sendReplyToClientWritev(el, fd, privdata, mask);
	319	return;
	320	}
	321
	322	while(listLength(c->reply)) {
	323	if (server.glueoutputbuf && listLength(c->reply) > 1)
	324	glueReplyBuffersIfNeeded(c);
	325
	326	o = listNodeValue(listFirst(c->reply));
	327	objlen = sdslen(o->ptr);
	328
	329	if (objlen == 0) {
	330	listDelNode(c->reply,listFirst(c->reply));
	331	continue;
	332	}
	333
	334	if (c->flags & REDIS_MASTER) {
	335	/* Don't reply to a master */
	336	nwritten = objlen - c->sentlen;
	337	} else {
	338	nwritten = write(fd, ((char*)o->ptr)+c->sentlen, objlen - c->sentlen);
	339	if (nwritten <= 0) break;
	340	}
	341	c->sentlen += nwritten;
	342	totwritten += nwritten;
	343	/* If we fully sent the object on head go to the next one */
	344	if (c->sentlen == objlen) {
	345	listDelNode(c->reply,listFirst(c->reply));
	346	c->sentlen = 0;
	347	}
	348	/* Note that we avoid to send more thank REDIS_MAX_WRITE_PER_EVENT
	349	* bytes, in a single threaded server it's a good idea to serve
	350	* other clients as well, even if a very large request comes from
	351	* super fast link that is always able to accept data (in real world
	352	* scenario think about 'KEYS ' against the loopback interfae) /
	353	if (totwritten > REDIS_MAX_WRITE_PER_EVENT) break;
	354	}
	355	if (nwritten == -1) {
	356	if (errno == EAGAIN) {
	357	nwritten = 0;
	358	} else {
	359	redisLog(REDIS_VERBOSE,
	360	"Error writing to client: %s", strerror(errno));
	361	freeClient(c);
	362	return;
	363	}
	364	}
	365	if (totwritten > 0) c->lastinteraction = time(NULL);
	366	if (listLength(c->reply) == 0) {
	367	c->sentlen = 0;
	368	aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
	369	}
	370	}
	371
	372	void sendReplyToClientWritev(aeEventLoop el, int fd, void privdata, int mask)
	373	{
	374	redisClient *c = privdata;
	375	int nwritten = 0, totwritten = 0, objlen, willwrite;
	376	robj *o;
	377	struct iovec iov[REDIS_WRITEV_IOVEC_COUNT];
	378	int offset, ion = 0;
	379	REDIS_NOTUSED(el);
	380	REDIS_NOTUSED(mask);
	381
	382	listNode *node;
	383	while (listLength(c->reply)) {
	384	offset = c->sentlen;
	385	ion = 0;
	386	willwrite = 0;
	387
	388	/* fill-in the iov[] array */
	389	for(node = listFirst(c->reply); node; node = listNextNode(node)) {
	390	o = listNodeValue(node);
	391	objlen = sdslen(o->ptr);
	392
	393	if (totwritten + objlen - offset > REDIS_MAX_WRITE_PER_EVENT)
	394	break;
	395
	396	if(ion == REDIS_WRITEV_IOVEC_COUNT)
	397	break; /* no more iovecs */
	398
	399	iov[ion].iov_base = ((char*)o->ptr) + offset;
	400	iov[ion].iov_len = objlen - offset;
	401	willwrite += objlen - offset;
	402	offset = 0; /* just for the first item */
	403	ion++;
	404	}
	405
	406	if(willwrite == 0)
	407	break;
	408
	409	/* write all collected blocks at once */
	410	if((nwritten = writev(fd, iov, ion)) < 0) {
	411	if (errno != EAGAIN) {
	412	redisLog(REDIS_VERBOSE,
	413	"Error writing to client: %s", strerror(errno));
	414	freeClient(c);
	415	return;
	416	}
	417	break;
	418	}
	419
	420	totwritten += nwritten;
	421	offset = c->sentlen;
	422
	423	/* remove written robjs from c->reply */
	424	while (nwritten && listLength(c->reply)) {
	425	o = listNodeValue(listFirst(c->reply));
	426	objlen = sdslen(o->ptr);
	427
	428	if(nwritten >= objlen - offset) {
	429	listDelNode(c->reply, listFirst(c->reply));
	430	nwritten -= objlen - offset;
	431	c->sentlen = 0;
	432	} else {
	433	/* partial write */
	434	c->sentlen += nwritten;
	435	break;
	436	}
	437	offset = 0;
	438	}
	439	}
	440
	441	if (totwritten > 0)
	442	c->lastinteraction = time(NULL);
	443
	444	if (listLength(c->reply) == 0) {
	445	c->sentlen = 0;
	446	aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
	447	}
	448	}
	449
	450	/* resetClient prepare the client to process the next command */
	451	void resetClient(redisClient *c) {
	452	freeClientArgv(c);
	453	c->bulklen = -1;
	454	c->multibulk = 0;
	455	}
	456
	457	void closeTimedoutClients(void) {
	458	redisClient *c;
	459	listNode *ln;
	460	time_t now = time(NULL);
	461	listIter li;
	462
	463	listRewind(server.clients,&li);
	464	while ((ln = listNext(&li)) != NULL) {
	465	c = listNodeValue(ln);
	466	if (server.maxidletime &&
	467	!(c->flags & REDIS_SLAVE) && /* no timeout for slaves */
	468	!(c->flags & REDIS_MASTER) && /* no timeout for masters */
	469	dictSize(c->pubsub_channels) == 0 && /* no timeout for pubsub */
	470	listLength(c->pubsub_patterns) == 0 &&
	471	(now - c->lastinteraction > server.maxidletime))
	472	{
	473	redisLog(REDIS_VERBOSE,"Closing idle client");
	474	freeClient(c);
	475	} else if (c->flags & REDIS_BLOCKED) {
	476	if (c->blockingto != 0 && c->blockingto < now) {
	477	addReply(c,shared.nullmultibulk);
	478	unblockClientWaitingData(c);
	479	}
	480	}
	481	}
	482	}
	483
	484	void processInputBuffer(redisClient *c) {
	485	again:
	486	/* Before to process the input buffer, make sure the client is not
	487	* waitig for a blocking operation such as BLPOP. Note that the first
	488	* iteration the client is never blocked, otherwise the processInputBuffer
	489	* would not be called at all, but after the execution of the first commands
	490	* in the input buffer the client may be blocked, and the "goto again"
	491	* will try to reiterate. The following line will make it return asap. */
	492	if (c->flags & REDIS_BLOCKED \|\| c->flags & REDIS_IO_WAIT) return;
	493	if (c->bulklen == -1) {
	494	/* Read the first line of the query */
	495	char *p = strchr(c->querybuf,'\n');
	496	size_t querylen;
	497
	498	if (p) {
	499	sds query, *argv;
	500	int argc, j;
	501
	502	query = c->querybuf;
	503	c->querybuf = sdsempty();
	504	querylen = 1+(p-(query));
	505	if (sdslen(query) > querylen) {
	506	/* leave data after the first line of the query in the buffer */
	507	c->querybuf = sdscatlen(c->querybuf,query+querylen,sdslen(query)-querylen);
	508	}
	509	p = '\0'; / remove "\n" */
	510	if ((p-1) == '\r') (p-1) = '\0'; /* and "\r" if any */
	511	sdsupdatelen(query);
	512
	513	/* Now we can split the query in arguments */
	514	argv = sdssplitlen(query,sdslen(query)," ",1,&argc);
	515	sdsfree(query);
	516
	517	if (c->argv) zfree(c->argv);
	518	c->argv = zmalloc(sizeof(robj)argc);
	519
	520	for (j = 0; j < argc; j++) {
	521	if (sdslen(argv[j])) {
	522	c->argv[c->argc] = createObject(REDIS_STRING,argv[j]);
	523	c->argc++;
	524	} else {
	525	sdsfree(argv[j]);
	526	}
	527	}
	528	zfree(argv);
	529	if (c->argc) {
	530	/* Execute the command. If the client is still valid
	531	* after processCommand() return and there is something
	532	* on the query buffer try to process the next command. */
	533	if (processCommand(c) && sdslen(c->querybuf)) goto again;
	534	} else {
	535	/* Nothing to process, argc == 0. Just process the query
	536	* buffer if it's not empty or return to the caller */
	537	if (sdslen(c->querybuf)) goto again;
	538	}
	539	return;
	540	} else if (sdslen(c->querybuf) >= REDIS_REQUEST_MAX_SIZE) {
	541	redisLog(REDIS_VERBOSE, "Client protocol error");
	542	freeClient(c);
	543	return;
	544	}
	545	} else {
	546	/* Bulk read handling. Note that if we are at this point
	547	the client already sent a command terminated with a newline,
	548	we are reading the bulk data that is actually the last
	549	argument of the command. */
	550	int qbl = sdslen(c->querybuf);
	551
	552	if (c->bulklen <= qbl) {
	553	/* Copy everything but the final CRLF as final argument */
	554	c->argv[c->argc] = createStringObject(c->querybuf,c->bulklen-2);
	555	c->argc++;
	556	c->querybuf = sdsrange(c->querybuf,c->bulklen,-1);
	557	/* Process the command. If the client is still valid after
	558	* the processing and there is more data in the buffer
	559	* try to parse it. */
	560	if (processCommand(c) && sdslen(c->querybuf)) goto again;
	561	return;
	562	}
	563	}
	564	}
	565
	566	void readQueryFromClient(aeEventLoop el, int fd, void privdata, int mask) {
	567	redisClient c = (redisClient) privdata;
	568	char buf[REDIS_IOBUF_LEN];
	569	int nread;
	570	REDIS_NOTUSED(el);
	571	REDIS_NOTUSED(mask);
	572
	573	nread = read(fd, buf, REDIS_IOBUF_LEN);
	574	if (nread == -1) {
	575	if (errno == EAGAIN) {
	576	nread = 0;
	577	} else {
	578	redisLog(REDIS_VERBOSE, "Reading from client: %s",strerror(errno));
	579	freeClient(c);
	580	return;
	581	}
	582	} else if (nread == 0) {
	583	redisLog(REDIS_VERBOSE, "Client closed connection");
	584	freeClient(c);
	585	return;
	586	}
	587	if (nread) {
	588	c->querybuf = sdscatlen(c->querybuf, buf, nread);
	589	c->lastinteraction = time(NULL);
	590	} else {
	591	return;
	592	}
	593	processInputBuffer(c);
	594	}