#include "server.h"

#include "util.h"

#include "sha1.h" /* SHA1 is used for DEBUG DIGEST */

#include "crc64.h"

#include "bio.h"

#include "quicklist.h"

#include "fpconv_dtoa.h"

#include <arpa/inet.h>

#include <signal.h>

#include <dlfcn.h>

#include <fcntl.h>

#include <sys/mman.h>

#include <unistd.h>

#ifdef HAVE_BACKTRACE

#include <execinfo.h>

#ifndef __OpenBSD__

#include <ucontext.h>

typedef ucontext_t sigcontext_t;

#endif /* HAVE_BACKTRACE */

#ifdef __CYGWIN__

#ifndef SA_ONSTACK

#define SA_ONSTACK 0x08000000

#if defined(__APPLE__) && defined(__arm64__)

#include <mach/mach.h>

static int bug_report_start = 0; /* True if bug report header was already logged. */

static pthread_mutex_t bug_report_start_mutex = PTHREAD_MUTEX_INITIALIZER;

void bugReportStart(void);

void printCrashReport(void);

void bugReportEnd(int killViaSignal, int sig);

void logStackTrace(void *eip, int uplevel);

void xorDigest(unsigned char *digest, const void *ptr, size_t len) {

SHA1_CTX ctx;

unsigned char hash[20];

int j;

SHA1Init(&ctx);

SHA1Update(&ctx,ptr,len);

SHA1Final(hash,&ctx);

for (j = 0; j < 20; j++)

digest[j] ^= hash[j];

}

void xorStringObjectDigest(unsigned char *digest, robj *o) {

o = getDecodedObject(o);

xorDigest(digest,o->ptr,sdslen(o->ptr));

decrRefCount(o);

}

void mixDigest(unsigned char *digest, const void *ptr, size_t len) {

SHA1_CTX ctx;

xorDigest(digest,ptr,len);

SHA1Init(&ctx);

SHA1Update(&ctx,digest,20);

SHA1Final(digest,&ctx);

}

void mixStringObjectDigest(unsigned char *digest, robj *o) {

o = getDecodedObject(o);

mixDigest(digest,o->ptr,sdslen(o->ptr));

decrRefCount(o);

}

