SHA1_CTX ctx;

unsigned char hash[20];

const unsigned char *s = (const unsigned char*)ptr;

int j;

SHA1Init(&ctx);

SHA1Update(&ctx,s,len);

SHA1Final(hash,&ctx);

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

digest[j] ^= hash[j];

o = getDecodedObject(o);

xorDigest(digest,(const unsigned char*)ptrFromObj(o),sdslen(szFromObj(o)));

decrRefCount(o);

SHA1_CTX ctx;

const char *s = (const char*)ptr;

xorDigest(digest,s,len);

SHA1Init(&ctx);

SHA1Update(&ctx,digest,20);

SHA1Final(digest,&ctx);

o = getDecodedObject(o);

mixDigest(digest,ptrFromObj(o),sdslen(szFromObj(o)));

decrRefCount(o);

uint32_t aux = htonl(o->type);

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

expireEntry *pexpire = getExpire(db,keyobj);

long long expiretime = -1;

char buf[128];

if (pexpire != nullptr)

pexpire->FGetPrimaryExpire(&expiretime);

/* 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_ZIPLIST) {

unsigned char *zl = (unsigned char*)ptrFromObj(o);

unsigned char *eptr, *sptr;

unsigned char *vstr;

unsigned int vlen;

long long vll;

double score;

eptr = ziplistIndex(zl,0);

serverAssert(eptr != NULL);

sptr = ziplistNext(zl,eptr);

serverAssert(sptr != NULL);

while (eptr != NULL) {

serverAssert(ziplistGet(eptr,&vstr,&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));

}

snprintf(buf,sizeof(buf),"%.17g",score);

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

xorDigest(digest,eledigest,20);

zzlNext(zl,&eptr,&sptr);

}

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

zset *zs = (zset*)ptrFromObj(o);

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

dictEntry *de;

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

sds sdsele = (sds)dictGetKey(de);

double *score = (double*)dictGetVal(de);

snprintf(buf,sizeof(buf),"%.17g",*score);

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,(stream*)ptrFromObj(o),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;

moduleValue *mv = (moduleValue*)ptrFromObj(o);

moduleType *mt = mv->type;

moduleInitDigestContext(md);

if (mt->digest) {

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

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

}

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

cronjob *job = (cronjob*)ptrFromObj(o);

mixDigest(digest, &job->interval, sizeof(job->interval));

mixDigest(digest, job->script.get(), job->script.size());

} else {

serverPanic("Unknown object type");

}

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

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

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 < cserver.dbnum; j++) {

redisDb *db = g_pserver->db+j;

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

di = dictGetSafeIterator(db->pdict);

/* 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 = (sds)dictGetKey(de);

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

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

o = (robj*)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);

}

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(szFromObj(argv[0]), &old, &sz, argc > 1? &val: NULL, argc > 1?sz: 0))) {

if (ret==EINVAL) {

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

sz /= 2;

#if BYTE_ORDER == BIG_ENDIAN

val <<= 8*sz;

#endif

continue;

}

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

return;

} else {

#if BYTE_ORDER == BIG_ENDIAN

old >>= 64 - 8*sz;

#endif

addReplyLongLong(c, old);

return;

}

}

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

int ret;

char *old;

size_t sz = sizeof(old);

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

if ((ret=je_mallctl(szFromObj(argv[0]), &old, &sz, NULL, 0))) {

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

return;

}

addReplyBulkCString(c, old);

if(argc > 1)

je_mallctl(szFromObj(argv[0]), NULL, 0, &argv[1]->m_ptr, sizeof(char*));

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

const char *help[] = {

"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.",

"CRASH-AND-RECOVER <milliseconds> -- Hard crash and restart after <milliseconds> delay.",

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

"DIGEST-VALUE <key-1> ... <key-N>-- Output a hex signature of the values of all the specified keys.",

"DEBUG PROTOCOL [string|integer|double|bignum|null|array|set|map|attrib|push|verbatim|true|false]",

"ERROR <string> -- Return a Redis protocol error with <string> as message. Useful for clients unit tests to simulate Redis errors.",

"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 as key's value.",

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

"LUA-ALWAYS-REPLICATE-COMMANDS <0|1> -- Setting it to 1 makes Lua replication defaulting to replicating single commands, without the script having to enable effects replication.",

"OBJECT <key> -- Show low level info about key and associated value.",

"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 a prefix is specified is used instead of the 'key' prefix.",

"RELOAD -- Save the RDB on disk and reload it back in memory.",

"RESTART -- Graceful restart: save config, db, restart.",

"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.",

"AOF-FLUSH-SLEEP <microsec> -- Server will sleep before flushing the AOF, this is used for testing",

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

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

"ZIPLIST <key> -- Show low level info about the ziplist encoding.",

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

#ifdef USE_JEMALLOC

"MALLCTL <key> [<val>] -- Get or set a malloc tunning integer.",

"MALLCTL-STR <key> [<val>] -- Get or set a malloc tunning string.",

#endif

};

addReplyHelp(c, help);

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

*((char*)-1) = 'x';

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

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

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

!strcasecmp(szFromObj(c->argv[1]),"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(szFromObj(c->argv[1]),"restart") ?

(RESTART_SERVER_GRACEFULLY|RESTART_SERVER_CONFIG_REWRITE) :

RESTART_SERVER_NONE;

restartServer(flags,delay);

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

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

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

zfree(ptr);

addReply(c,shared.ok);

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

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

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

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

addReply(c,shared.ok);

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

rdbSaveInfo rsi, *rsiptr;

rsiptr = rdbPopulateSaveInfo(&rsi);

if (rdbSave(rsiptr) != C_OK) {

addReply(c,shared.err);

return;

}

emptyDb(-1,EMPTYDB_NO_FLAGS,NULL);

protectClient(c);

int ret = rdbLoadFile(g_pserver->rdb_filename,NULL,RDBFLAGS_NONE);

unprotectClient(c);

if (ret != C_OK) {

addReplyError(c,"Error trying to load the RDB dump");

return;

}

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

addReply(c,shared.ok);

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

if (g_pserver->aof_state != AOF_OFF) flushAppendOnlyFile(1);

emptyDb(-1,EMPTYDB_NO_FLAGS,NULL);

protectClient(c);

int ret = loadAppendOnlyFile(g_pserver->aof_filename);

unprotectClient(c);

if (ret != C_OK) {

addReply(c,shared.err);

return;

}

g_pserver->dirty = 0; /* Prevent AOF / replication */

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

