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 = INVALID_EXPIRE;

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->dict);

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 = {{0},{0}};

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 != INVALID_EXPIRE) 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->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 = (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 == EPERM && argc > 1) {

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

if (!(ret=je_mallctl(szFromObj(argv[0]), 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;

#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 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(szFromObj(argv[0]), &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 = szFromObj(argv[1]);

char **valref = &val;

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

valref = NULL, sz = 0;

wret = je_mallctl(szFromObj(argv[0]), NULL, 0, valref, sz);

}

if (!rret)

addReplyBulkCString(c, old);

else if (wret)

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

else

addReply(c, shared.ok);

if (c->argc == 2 && !strcasecmp(szFromObj(c->argv[1]),"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 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.",

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

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

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

#ifdef USE_JEMALLOC

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

" Get or set a malloc tuning integer.",

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

" Get or set a malloc tuning string.",

#endif

"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 <prefix> is specified then",

" it is used instead of the 'key' prefix.",

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

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

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

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

"ZIPLIST <key>",

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

};

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 %lld", (long long)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]),"leak") && c->argc == 3) {

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

addReply(c,shared.ok);

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

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 (rdbSaveFile(g_pserver->rdb_filename,rsiptr) != C_OK) {

addReply(c,shared.err);

return;

}

}

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

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

protectClient(c);

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

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

addReplyErrorObject(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->dict,ptrFromObj(c->argv[2]))) == NULL) {

addReplyErrorObject(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, c->argv[2]),

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->dict,ptrFromObj(c->argv[2]))) == NULL) {

addReplyErrorObject(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_roptr o;

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

== nullptr) return;

if (o->encoding != OBJ_ENCODING_ZIPLIST) {

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

} 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 (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*)ptrFromObj(c->argv[3]), 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(ptrFromObj(val), buf, valsize<=buflen? valsize: buflen);

}

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

signalModifiedKey(c,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 */

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

dictEntry *de;

robj *o = (robj*)((de = dictFind(c->db->dict,ptrFromObj(c->argv[j]))) == NULL) ? NULL : (robj*)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(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")) {

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

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]),"set-skip-checksum-validation") &&

c->argc == 3)

{

cserver.skip_checksum_validation = 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].dict);

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_roptr o;

dict *ht = NULL;

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

== nullptr) 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->dict;

}

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

} else if (!strcasecmp(szFromObj(c->argv[1]),"truncate-repl-backlog") && c->argc == 2) {

g_pserver->repl_backlog_idx = 0;

g_pserver->repl_backlog_off = g_pserver->master_repl_offset+1;

g_pserver->repl_backlog_histlen = 0;

if (g_pserver->repl_batch_idxStart >= 0) g_pserver->repl_batch_idxStart = -1;

if (g_pserver->repl_batch_offStart >= 0) g_pserver->repl_batch_offStart = -1;

addReply(c, shared.ok);

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

{

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

addReplyError(c, "CONFIG-REWRITE-FORCE-ALL failed");

else

addReply(c, shared.ok);

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

{

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

addReplyError(c, "CONFIG-REWRITE-FORCE-ALL failed");

else

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;

}

g_fInCrash = true;

bugReportStart();

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

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

if (g_pserver->crashlog_enabled) {

#if defined HAVE_BACKTRACE || defined UNW_LOCAL_ONLY

logStackTrace(NULL, 1);

#endif

printCrashReport();

}

// remove the signal handler so on abort() we will output the crash report.

removeSignalHandlers();

bugReportEnd(0, 0);

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 UNSAFE_CRASH_REPORT

/* This code is now disabled. o->ptr may be unreliable to print. in some