void xorObjectDigest(redisDb *db, robj *keyobj, unsigned char *digest, robj *o) {

uint32_t aux = htonl(o->type);

mixDigest(digest,&aux,sizeof(aux));

long long expiretime = getExpire(db,keyobj);

char buf[128];

/* Save the key and associated value */

if (o->type == OBJ_STRING) {

mixStringObjectDigest(digest,o);

} else if (o->type == OBJ_LIST) {

listTypeIterator *li = listTypeInitIterator(o,0,LIST_TAIL);

listTypeEntry entry;

while(listTypeNext(li,&entry)) {

robj *eleobj = listTypeGet(&entry);

mixStringObjectDigest(digest,eleobj);

decrRefCount(eleobj);

}

listTypeReleaseIterator(li);

} else if (o->type == OBJ_SET) {

setTypeIterator *si = setTypeInitIterator(o);

sds sdsele;

while((sdsele = setTypeNextObject(si)) != NULL) {

xorDigest(digest,sdsele,sdslen(sdsele));

sdsfree(sdsele);

}

setTypeReleaseIterator(si);

} else if (o->type == OBJ_ZSET) {

unsigned char eledigest[20];

if (o->encoding == OBJ_ENCODING_LISTPACK) {

unsigned char *zl = o->ptr;

unsigned char *eptr, *sptr;

unsigned char *vstr;

unsigned int vlen;

long long vll;

double score;

eptr = lpSeek(zl,0);

serverAssert(eptr != NULL);

sptr = lpNext(zl,eptr);

serverAssert(sptr != NULL);

while (eptr != NULL) {

vstr = lpGetValue(eptr,&vlen,&vll);

score = zzlGetScore(sptr);

memset(eledigest,0,20);

if (vstr != NULL) {

mixDigest(eledigest,vstr,vlen);

} else {

ll2string(buf,sizeof(buf),vll);

mixDigest(eledigest,buf,strlen(buf));

}

const int len = fpconv_dtoa(score, buf);

buf[len] = '\0';

mixDigest(eledigest,buf,strlen(buf));

xorDigest(digest,eledigest,20);

zzlNext(zl,&eptr,&sptr);

}

} else if (o->encoding == OBJ_ENCODING_SKIPLIST) {

zset *zs = o->ptr;

dictIterator *di = dictGetIterator(zs->dict);

dictEntry *de;

while((de = dictNext(di)) != NULL) {

sds sdsele = dictGetKey(de);

double *score = dictGetVal(de);

const int len = fpconv_dtoa(*score, buf);

buf[len] = '\0';

memset(eledigest,0,20);

mixDigest(eledigest,sdsele,sdslen(sdsele));

mixDigest(eledigest,buf,strlen(buf));

xorDigest(digest,eledigest,20);

}

dictReleaseIterator(di);

} else {

serverPanic("Unknown sorted set encoding");

}

} else if (o->type == OBJ_HASH) {

hashTypeIterator *hi = hashTypeInitIterator(o);

while (hashTypeNext(hi) != C_ERR) {

unsigned char eledigest[20];

sds sdsele;

memset(eledigest,0,20);

sdsele = hashTypeCurrentObjectNewSds(hi,OBJ_HASH_KEY);

mixDigest(eledigest,sdsele,sdslen(sdsele));

sdsfree(sdsele);

sdsele = hashTypeCurrentObjectNewSds(hi,OBJ_HASH_VALUE);

mixDigest(eledigest,sdsele,sdslen(sdsele));

sdsfree(sdsele);

xorDigest(digest,eledigest,20);

}

hashTypeReleaseIterator(hi);

} else if (o->type == OBJ_STREAM) {

streamIterator si;

streamIteratorStart(&si,o->ptr,NULL,NULL,0);

streamID id;

int64_t numfields;

while(streamIteratorGetID(&si,&id,&numfields)) {

sds itemid = sdscatfmt(sdsempty(),"%U.%U",id.ms,id.seq);

mixDigest(digest,itemid,sdslen(itemid));

sdsfree(itemid);

while(numfields--) {

unsigned char *field, *value;

int64_t field_len, value_len;

streamIteratorGetField(&si,&field,&value,

&field_len,&value_len);

mixDigest(digest,field,field_len);

mixDigest(digest,value,value_len);

}

}

streamIteratorStop(&si);

} else if (o->type == OBJ_MODULE) {

RedisModuleDigest md = {{0},{0},keyobj,db->id};

moduleValue *mv = o->ptr;

moduleType *mt = mv->type;

moduleInitDigestContext(md);

if (mt->digest) {

mt->digest(&md,mv->value);

xorDigest(digest,md.x,sizeof(md.x));

}

} else {

serverPanic("Unknown object type");

}

/* If the key has an expire, add it to the mix */

if (expiretime != -1) xorDigest(digest,"!!expire!!",10);

}

void computeDatasetDigest(unsigned char *final) {

unsigned char digest[20];

dictIterator *di = NULL;

dictEntry *de;

int j;

uint32_t aux;

memset(final,0,20); /* Start with a clean result */

for (j = 0; j < server.dbnum; j++) {

redisDb *db = server.db+j;

if (dictSize(db->dict) == 0) continue;

di = dictGetSafeIterator(db->dict);

/* hash the DB id, so the same dataset moved in a different

aux = htonl(j);

mixDigest(final,&aux,sizeof(aux));

/* Iterate this DB writing every entry */

while((de = dictNext(di)) != NULL) {

sds key;

robj *keyobj, *o;

memset(digest,0,20); /* This key-val digest */

key = dictGetKey(de);

keyobj = createStringObject(key,sdslen(key));

mixDigest(digest,key,sdslen(key));

o = dictGetVal(de);

xorObjectDigest(db,keyobj,digest,o);

/* We can finally xor the key-val digest to the final digest */

xorDigest(final,digest,20);

decrRefCount(keyobj);

}

dictReleaseIterator(di);

}

}

#ifdef USE_JEMALLOC

void mallctl_int(client *c, robj **argv, int argc) {

int ret;

/* start with the biggest size (int64), and if that fails, try smaller sizes (int32, bool) */

int64_t old = 0, val;

if (argc > 1) {

long long ll;

if (getLongLongFromObjectOrReply(c, argv[1], &ll, NULL) != C_OK)

return;

val = ll;

}

size_t sz = sizeof(old);

while (sz > 0) {

if ((ret=je_mallctl(argv[0]->ptr, &old, &sz, argc > 1? &val: NULL, argc > 1?sz: 0))) {

if (ret == EPERM && argc > 1) {

/* if this option is write only, try just writing to it. */

if (!(ret=je_mallctl(argv[0]->ptr, NULL, 0, &val, sz))) {

addReply(c, shared.ok);

return;

}

}

if (ret==EINVAL) {

/* size might be wrong, try a smaller one */

sz /= 2;

#if BYTE_ORDER == BIG_ENDIAN

val <<= 8*sz;

continue;

}

addReplyErrorFormat(c,"%s", strerror(ret));

return;

} else {

#if BYTE_ORDER == BIG_ENDIAN

old >>= 64 - 8*sz;

addReplyLongLong(c, old);

return;

}

}

addReplyErrorFormat(c,"%s", strerror(EINVAL));

}