addReply(c,shared.ok);

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

dictEntry *de;

robj *val;

const char *strenc;

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

addReply(c,shared.nokeyerr);

return;

}

val = (robj*)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 = (quicklist*)val->m_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 ziplist size */

used = snprintf(nextra, remaining, " ql_ziplist_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, static_cast<int>(val->getrefcount(std::memory_order_relaxed)),

strenc, rdbSavedObjectLen(val),

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

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

dictEntry *de;

robj *val;

sds key;

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

addReply(c,shared.nokeyerr);

return;

}

val = (robj*)dictGetVal(de);

key = (sds)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(szFromObj(val)),

(long long) sdsavail(szFromObj(val)),

(long long) getStringObjectSdsUsedMemory(val));

}

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

robj *o;

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

== NULL) return;

if (o->encoding != OBJ_ENCODING_ZIPLIST) {

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

} else {

ziplistRepr((unsigned char*)ptrFromObj(o));

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

}

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

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

long keys, j;

robj *key, *val;

char buf[128];

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

return;

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

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

long valsize = 0;

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

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

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

if (c->argc == 5)

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

return;

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(ptrFromObj(val), buf, valsize<=buflen? valsize: buflen);

}

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

signalModifiedKey(c->db,key);

decrRefCount(key);

}

addReply(c,shared.ok);

} else if (!strcasecmp(szFromObj(c->argv[1]),"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(szFromObj(c->argv[1]),"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 */

robj_roptr o = lookupKeyReadWithFlags(c->db,c->argv[j],LOOKUP_NOTOUCH);

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(szFromObj(c->argv[1]),"protocol") && c->argc == 3) {

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

const char *name = szFromObj(c->argv[2]);

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

addReplyBulkCString(c,"Hello World");

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

addReplyLongLong(c,12345);

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

addReplyDouble(c,3.14159265359);

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

addReplyProto(c,"(1234567999999999999999999999999999999\r\n",40);

} 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")) {

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")) {

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(szFromObj(c->argv[1]),"sleep") && c->argc == 3) {

double dtime = strtod(szFromObj(c->argv[2]),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(szFromObj(c->argv[1]),"set-active-expire") &&

c->argc == 3)

{

g_pserver->active_expire_enabled = atoi(szFromObj(c->argv[2]));

addReply(c,shared.ok);

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

c->argc == 3)

{

g_pserver->aof_flush_sleep = atoi(szFromObj(c->argv[2]));

addReply(c,shared.ok);

} else if (!strcasecmp(szFromObj(c->argv[1]),"lua-always-replicate-commands") &&

c->argc == 3)

{

g_pserver->lua_always_replicate_commands = atoi(szFromObj(c->argv[2]));

addReply(c,shared.ok);

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

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

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

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

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

addReplySds(c,errstr);

} else if (!strcasecmp(szFromObj(c->argv[1]),"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(szFromObj(c->argv[1]),"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 >= cserver.dbnum) {

sdsfree(stats);

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

return;

}

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

dictGetStats(buf,sizeof(buf),g_pserver->db[dbid].pdict);

stats = sdscat(stats,buf);

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

g_pserver->db[dbid].setexpire->getstats(buf, sizeof(buf));

stats = sdscat(stats, buf);

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

sdsfree(stats);

} else if (!strcasecmp(szFromObj(c->argv[1]),"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 = (zset*)ptrFromObj(o);

ht = zs->pdict;

}

break;

case OBJ_ENCODING_HT:

ht = (dict*)ptrFromObj(o);

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(szFromObj(c->argv[1]),"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(szFromObj(c->argv[1]),"stringmatch-test") && c->argc == 2) {

stringmatchlen_fuzz_test();

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

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

c->flags |= CLIENT_MASTER | CLIENT_MASTER_FORCE_REPLY;

if (!strcasecmp(szFromObj(c->argv[2]), "yes"))

{

redisMaster *mi = (redisMaster*)zcalloc(sizeof(redisMaster), MALLOC_LOCAL);

mi->master = c;

listAddNodeHead(g_pserver->masters, mi);

}

else if (strcasecmp(szFromObj(c->argv[2]), "flagonly")) // if we didn't set flagonly assume its an unset

{

serverAssert(c->flags & CLIENT_MASTER);

if (listLength(g_pserver->masters))

{

redisMaster *mi = (redisMaster*)listNodeValue(listFirst(g_pserver->masters));

serverAssert(mi->master == c);

listDelNode(g_pserver->masters, listFirst(g_pserver->masters));

zfree(mi);

}

c->flags &= ~(CLIENT_MASTER | CLIENT_MASTER_FORCE_REPLY);

}

addReply(c, shared.ok);

#ifdef USE_JEMALLOC

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

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

return;

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

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

return;

#endif

} else {

addReplySubcommandSyntaxError(c);

return;

}

bugReportStart();

serverLog(LL_WARNING,"=== ASSERTION FAILED ===");

serverLog(LL_WARNING,"==> %s:%d '%s' is not true",file,line,estr);

#ifdef HAVE_BACKTRACE

g_pserver->assert_failed = estr;

g_pserver->assert_file = file;

g_pserver->assert_line = line;

serverLog(LL_WARNING,"(forcing SIGSEGV to print the bug report.)");

#endif

*((char*)-1) = 'x';

int j;

char conninfo[CONN_INFO_LEN];

bugReportStart();

serverLog(LL_WARNING,"=== ASSERTION FAILED CLIENT CONTEXT ===");

serverLog(LL_WARNING,"client->flags = %llu", (unsigned long long) c->flags);

serverLog(LL_WARNING,"client->conn = %s", connGetInfo(c->conn, conninfo, sizeof(conninfo)));

serverLog(LL_WARNING,"client->argc = %d", c->argc);

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

char buf[128];

char *arg;

if (c->argv[j]->type == OBJ_STRING && sdsEncodedObject(c->argv[j])) {

arg = (char*) ptrFromObj(c->argv[j]);

} else {

snprintf(buf,sizeof(buf),"Object type: %u, encoding: %u",

c->argv[j]->type, c->argv[j]->encoding);

arg = buf;

}

serverLog(LL_WARNING,"client->argv[%d] = \"%s\" (refcount: %d)",

j, arg, static_cast<int>(c->argv[j]->getrefcount(std::memory_order_relaxed)));

}

serverLog(LL_WARNING,"Object type: %d", o->type);

serverLog(LL_WARNING,"Object encoding: %d", o->encoding);

serverLog(LL_WARNING,"Object refcount: %d", static_cast<int>(o->getrefcount(std::memory_order_relaxed)));

if (o->type == OBJ_STRING && sdsEncodedObject(o)) {

serverLog(LL_WARNING,"Object raw string len: %zu", sdslen(szFromObj(o)));

if (sdslen(szFromObj(o)) < 4096) {

sds repr = sdscatrepr(sdsempty(),szFromObj(o),sdslen(szFromObj(o)));

serverLog(LL_WARNING,"Object raw string content: %s", repr);

sdsfree(repr);

}

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

serverLog(LL_WARNING,"List length: %d", (int) listTypeLength(o));

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

serverLog(LL_WARNING,"Set size: %d", (int) setTypeSize(o));

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

serverLog(LL_WARNING,"Hash size: %d", (int) hashTypeLength(o));

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

serverLog(LL_WARNING,"Sorted set size: %d", (int) zsetLength(o));

if (o->encoding == OBJ_ENCODING_SKIPLIST)

serverLog(LL_WARNING,"Skiplist level: %d", (int) ((const zset*)ptrFromObj(o))->zsl->level);

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

serverLog(LL_WARNING,"Stream size: %d", (int) streamLength(o));

}

bugReportStart();

serverLog(LL_WARNING,"=== ASSERTION FAILED OBJECT CONTEXT ===");

serverLogObjectDebugInfo(o);

if (c) _serverAssertPrintClientInfo(c);

if (o) _serverAssertPrintObject(o);

_serverAssert(estr,file,line);

va_list ap;

va_start(ap,msg);

char fmtmsg[256];

vsnprintf(fmtmsg,sizeof(fmtmsg),msg,ap);

va_end(ap);

bugReportStart();

serverLog(LL_WARNING,"------------------------------------------------");

serverLog(LL_WARNING,"!!! Software Failure. Press left mouse button to continue");

serverLog(LL_WARNING,"Guru Meditation: %s #%s:%d",fmtmsg,file,line);

#ifdef HAVE_BACKTRACE

serverLog(LL_WARNING,"(forcing SIGSEGV in order to print the stack trace)");

#endif

serverLog(LL_WARNING,"------------------------------------------------");

*((char*)-1) = 'x';

if (g_pserver->bug_report_start == 0) {

serverLogRaw(LL_WARNING|LL_RAW,

"\n\n=== KEYDB BUG REPORT START: Cut & paste starting from here ===\n");

g_pserver->bug_report_start = 1;

}

int i;

for (i = 15; i >= 0; i--) {

unsigned long addr = (unsigned long) sp+i;

unsigned long val = (unsigned long) sp[i];

if (sizeof(long) == 4)

serverLog(LL_WARNING, "(%08lx) -> %08lx", addr, val);

else

serverLog(LL_WARNING, "(%016lx) -> %016lx", addr, val);

}

serverLog(LL_WARNING|LL_RAW, "\n------ REGISTERS ------\n");

#if defined(__APPLE__) && defined(MAC_OS_X_VERSION_10_6)

/* OSX AMD64 */

#if defined(_STRUCT_X86_THREAD_STATE64) && !defined(__i386__)

serverLog(LL_WARNING,

"\n"

"RAX:%016lx RBX:%016lx\nRCX:%016lx RDX:%016lx\n"

"RDI:%016lx RSI:%016lx\nRBP:%016lx RSP:%016lx\n"

"R8 :%016lx R9 :%016lx\nR10:%016lx R11:%016lx\n"

"R12:%016lx R13:%016lx\nR14:%016lx R15:%016lx\n"

"RIP:%016lx EFL:%016lx\nCS :%016lx FS:%016lx GS:%016lx",

(unsigned long) uc->uc_mcontext->__ss.__rax,

(unsigned long) uc->uc_mcontext->__ss.__rbx,

(unsigned long) uc->uc_mcontext->__ss.__rcx,

(unsigned long) uc->uc_mcontext->__ss.__rdx,

(unsigned long) uc->uc_mcontext->__ss.__rdi,

(unsigned long) uc->uc_mcontext->__ss.__rsi,

(unsigned long) uc->uc_mcontext->__ss.__rbp,

(unsigned long) uc->uc_mcontext->__ss.__rsp,

(unsigned long) uc->uc_mcontext->__ss.__r8,

(unsigned long) uc->uc_mcontext->__ss.__r9,

(unsigned long) uc->uc_mcontext->__ss.__r10,

(unsigned long) uc->uc_mcontext->__ss.__r11,

(unsigned long) uc->uc_mcontext->__ss.__r12,

(unsigned long) uc->uc_mcontext->__ss.__r13,

(unsigned long) uc->uc_mcontext->__ss.__r14,

(unsigned long) uc->uc_mcontext->__ss.__r15,

(unsigned long) uc->uc_mcontext->__ss.__rip,

(unsigned long) uc->uc_mcontext->__ss.__rflags,

(unsigned long) uc->uc_mcontext->__ss.__cs,

(unsigned long) uc->uc_mcontext->__ss.__fs,

(unsigned long) uc->uc_mcontext->__ss.__gs

);

logStackContent((void**)uc->uc_mcontext->__ss.__rsp);

#else

/* OSX x86 */