void mallctl_string(client *c, robj **argv, int argc) {

int rret, wret;

char *old;

size_t sz = sizeof(old);

/* for strings, it seems we need to first get the old value, before overriding it. */

if ((rret=je_mallctl(argv[0]->ptr, &old, &sz, NULL, 0))) {

/* return error unless this option is write only. */

if (!(rret == EPERM && argc > 1)) {

addReplyErrorFormat(c,"%s", strerror(rret));

return;

}

}

if(argc > 1) {

char *val = argv[1]->ptr;

char **valref = &val;

if ((!strcmp(val,"VOID")))

valref = NULL, sz = 0;

wret = je_mallctl(argv[0]->ptr, NULL, 0, valref, sz);

}

if (!rret)

addReplyBulkCString(c, old);

else if (wret)

addReplyErrorFormat(c,"%s", strerror(wret));

else

addReply(c, shared.ok);

}

void debugCommand(client *c) {

if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"help")) {

const char *help[] = {

"AOF-FLUSH-SLEEP <microsec>",

" Server will sleep before flushing the AOF, this is used for testing.",

"ASSERT",

" Crash by assertion failed.",

"CHANGE-REPL-ID",

" Change the replication IDs of the instance.",

" Dangerous: should be used only for testing the replication subsystem.",

"CONFIG-REWRITE-FORCE-ALL",

" Like CONFIG REWRITE but writes all configuration options, including",

" keywords not listed in original configuration file or default values.",

"CRASH-AND-RECOVER [<milliseconds>]",

" Hard crash and restart after a <milliseconds> delay (default 0).",

"DIGEST",

" Output a hex signature representing the current DB content.",

"DIGEST-VALUE <key> [<key> ...]",

" Output a hex signature of the values of all the specified keys.",

"ERROR <string>",

" Return a Redis protocol error with <string> as message. Useful for clients",

" unit tests to simulate Redis errors.",

"LEAK <string>",

" Create a memory leak of the input string.",

"LOG <message>",

" Write <message> to the server log.",

"HTSTATS <dbid>",

" Return hash table statistics of the specified Redis database.",

"HTSTATS-KEY <key>",

" Like HTSTATS but for the hash table stored at <key>'s value.",

"LOADAOF",

" Flush the AOF buffers on disk and reload the AOF in memory.",

"REPLICATE <string>",

" Replicates the provided string to replicas, allowing data divergence.",

#ifdef USE_JEMALLOC

"MALLCTL <key> [<val>]",

" Get or set a malloc tuning integer.",

"MALLCTL-STR <key> [<val>]",

" Get or set a malloc tuning string.",

"OBJECT <key>",

" Show low level info about `key` and associated value.",

"DROP-CLUSTER-PACKET-FILTER <packet-type>",

" Drop all packets that match the filtered type. Set to -1 allow all packets.",

"OOM",

" Crash the server simulating an out-of-memory error.",

"PANIC",

" Crash the server simulating a panic.",

"POPULATE <count> [<prefix>] [<size>]",

" Create <count> string keys named key:<num>. If <prefix> is specified then",

" it is used instead of the 'key' prefix. These are not propagated to",

" replicas. Cluster slots are not respected so keys not belonging to the",

" current node can be created in cluster mode.",

"PROTOCOL <type>",

" Reply with a test value of the specified type. <type> can be: string,",

" integer, double, bignum, null, array, set, map, attrib, push, verbatim,",

" true, false.",

"RELOAD [option ...]",

" Save the RDB on disk and reload it back to memory. Valid <option> values:",

" * MERGE: conflicting keys will be loaded from RDB.",

" * NOFLUSH: the existing database will not be removed before load, but",

" conflicting keys will generate an exception and kill the server.",

" * NOSAVE: the database will be loaded from an existing RDB file.",

" Examples:",

" * DEBUG RELOAD: verify that the server is able to persist, flush and reload",

" the database.",

" * DEBUG RELOAD NOSAVE: replace the current database with the contents of an",

" existing RDB file.",

" * DEBUG RELOAD NOSAVE NOFLUSH MERGE: add the contents of an existing RDB",

" file to the database.",

"RESTART [<milliseconds>]",

" Graceful restart: save config, db, restart after a <milliseconds> delay (default 0).",

"SDSLEN <key>",

" Show low level SDS string info representing `key` and value.",

"SEGFAULT",

" Crash the server with sigsegv.",

"SET-ACTIVE-EXPIRE <0|1>",

" Setting it to 0 disables expiring keys in background when they are not",

" accessed (otherwise the Redis behavior). Setting it to 1 reenables back the",

" default.",

"QUICKLIST-PACKED-THRESHOLD <size>",

" Sets the threshold for elements to be inserted as plain vs packed nodes",

" Default value is 1GB, allows values up to 4GB. Setting to 0 restores to default.",

"SET-SKIP-CHECKSUM-VALIDATION <0|1>",

" Enables or disables checksum checks for RDB files and RESTORE's payload.",

"SLEEP <seconds>",

" Stop the server for <seconds>. Decimals allowed.",

"STRINGMATCH-TEST",

" Run a fuzz tester against the stringmatchlen() function.",

"STRUCTSIZE",

" Return the size of different Redis core C structures.",

"LISTPACK <key>",

" Show low level info about the listpack encoding of <key>.",

"QUICKLIST <key> [<0|1>]",

" Show low level info about the quicklist encoding of <key>.",

" The optional argument (0 by default) sets the level of detail",

"CLIENT-EVICTION",

" Show low level client eviction pools info (maxmemory-clients).",

"PAUSE-CRON <0|1>",

" Stop periodic cron job processing.",

"REPLYBUFFER PEAK-RESET-TIME <NEVER||RESET|time>",

" Sets the time (in milliseconds) to wait between client reply buffer peak resets.",

" In case NEVER is provided the last observed peak will never be reset",

" In case RESET is provided the peak reset time will be restored to the default value",

"REPLYBUFFER RESIZING <0|1>",

" Enable or disable the reply buffer resize cron job",

};

addReplyHelp(c, help);

} else if (!strcasecmp(c->argv[1]->ptr,"segfault")) {

/* Compiler gives warnings about writing to a random address

char* p = mmap(NULL, 4096, PROT_READ, MAP_PRIVATE | MAP_ANON, -1, 0);

*p = 'x';

} else if (!strcasecmp(c->argv[1]->ptr,"panic")) {

serverPanic("DEBUG PANIC called at Unix time %lld", (long long)time(NULL));

} else if (!strcasecmp(c->argv[1]->ptr,"restart") ||

!strcasecmp(c->argv[1]->ptr,"crash-and-recover"))

{

long long delay = 0;

if (c->argc >= 3) {

if (getLongLongFromObjectOrReply(c, c->argv[2], &delay, NULL)

!= C_OK) return;

if (delay < 0) delay = 0;

}

int flags = !strcasecmp(c->argv[1]->ptr,"restart") ?

(RESTART_SERVER_GRACEFULLY|RESTART_SERVER_CONFIG_REWRITE) :

RESTART_SERVER_NONE;

restartServer(flags,delay);

addReplyError(c,"failed to restart the server. Check server logs.");

} else if (!strcasecmp(c->argv[1]->ptr,"oom")) {

void *ptr = zmalloc(ULONG_MAX); /* Should trigger an out of memory. */

zfree(ptr);

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"assert")) {

serverAssertWithInfo(c,c->argv[0],1 == 2);

} else if (!strcasecmp(c->argv[1]->ptr,"log") && c->argc == 3) {

serverLog(LL_WARNING, "DEBUG LOG: %s", (char*)c->argv[2]->ptr);

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"leak") && c->argc == 3) {

sdsdup(c->argv[2]->ptr);

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"reload")) {

int flush = 1, save = 1;

int flags = RDBFLAGS_NONE;

/* Parse the additional options that modify the RELOAD

for (int j = 2; j < c->argc; j++) {

char *opt = c->argv[j]->ptr;

if (!strcasecmp(opt,"MERGE")) {

flags |= RDBFLAGS_ALLOW_DUP;

} else if (!strcasecmp(opt,"NOFLUSH")) {

flush = 0;

} else if (!strcasecmp(opt,"NOSAVE")) {

save = 0;

} else {

addReplyError(c,"DEBUG RELOAD only supports the "

"MERGE, NOFLUSH and NOSAVE options.");

return;

}

}

/* The default behavior is to save the RDB file before loading

if (save) {

rdbSaveInfo rsi, *rsiptr;

rsiptr = rdbPopulateSaveInfo(&rsi);

if (rdbSave(SLAVE_REQ_NONE,server.rdb_filename,rsiptr) != C_OK) {

addReplyErrorObject(c,shared.err);

return;

}

}

/* The default behavior is to remove the current dataset from

if (flush) emptyData(-1,EMPTYDB_NO_FLAGS,NULL);

protectClient(c);

int ret = rdbLoad(server.rdb_filename,NULL,flags);

unprotectClient(c);

if (ret != RDB_OK) {

addReplyError(c,"Error trying to load the RDB dump, check server logs.");

return;

}

serverLog(LL_WARNING,"DB reloaded by DEBUG RELOAD");

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"loadaof")) {

if (server.aof_state != AOF_OFF) flushAppendOnlyFile(1);

emptyData(-1,EMPTYDB_NO_FLAGS,NULL);

protectClient(c);

if (server.aof_manifest) aofManifestFree(server.aof_manifest);

aofLoadManifestFromDisk();

aofDelHistoryFiles();

int ret = loadAppendOnlyFiles(server.aof_manifest);

if (ret != AOF_OK && ret != AOF_EMPTY)

exit(1);

unprotectClient(c);

server.dirty = 0; /* Prevent AOF / replication */

serverLog(LL_WARNING,"Append Only File loaded by DEBUG LOADAOF");

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"drop-cluster-packet-filter") && c->argc == 3) {

long packet_type;

if (getLongFromObjectOrReply(c, c->argv[2], &packet_type, NULL) != C_OK)

return;

server.cluster_drop_packet_filter = packet_type;

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"object") && c->argc == 3) {

dictEntry *de;

robj *val;

char *strenc;

if ((de = dictFind(c->db->dict,c->argv[2]->ptr)) == NULL) {

addReplyErrorObject(c,shared.nokeyerr);

return;

}

val = dictGetVal(de);

strenc = strEncoding(val->encoding);

char extra[138] = {0};

if (val->encoding == OBJ_ENCODING_QUICKLIST) {

char *nextra = extra;

int remaining = sizeof(extra);

quicklist *ql = val->ptr;

/* Add number of quicklist nodes */

int used = snprintf(nextra, remaining, " ql_nodes:%lu", ql->len);

nextra += used;

remaining -= used;

/* Add average quicklist fill factor */

double avg = (double)ql->count/ql->len;

used = snprintf(nextra, remaining, " ql_avg_node:%.2f", avg);

nextra += used;

remaining -= used;

/* Add quicklist fill level / max listpack size */

used = snprintf(nextra, remaining, " ql_listpack_max:%d", ql->fill);

nextra += used;

remaining -= used;

/* Add isCompressed? */

int compressed = ql->compress != 0;

used = snprintf(nextra, remaining, " ql_compressed:%d", compressed);

nextra += used;

remaining -= used;

/* Add total uncompressed size */

unsigned long sz = 0;

for (quicklistNode *node = ql->head; node; node = node->next) {

sz += node->sz;

}

used = snprintf(nextra, remaining, " ql_uncompressed_size:%lu", sz);

nextra += used;

remaining -= used;

}

addReplyStatusFormat(c,

"Value at:%p refcount:%d "

"encoding:%s serializedlength:%zu "

"lru:%d lru_seconds_idle:%llu%s",

(void*)val, val->refcount,

strenc, rdbSavedObjectLen(val, c->argv[2], c->db->id),

val->lru, estimateObjectIdleTime(val)/1000, extra);

} else if (!strcasecmp(c->argv[1]->ptr,"sdslen") && c->argc == 3) {

dictEntry *de;

robj *val;

sds key;

if ((de = dictFind(c->db->dict,c->argv[2]->ptr)) == NULL) {

addReplyErrorObject(c,shared.nokeyerr);

return;

}

val = dictGetVal(de);

key = dictGetKey(de);

if (val->type != OBJ_STRING || !sdsEncodedObject(val)) {

addReplyError(c,"Not an sds encoded string.");

} else {

addReplyStatusFormat(c,

"key_sds_len:%lld, key_sds_avail:%lld, key_zmalloc: %lld, "

"val_sds_len:%lld, val_sds_avail:%lld, val_zmalloc: %lld",

(long long) sdslen(key),

(long long) sdsavail(key),

(long long) sdsZmallocSize(key),

(long long) sdslen(val->ptr),

(long long) sdsavail(val->ptr),

(long long) getStringObjectSdsUsedMemory(val));

}

} else if (!strcasecmp(c->argv[1]->ptr,"listpack") && c->argc == 3) {

robj *o;

if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nokeyerr))

== NULL) return;

if (o->encoding != OBJ_ENCODING_LISTPACK) {

addReplyError(c,"Not a listpack encoded object.");

} else {

lpRepr(o->ptr);

addReplyStatus(c,"Listpack structure printed on stdout");

}

} else if (!strcasecmp(c->argv[1]->ptr,"quicklist") && (c->argc == 3 || c->argc == 4)) {

robj *o;

if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nokeyerr))

== NULL) return;

int full = 0;

if (c->argc == 4)

full = atoi(c->argv[3]->ptr);

if (o->encoding != OBJ_ENCODING_QUICKLIST) {

addReplyError(c,"Not a quicklist encoded object.");

} else {

quicklistRepr(o->ptr, full);

addReplyStatus(c,"Quicklist structure printed on stdout");

}

} else if (!strcasecmp(c->argv[1]->ptr,"populate") &&

c->argc >= 3 && c->argc <= 5) {

long keys, j;

robj *key, *val;

char buf[128];

if (getPositiveLongFromObjectOrReply(c, c->argv[2], &keys, NULL) != C_OK)

return;

dictExpand(c->db->dict,keys);

long valsize = 0;

if ( c->argc == 5 && getPositiveLongFromObjectOrReply(c, c->argv[4], &valsize, NULL) != C_OK )

return;

for (j = 0; j < keys; j++) {

snprintf(buf,sizeof(buf),"%s:%lu",

(c->argc == 3) ? "key" : (char*)c->argv[3]->ptr, j);

key = createStringObject(buf,strlen(buf));

if (lookupKeyWrite(c->db,key) != NULL) {

decrRefCount(key);

continue;

}

snprintf(buf,sizeof(buf),"value:%lu",j);

if (valsize==0)

val = createStringObject(buf,strlen(buf));

else {

int buflen = strlen(buf);

val = createStringObject(NULL,valsize);

memcpy(val->ptr, buf, valsize<=buflen? valsize: buflen);

}

dbAdd(c->db,key,val);

signalModifiedKey(c,c->db,key);

decrRefCount(key);

}

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"digest") && c->argc == 2) {

/* DEBUG DIGEST (form without keys specified) */

unsigned char digest[20];

sds d = sdsempty();

computeDatasetDigest(digest);

for (int i = 0; i < 20; i++) d = sdscatprintf(d, "%02x",digest[i]);

addReplyStatus(c,d);

sdsfree(d);

} else if (!strcasecmp(c->argv[1]->ptr,"digest-value") && c->argc >= 2) {

/* DEBUG DIGEST-VALUE key key key ... key. */

addReplyArrayLen(c,c->argc-2);

for (int j = 2; j < c->argc; j++) {

unsigned char digest[20];

memset(digest,0,20); /* Start with a clean result */

/* We don't use lookupKey because a debug command should

dictEntry *de;

robj *o = ((de = dictFind(c->db->dict,c->argv[j]->ptr)) == NULL) ? NULL : dictGetVal(de);

if (o) xorObjectDigest(c->db,c->argv[j],digest,o);

sds d = sdsempty();

for (int i = 0; i < 20; i++) d = sdscatprintf(d, "%02x",digest[i]);

addReplyStatus(c,d);

sdsfree(d);

}

} else if (!strcasecmp(c->argv[1]->ptr,"protocol") && c->argc == 3) {

/* DEBUG PROTOCOL [string|integer|double|bignum|null|array|set|map|

char *name = c->argv[2]->ptr;

if (!strcasecmp(name,"string")) {

addReplyBulkCString(c,"Hello World");

} else if (!strcasecmp(name,"integer")) {

addReplyLongLong(c,12345);

} else if (!strcasecmp(name,"double")) {

addReplyDouble(c,3.141);

} else if (!strcasecmp(name,"bignum")) {

addReplyBigNum(c,"1234567999999999999999999999999999999",37);

} else if (!strcasecmp(name,"null")) {

addReplyNull(c);

} else if (!strcasecmp(name,"array")) {

addReplyArrayLen(c,3);

for (int j = 0; j < 3; j++) addReplyLongLong(c,j);

} else if (!strcasecmp(name,"set")) {

addReplySetLen(c,3);

for (int j = 0; j < 3; j++) addReplyLongLong(c,j);

} else if (!strcasecmp(name,"map")) {

addReplyMapLen(c,3);

for (int j = 0; j < 3; j++) {

addReplyLongLong(c,j);

addReplyBool(c, j == 1);

}

} else if (!strcasecmp(name,"attrib")) {

if (c->resp >= 3) {

addReplyAttributeLen(c,1);

addReplyBulkCString(c,"key-popularity");

addReplyArrayLen(c,2);

addReplyBulkCString(c,"key:123");

addReplyLongLong(c,90);

}

/* Attributes are not real replies, so a well formed reply should

addReplyBulkCString(c,"Some real reply following the attribute");

} else if (!strcasecmp(name,"push")) {

if (c->resp < 3) {

addReplyError(c,"RESP2 is not supported by this command");

return;

}

addReplyPushLen(c,2);

addReplyBulkCString(c,"server-cpu-usage");

addReplyLongLong(c,42);

/* Push replies are not synchronous replies, so we emit also a

addReplyBulkCString(c,"Some real reply following the push reply");

} else if (!strcasecmp(name,"true")) {

addReplyBool(c,1);

} else if (!strcasecmp(name,"false")) {

addReplyBool(c,0);

} else if (!strcasecmp(name,"verbatim")) {

addReplyVerbatim(c,"This is a verbatim\nstring",25,"txt");

} else {

addReplyError(c,"Wrong protocol type name. Please use one of the following: string|integer|double|bignum|null|array|set|map|attrib|push|verbatim|true|false");

}

} else if (!strcasecmp(c->argv[1]->ptr,"sleep") && c->argc == 3) {

double dtime = strtod(c->argv[2]->ptr,NULL);

long long utime = dtime*1000000;

struct timespec tv;

tv.tv_sec = utime / 1000000;

tv.tv_nsec = (utime % 1000000) * 1000;

nanosleep(&tv, NULL);

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"set-active-expire") &&

c->argc == 3)

{

server.active_expire_enabled = atoi(c->argv[2]->ptr);

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"quicklist-packed-threshold") &&

c->argc == 3)

{

int memerr;

unsigned long long sz = memtoull((const char *)c->argv[2]->ptr, &memerr);

if (memerr || !quicklistisSetPackedThreshold(sz)) {

addReplyError(c, "argument must be a memory value bigger than 1 and smaller than 4gb");

} else {

addReply(c,shared.ok);

}

} else if (!strcasecmp(c->argv[1]->ptr,"set-skip-checksum-validation") &&

c->argc == 3)

{

server.skip_checksum_validation = atoi(c->argv[2]->ptr);

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"aof-flush-sleep") &&

c->argc == 3)

{

server.aof_flush_sleep = atoi(c->argv[2]->ptr);

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"replicate") && c->argc >= 3) {

replicationFeedSlaves(server.slaves, -1,

c->argv + 2, c->argc - 2);

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"error") && c->argc == 3) {

sds errstr = sdsnewlen("-",1);

errstr = sdscatsds(errstr,c->argv[2]->ptr);

errstr = sdsmapchars(errstr,"\n\r"," ",2); /* no newlines in errors. */

errstr = sdscatlen(errstr,"\r\n",2);

addReplySds(c,errstr);

} else if (!strcasecmp(c->argv[1]->ptr,"structsize") && c->argc == 2) {

sds sizes = sdsempty();

sizes = sdscatprintf(sizes,"bits:%d ",(sizeof(void*) == 8)?64:32);

sizes = sdscatprintf(sizes,"robj:%d ",(int)sizeof(robj));

sizes = sdscatprintf(sizes,"dictentry:%d ",(int)sizeof(dictEntry));

sizes = sdscatprintf(sizes,"sdshdr5:%d ",(int)sizeof(struct sdshdr5));

sizes = sdscatprintf(sizes,"sdshdr8:%d ",(int)sizeof(struct sdshdr8));

sizes = sdscatprintf(sizes,"sdshdr16:%d ",(int)sizeof(struct sdshdr16));

sizes = sdscatprintf(sizes,"sdshdr32:%d ",(int)sizeof(struct sdshdr32));

sizes = sdscatprintf(sizes,"sdshdr64:%d ",(int)sizeof(struct sdshdr64));

addReplyBulkSds(c,sizes);

} else if (!strcasecmp(c->argv[1]->ptr,"htstats") && c->argc == 3) {

long dbid;

sds stats = sdsempty();

char buf[4096];

if (getLongFromObjectOrReply(c, c->argv[2], &dbid, NULL) != C_OK) {

sdsfree(stats);

return;

}

if (dbid < 0 || dbid >= server.dbnum) {

sdsfree(stats);

addReplyError(c,"Out of range database");

return;

}

stats = sdscatprintf(stats,"[Dictionary HT]\n");

dictGetStats(buf,sizeof(buf),server.db[dbid].dict);

stats = sdscat(stats,buf);

stats = sdscatprintf(stats,"[Expires HT]\n");

dictGetStats(buf,sizeof(buf),server.db[dbid].expires);

stats = sdscat(stats,buf);

addReplyVerbatim(c,stats,sdslen(stats),"txt");

sdsfree(stats);

} else if (!strcasecmp(c->argv[1]->ptr,"htstats-key") && c->argc == 3) {

robj *o;

dict *ht = NULL;

if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nokeyerr))

== NULL) return;

/* Get the hash table reference from the object, if possible. */

switch (o->encoding) {

case OBJ_ENCODING_SKIPLIST:

{

zset *zs = o->ptr;

ht = zs->dict;

}

break;

case OBJ_ENCODING_HT:

ht = o->ptr;

break;

}

if (ht == NULL) {

addReplyError(c,"The value stored at the specified key is not "

"represented using an hash table");

} else {

char buf[4096];

dictGetStats(buf,sizeof(buf),ht);

addReplyVerbatim(c,buf,strlen(buf),"txt");

}

} else if (!strcasecmp(c->argv[1]->ptr,"change-repl-id") && c->argc == 2) {

serverLog(LL_WARNING,"Changing replication IDs after receiving DEBUG change-repl-id");

changeReplicationId();

clearReplicationId2();

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"stringmatch-test") && c->argc == 2)

{

stringmatchlen_fuzz_test();

addReplyStatus(c,"Apparently Redis did not crash: test passed");

} else if (!strcasecmp(c->argv[1]->ptr,"set-disable-deny-scripts") && c->argc == 3)

{

server.script_disable_deny_script = atoi(c->argv[2]->ptr);

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"config-rewrite-force-all") && c->argc == 2)

{

if (rewriteConfig(server.configfile, 1) == -1)

addReplyErrorFormat(c, "CONFIG-REWRITE-FORCE-ALL failed: %s", strerror(errno));

else

addReply(c, shared.ok);

} else if(!strcasecmp(c->argv[1]->ptr,"client-eviction") && c->argc == 2) {

if (!server.client_mem_usage_buckets) {

addReplyError(c,"maxmemory-clients is disabled.");

return;

}

sds bucket_info = sdsempty();

for (int j = 0; j < CLIENT_MEM_USAGE_BUCKETS; j++) {

if (j == 0)

bucket_info = sdscatprintf(bucket_info, "bucket 0");

else

bucket_info = sdscatprintf(bucket_info, "bucket %10zu", (size_t)1<<(j-1+CLIENT_MEM_USAGE_BUCKET_MIN_LOG));

if (j == CLIENT_MEM_USAGE_BUCKETS-1)

bucket_info = sdscatprintf(bucket_info, "+ : ");

else

bucket_info = sdscatprintf(bucket_info, " - %10zu: ", ((size_t)1<<(j+CLIENT_MEM_USAGE_BUCKET_MIN_LOG))-1);

bucket_info = sdscatprintf(bucket_info, "tot-mem: %10zu, clients: %lu\n",

server.client_mem_usage_buckets[j].mem_usage_sum,

server.client_mem_usage_buckets[j].clients->len);

}

addReplyVerbatim(c,bucket_info,sdslen(bucket_info),"txt");

sdsfree(bucket_info);

#ifdef USE_JEMALLOC

} else if(!strcasecmp(c->argv[1]->ptr,"mallctl") && c->argc >= 3) {

mallctl_int(c, c->argv+2, c->argc-2);

return;

} else if(!strcasecmp(c->argv[1]->ptr,"mallctl-str") && c->argc >= 3) {

mallctl_string(c, c->argv+2, c->argc-2);

return;

} else if (!strcasecmp(c->argv[1]->ptr,"pause-cron") && c->argc == 3)

{

server.pause_cron = atoi(c->argv[2]->ptr);

addReply(c,shared.ok);

} else if (!strcasecmp(c->argv[1]->ptr,"replybuffer") && c->argc == 4 ) {

if(!strcasecmp(c->argv[2]->ptr, "peak-reset-time")) {

if (!strcasecmp(c->argv[3]->ptr, "never")) {

server.reply_buffer_peak_reset_time = -1;

} else if(!strcasecmp(c->argv[3]->ptr, "reset")) {

server.reply_buffer_peak_reset_time = REPLY_BUFFER_DEFAULT_PEAK_RESET_TIME;

} else {

if (getLongFromObjectOrReply(c, c->argv[3], &server.reply_buffer_peak_reset_time, NULL) != C_OK)

return;

}

} else if(!strcasecmp(c->argv[2]->ptr,"resizing")) {

server.reply_buffer_resizing_enabled = atoi(c->argv[3]->ptr);

} else {

addReplySubcommandSyntaxError(c);

return;

}

addReply(c, shared.ok);

} else {

addReplySubcommandSyntaxError(c);