void DBXD_genRedisInfoString(sds info) { #ifdef REDIS3 info = sdscat(info,"\r\n"); #endif info = sdscatprintf(info, #ifdef REDIS3 "# ALCHEMY\r\n" #endif "luacronfunc:%s\r\n" "basedir:%s\r\n" "outputmode:%s\r\n" "webserver_mode:%s\r\n" "webserver_index_function:%s\r\n" "rest_api_mode:%s\r\n", server.alc.LuaCronFunc, server.alc.Basedir, (EREDIS ? "embedded" : OREDIS ? "pure_redis" : LREDIS ? "lua" : "normal"), (server.alc.WebServerMode == -1) ? "no" : "yes", server.alc.WebServerIndexFunc, (server.alc.RestAPIMode == -1) ? "no" : "yes"); if (server.alc.OutputLuaFunc_Start) { info = sdscatprintf(info, "lua_output_start:%s\r\n", server.alc.OutputLuaFunc_Start); } if (server.alc.OutputLuaFunc_Cnames) { info = sdscatprintf(info, "lua_output_cnames:%s\r\n", server.alc.OutputLuaFunc_Cnames); } if (server.alc.OutputLuaFunc_Row) { info = sdscatprintf(info, "lua_output_row:%s\r\n", server.alc.OutputLuaFunc_Row); } }
static sds signature(sds consumerSecret, sds accessTokenSecret, METHOD method, sds url, Parameters *params) { sds query = join_parameters(params, "&"); sds encodedCS = url_encode(consumerSecret); sds encodedATS = url_encode(accessTokenSecret); sds key = sdscatprintf(sdsempty(), "%s&%s", encodedCS, encodedATS); sds method_str; if (method == POST) { method_str = sdsnew("POST"); } else { method_str = sdsnew("GET"); } sds encodedURL = url_encode(url); sds encodedQuery = url_encode(query); sds base = sdscatprintf(sdsempty(), "%s&%s&%s", method_str, encodedURL, encodedQuery); sds res = hmac_sha1(key, base); sds buf = sdsgrowzero(sdsempty(), 256); k64_encode (res, buf); sdsfree(query); sdsfree(encodedCS); sdsfree(encodedATS); sdsfree(key); sdsfree(method_str); sdsfree(encodedURL); sdsfree(encodedQuery); sdsfree(base); sdsfree(res); return sdsnewlen(buf, strlen(buf)); }
void replicationFeedMonitors(list *monitors, int dictid, robj **argv, int argc) { listNode *ln; listIter li; int j; sds cmdrepr = sdsnew("+"); robj *cmdobj; struct timeval tv; gettimeofday(&tv,NULL); cmdrepr = sdscatprintf(cmdrepr,"%ld.%06ld ",(long)tv.tv_sec,(long)tv.tv_usec); if (dictid != 0) cmdrepr = sdscatprintf(cmdrepr,"(db %d) ", dictid); for (j = 0; j < argc; j++) { if (argv[j]->encoding == REDIS_ENCODING_INT) { cmdrepr = sdscatprintf(cmdrepr, "\"%ld\"", (long)argv[j]->ptr); } else { cmdrepr = sdscatrepr(cmdrepr,(char*)argv[j]->ptr, sdslen(argv[j]->ptr)); } if (j != argc-1) cmdrepr = sdscatlen(cmdrepr," ",1); } cmdrepr = sdscatlen(cmdrepr,"\r\n",2); cmdobj = createObject(REDIS_STRING,cmdrepr); listRewind(monitors,&li); while((ln = listNext(&li))) { redisClient *monitor = ln->value; addReply(monitor,cmdobj); } decrRefCount(cmdobj); }
/** * Takes partial tags and replaces them with a parsed partial template. * * @param sds tag The tag * * @retval sds buff Partial template buffer. */ static sds tag_partial(sds tag) { puts("tag_partial"); printf("tag found: '%s'\n",tag); sds re = sdsempty(); sds f = sdsempty(); sds buff = sdsempty(); re = sdscatprintf(re, "%s>([^}]+)%s", ldelim, rdelim); struct slre_cap caps[1]; if (slre_match(re, tag, strlen(tag), caps, 1) > 0) { f = sdscatprintf(f,"%.*s", caps[0].len, caps[0].ptr); sdstrim(f," "); sds fname = sdscatprintf(sdsempty(),"%s%s", tpldir, f); fname = sdscat(fname,tplext); //puts(fname); FILE * fp; if ((fp = fopen(fname, "r")) != NULL) { fclose(fp); buff = render_template(f); } puts("free fname"); sdsfree(fname); } puts("free f"); sdsfree(f); // //sdsfree(buff); puts("free re"); sdsfree(re); return buff; }
/** * Takes delimiter tags and sets the delimiter for the parser. * * @param sds tag The tag * * @retval sdsempty() Emtpy sds string. */ static sds tag_delimiter(sds tag) { puts("tag_delimiter"); printf("tag found: '%s'\n",tag); sds re = sdsempty(); sds oldl = sdsdup(ldelim), oldr = sdsdup(rdelim); re = sdscatprintf(re, "(%s=\\S+)\\s+(\\S+=%s)", oldl, oldr); struct slre_cap caps[2]; int i; if ((i = slre_match(re, tag, sdslen(tag), caps, 2)) > 0) { ldelim = sdscpylen(ldelim, caps[0].ptr, caps[0].len); rdelim = sdscpylen(rdelim, caps[1].ptr, caps[1].len); oldl = sdscatprintf(sdsempty(), "%s=", oldl); oldr = sdscatprintf(sdsempty(), "=%s", oldr); ldelim = sdsreplace(ldelim, oldl, NULL); rdelim = sdsreplace(rdelim, oldr, NULL); printf("ldelim: '%s'\n", ldelim); printf("rdelim: '%s'\n", rdelim); } printf("Matched: %d\n",i); puts("free oldl); sdsfree(oldr); sdsfree(re"); sdsfree(oldl); sdsfree(oldr); sdsfree(re); return sdsempty(); }
static bool addSingle(redisClient *c, void *x, robj *key, long *instd, bool is_ins) { redisClient *fc = (redisClient *)x; robj *vals = createObject(REDIS_STRING, NULL); if (is_ins) { vals->ptr = sdsnewlen(key->ptr, sdslen(key->ptr)); } else { vals->ptr = (key->encoding == REDIS_ENCODING_RAW) ? sdscatprintf(sdsempty(), "%ld,%s", *instd, (char *)key->ptr) : sdscatprintf(sdsempty(), "%ld,%ld", *instd, (long) key->ptr); } fc->argv[2] = vals; //RL4 "SGL: INSERTING [1]: %s [2]: %s", fc->argv[1]->ptr, fc->argv[2]->ptr); legacyInsertCommand(fc); decrRefCount(vals); if (!respOk(fc)) { /* insert error */ listNode *ln = listFirst(fc->reply); addReply(c, ln->value); return 0; } *instd = *instd + 1; return 1; }
static int redisSetBlocking(redisContext *c, int fd, int blocking) { int flags; /* Set the socket nonblocking. * Note that fcntl(2) for F_GETFL and F_SETFL can't be * interrupted by a signal. */ if ((flags = fcntl(fd, F_GETFL)) == -1) { __redisSetError(c,REDIS_ERR_IO, sdscatprintf(sdsempty(), "fcntl(F_GETFL): %s", strerror(errno))); close(fd); return REDIS_ERR; } if (blocking) flags &= ~O_NONBLOCK; else flags |= O_NONBLOCK; if (fcntl(fd, F_SETFL, flags) == -1) { __redisSetError(c,REDIS_ERR_IO, sdscatprintf(sdsempty(), "fcntl(F_SETFL): %s", strerror(errno))); close(fd); return REDIS_ERR; } return REDIS_OK; }
bool luafunc_call(redisClient *c, int argc, robj **argv) { sds fname; if (server.alc.WebServerMode == -1) { fname = sdsdup(argv[1]->ptr); } else { if (isWhiteListedIp(c)) { if (c->http.mode == HTTP_MODE_ON) { fname = sdscatprintf(sdsempty(), "WL_%s", (char *)argv[1]->ptr); } else { fname = sdsdup(argv[1]->ptr); } } else { fname = sdscatprintf(sdsempty(), "WL_%s", (char *)argv[1]->ptr); } } //printf("luafunc_call: fname: %s\n", fname); lua_getglobal(server.lua, fname); sdsfree(fname); int type = lua_type(server.lua, -1); if (type != LUA_TFUNCTION) { lua_pop(server.lua, 1); if (c->http.mode == HTTP_MODE_ON) SEND_404 else LUA_FUNCTION_REDIS_ERR return 1; }
int main(int argc, char *argv[]) { list_type type; type.dup = node_dup; type.free = node_free; type.compare = node_compare; list_t *list = list_create(&type); for (int i = 0; i < 10; ++i) { sds value = sdsempty(); value = sdscatprintf(value, "%d", i); list_add_node_tail(list, value); printf("add %s\n", value); sdsfree(value); } for (int i = 0; i < 10; ++i) { sds value = sdsempty(); value = sdscatprintf(value, "%d", 10 + i); list_add_node_head(list, value); printf("add %s\n", value); sdsfree(value); } list_node *node = list_index(list, 10); sds value = sdsempty(); value = sdscatprintf(value, "%d", 100); list_insert_node(list, node, value, 1); printf("insert %s\n", value); node = list_find(list, value); printf("search: %s\n", (char *)node->value); sdsfree(value); for (int i = -10; i < 10; ++i) { node = list_index(list, i); if (node) { printf("%d: %s\n", i, (char *)node->value); } } list_t *copy = list_dup(list); list_release(list); printf("len: %ld\n", list_len(copy)); list_rotate(copy); list_rotate(copy); list_rotate(copy); list_iter *iter = list_get_iterator(copy, LIST_START_HEAD); while ((node = list_next(iter)) != NULL) { printf("%s\n", (char *)node->value); list_del(copy, node); } list_release_iterator(iter); list_release(copy); printf("len: %ld\n", list_len(copy)); printf("head: %p, tail: %p\n", copy->head, copy->tail); return 0; }
sds sdscatrepr(sds s, char *p, size_t len) { s = sdscatlen(s,"\"",1); if (s == NULL) return NULL; while(len--) { switch(*p) { case '\\': case '"': s = sdscatprintf(s,"\\%c",*p); break; case '\n': s = sdscatlen(s,"\\n",2); break; case '\r': s = sdscatlen(s,"\\r",2); break; case '\t': s = sdscatlen(s,"\\t",2); break; case '\a': s = sdscatlen(s,"\\a",2); break; case '\b': s = sdscatlen(s,"\\b",2); break; default: if (isprint(*p)) s = sdscatprintf(s,"%c",*p); else s = sdscatprintf(s,"\\x%02x",(unsigned char)*p); break; } p++; if (s == NULL) return NULL; } return sdscatlen(s,"\"",1); }
/* * cetcd_cluster_request tries to request the whole cluster. It round-robin to next server if the request failed * */ void *cetcd_cluster_request(cetcd_client *cli, cetcd_request *req) { size_t i, count; cetcd_string url; cetcd_error *err = NULL; cetcd_response *resp = NULL; cetcd_array *addrs = NULL; void *res = NULL; count = cetcd_array_size(cli->addresses); for(i = 0; i < count; ++i) { url = sdscatprintf(sdsempty(), "http://%s/%s", (cetcd_string)cetcd_array_get(cli->addresses, cli->picked), req->uri); req->url = url; req->cli = cli; res = cetcd_send_request(cli->curl, req); sdsfree(url); /*api_type == syncCluster, got address, return*/ if (req->api_type == ETCD_MEMBERS ){ if ((addrs = res)) { if ( cetcd_array_size(addrs)) { return addrs; } else { cetcd_array_destroy(addrs); } } } else { if((resp=res) && resp->err && resp->err->ecode == error_send_request_failed) { if (i != count-1) { cetcd_response_release(resp); resp = NULL; } } else { /*got response, return*/ return resp; } } /*try next*/ if (i != count-1) { cli->picked = (cli->picked + 1) % count; } } /*the whole cluster failed*/ if (req->api_type == ETCD_MEMBERS) return NULL; if (resp) { if(resp->err) { err = resp->err; /*remember last error*/ } resp->err = calloc(1, sizeof(cetcd_error)); resp->err->ecode = error_cluster_failed; resp->err->message = sdsnew("etcd_do_request: all cluster servers failed."); if (err) { resp->err->message = sdscatprintf(resp->err->message, " last error: %s", err->message); cetcd_error_release(err); } resp->err->cause = sdsdup(req->uri); } return resp; }
// LUA_SCRIPT_TO_HTTP_RESPONSE LUA_SCRIPT_TO_HTTP_RESPONSE static robj *luaReplyToHTTPReply(lua_State *lua) { robj *r = createObject(REDIS_STRING, NULL); int t = lua_type(lua, 1); switch(t) { case LUA_TSTRING: r->ptr = sdsnewlen((char*)lua_tostring(lua, 1), lua_strlen(lua, 1)); break; case LUA_TBOOLEAN: r->ptr = sdsnewlen(lua_toboolean(lua, 1) ? "1" : "0", 1); break; case LUA_TNUMBER: r->ptr = sdscatprintf(sdsempty(), "%lld", (lolo)lua_tonumber(lua,1)); break; case LUA_TTABLE: lua_pushstring(lua, "err"); // check for error lua_gettable(lua, -2); t = lua_type(lua, -1); if (t == LUA_TSTRING) { r->ptr = sdscatprintf(sdsempty(), "%s", (char*)lua_tostring(lua, -1)); lua_pop(lua,2); } else { // check for ok lua_pop(lua, 1); lua_pushstring(lua, "ok"); lua_gettable(lua, -2); t = lua_type(lua, -1); if (t == LUA_TSTRING) { r->ptr = sdscatprintf(sdsempty(), "%s\r\n", (char*)lua_tostring(lua, -1)); lua_pop(lua, 1); } else { // this is a real table int j = 1, mbulklen = 0; lua_pop(lua, 1); /* Discard the 'ok' field value we popped */ while(1) { lua_pushnumber(lua, j++); lua_gettable(lua, -2); t = lua_type(lua, -1); if (t == LUA_TNIL) { lua_pop(lua,1); break; } else if (t == LUA_TSTRING) { size_t len; char *s = (char *)lua_tolstring(lua, -1, &len); r->ptr = r->ptr ? sdscatlen(r->ptr, s, len) : sdsnewlen(s, len); mbulklen++; } else if (t == LUA_TNUMBER) { sds s = r->ptr ? r->ptr : sdsempty(); r->ptr = sdscatprintf(s, "%lld", (lolo)lua_tonumber(lua,1)); mbulklen++; } lua_pop(lua, 1); } } break; default: r->ptr = sdsempty(); } } lua_pop(lua, 1); return r; }
void debugCommand(client *c) { if (!strcasecmp(c->argv[1]->ptr,"segfault")) { *((char*)-1) = 'x'; } 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")) { if (c->argc >= 3) c->argv[2] = tryObjectEncoding(c->argv[2]); serverAssertWithInfo(c,c->argv[0],1 == 2); } else if (!strcasecmp(c->argv[1]->ptr,"flushall")) { flushServerData(); addReply(c,shared.ok); } else if (!strcasecmp(c->argv[1]->ptr,"loadaof")) { flushServerData(); if (loadAppendOnlyFile(server.aof_filename) != C_OK) { addReply(c,shared.err); return; } serverLog(LL_WARNING,"Append Only File loaded by DEBUG LOADAOF"); addReply(c,shared.ok); } 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,"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,"job:%d ", (int)sizeof(job)); sizes = sdscatprintf(sizes,"queue:%d ", (int)sizeof(queue)); 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 { addReplyErrorFormat(c, "Unknown DEBUG subcommand or wrong number of arguments for '%s'", (char*)c->argv[1]->ptr); } }
static int redisContextWaitReady(redisContext *c, int fd, const struct timeval *timeout) { struct timeval to; struct timeval *toptr = NULL; fd_set wfd; int err; socklen_t errlen; /* Only use timeout when not NULL. */ if (timeout != NULL) { to = *timeout; toptr = &to; } if (errno == EINPROGRESS) { FD_ZERO(&wfd); FD_SET(fd, &wfd); if (select(FD_SETSIZE, NULL, &wfd, NULL, toptr) == -1) { __redisSetError(c,REDIS_ERR_IO, sdscatprintf(sdsempty(), "select(2): %s", strerror(errno))); close(fd); return REDIS_ERR; } if (!FD_ISSET(fd, &wfd)) { errno = ETIMEDOUT; __redisSetError(c,REDIS_ERR_IO,NULL); close(fd); return REDIS_ERR; } err = 0; errlen = sizeof(err); if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) { __redisSetError(c,REDIS_ERR_IO, sdscatprintf(sdsempty(), "getsockopt(SO_ERROR): %s", strerror(errno))); close(fd); return REDIS_ERR; } if (err) { errno = err; __redisSetError(c,REDIS_ERR_IO,NULL); close(fd); return REDIS_ERR; } return REDIS_OK; } __redisSetError(c,REDIS_ERR_IO,NULL); close(fd); return REDIS_ERR; }
void stream(T4C* t4c, sds url, Parameters* paramsArgument, size_t (*callback)(void*, size_t, size_t, void*)) { Parameters* oauthParams = new_parameters(); genOAuthParams(t4c, oauthParams); Parameters* params = new_parameters(); buildParams(params, oauthParams, paramsArgument); sds oauthSignature = signature(t4c->consumerSecret, t4c->accessTokenSecret, GET, url, params); sds encodedSignature = url_encode(oauthSignature); add_parameter(oauthParams, sdsnew("oauth_signature"), encodedSignature); add_parameter(params, sdsnew("oauth_signature"), encodedSignature); sds authorizeChild = join_parameters(oauthParams, ","); sds authorize = sdscatprintf(sdsempty(), "Authorization: OAuth %s", authorizeChild); sds path = join_parameters(params, "&"); if (DEBUG) { printf("----------------------------\n"); printf("STREAMING API"); printf("URL: %s\n", url); printf("path: %s\n", path); printf("authorize: %s\n", authorize); printf("----------------------------\n"); } CURL* curl; curl = curl_easy_init(); sds reqURL = sdscatprintf(sdsempty(), "%s?%s", url, path); curl_easy_setopt(curl, CURLOPT_URL, reqURL); struct curl_slist *headers = NULL; headers = curl_slist_append(headers, authorize); curl_easy_setopt(curl, CURLOPT_HEADER, headers); curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0); curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, callback); curl_easy_setopt(curl, CURLOPT_TIMEOUT, 0); curl_easy_perform(curl); curl_easy_cleanup(curl); sdsfree(oauthSignature); sdsfree(encodedSignature); sdsfree(reqURL); sdsfree(url); sdsfree(path); sdsfree(authorize); sdsfree(authorizeChild); free_parameters(oauthParams); }
static cetcd_string cetcd_watcher_build_url(cetcd_client *cli, cetcd_watcher *watcher) { cetcd_string url; url = sdscatprintf(sdsempty(), "http://%s/%s%s?wait=true", (cetcd_string)cetcd_array_get(cli->addresses, cli->picked), cli->keys_space, watcher->key); if (watcher->index) { url = sdscatprintf(url, "&waitIndex=%lu", watcher->index); } if (watcher->recursive) { url = sdscatprintf(url, "&recursive=true"); } return url; }
static int cliSendCommand(int argc, char **argv, int repeat) { char *command = argv[0]; int fd, j, retval = 0; sds cmd; config.raw_output = !strcasecmp(command,"info"); if (!strcasecmp(command,"help")) { showInteractiveHelp(); return 0; } if (!strcasecmp(command,"shutdown")) config.shutdown = 1; if (!strcasecmp(command,"monitor")) config.monitor_mode = 1; if (!strcasecmp(command,"subscribe") || !strcasecmp(command,"psubscribe")) config.pubsub_mode = 1; if ((fd = cliConnect(0)) == -1) return 1; /* Select db number */ retval = selectDb(fd); if (retval) { fprintf(stderr,"Error setting DB num\n"); return 1; } /* Build the command to send */ cmd = sdscatprintf(sdsempty(),"*%d\r\n",argc); for (j = 0; j < argc; j++) { cmd = sdscatprintf(cmd,"$%lu\r\n", (unsigned long)sdslen(argv[j])); cmd = sdscatlen(cmd,argv[j],sdslen(argv[j])); cmd = sdscatlen(cmd,"\r\n",2); } while(repeat--) { anetWrite(fd,cmd,sdslen(cmd)); while (config.monitor_mode) { if (cliReadSingleLineReply(fd,0)) exit(1); printf("\n"); } if (config.pubsub_mode) { printf("Reading messages... (press Ctrl-c to quit)\n"); while (1) { cliReadReply(fd); printf("\n\n"); } } retval = cliReadReply(fd); if (!config.raw_output && config.tty) printf("\n"); if (retval) return retval; } return 0; }
sds catAppendOnlyGenericCommand(sds buf, int argc, robj **argv) { int j; buf = sdscatprintf(buf,"*%d\r\n",argc); for (j = 0; j < argc; j++) { robj *o = getDecodedObject(argv[j]); buf = sdscatprintf(buf,"$%lu\r\n",(unsigned long)sdslen(o->ptr)); buf = sdscatlen(buf,o->ptr,sdslen(o->ptr)); buf = sdscatlen(buf,"\r\n",2); decrRefCount(o); } return buf; }
static int cliSendCommand(int argc, char **argv) { struct redisCommand *rc = lookupCommand(argv[0]); int fd, j, retval = 0; sds cmd; if (!rc) { fprintf(stderr,"Unknown command '%s'\n",argv[0]); return 1; } if ((rc->arity > 0 && argc != rc->arity) || (rc->arity < 0 && argc < -rc->arity)) { fprintf(stderr,"Wrong number of arguments for '%s'\n",rc->name); return 1; } if ((fd = cliConnect()) == -1) return 1; while(config.repeat--) { /* Build the command to send */ cmd = sdsempty(); if (rc->flags & REDIS_CMD_MULTIBULK) { cmd = sdscatprintf(cmd,"*%d\r\n",argc); for (j = 0; j < argc; j++) { cmd = sdscatprintf(cmd,"$%d\r\n",sdslen(argv[j])); cmd = sdscatlen(cmd,argv[j],sdslen(argv[j])); cmd = sdscatlen(cmd,"\r\n",2); } } else { for (j = 0; j < argc; j++) { if (j != 0) cmd = sdscat(cmd," "); if (j == argc-1 && rc->flags & REDIS_CMD_BULK) { cmd = sdscatprintf(cmd,"%d",sdslen(argv[j])); } else { cmd = sdscatlen(cmd,argv[j],sdslen(argv[j])); } } cmd = sdscat(cmd,"\r\n"); if (rc->flags & REDIS_CMD_BULK) { cmd = sdscatlen(cmd,argv[argc-1],sdslen(argv[argc-1])); cmd = sdscatlen(cmd,"\r\n",2); } } anetWrite(fd,cmd,sdslen(cmd)); sdsfree(cmd); retval = cliReadReply(fd); if (retval) { close(fd); return retval; } } close(fd); return 0; }
void luaCommand(redisClient *c) { //printf("LUA: %s\n", c->argv[1]->ptr); LuaFlag = PIPE_NONE_FLAG; LuaClient = c; /* used in func redisLua */ int s = luaL_dostring(Lua, c->argv[1]->ptr); if (s) { const char *x = lua_tostring(Lua, -1); lua_pop(Lua, 1); addReplySds(c, sdscatprintf(sdsempty(), "-ERR Lua error: %s \r\n", x)); return; } int lret = lua_gettop(Lua); //printf("LuaFlag: %d lret: %d\n", LuaFlag, lret); if (lua_istable(Lua, -1)) { const int len = lua_objlen(Lua, -1 ); addReplySds(c, sdscatprintf(sdsempty(), "*%d\r\n", len)); for (int i = 1; i <= len; ++i ) { lua_pushinteger(Lua, i); lua_gettable(Lua, -2); char *x = (char *)lua_tostring(Lua, -1); robj *r = _createStringObject(x); addReplyBulk(c, r); decrRefCount(r); lua_pop(Lua, 1); } lua_pop(Lua, 1); } else if (LuaFlag == PIPE_EMPTY_SET_FLAG) { addReply(c, shared.emptymultibulk); lua_pop(Lua, 1); /* pop because Pipe adds "-1" for Multi-NonRelIndxs */ } else if (!lret) { addReply(c, shared.nullbulk); } else { char *x = (char *)lua_tostring(Lua, -1); if (!x) { addReply(c, shared.nullbulk); } else { /* NOTE: if "client() is called in a lua func and the lua func then returns "+OK" it will 'correctly' returned */ if (LuaFlag == PIPE_ONE_LINER_FLAG && (*x == '-' || *x == '+' || *x == ':')) { addReplySds(c, sdscatprintf(sdsempty(), "%s\r\n", x)); } else { robj *r = _createStringObject(x); addReplyBulk(c, r); decrRefCount(r); } } lua_pop(Lua, 1); } lua_gc(Lua, LUA_GCCOLLECT, 0); }
static sds cliVersion() { sds version; version = sdscatprintf(sdsempty(), "%s", REDIS_VERSION); /* Add git commit and working tree status when available */ if (strtoll(redisGitSHA1(),NULL,16)) { version = sdscatprintf(version, " (git:%s", redisGitSHA1()); if (strtoll(redisGitDirty(),NULL,10)) version = sdscatprintf(version, "-dirty"); version = sdscat(version, ")"); } return version; }
bool loadLuaHelperFile(cli *c, char *fname) { sds fwpath = sdscatprintf(sdsempty(), "%s%s", server.alc.Basedir, fname); bool ret = 1; if (luaL_loadfile(server.lua, fwpath) || DXDB_lua_pcall(server.lua, 0, 0, 0)) { const char *lerr = lua_tostring(server.lua, -1); if (c) addReplySds(c, sdscatprintf(sdsempty(), "-ERR luaL_loadfile: %s err: %s\r\n", fwpath, lerr)); else fprintf(stderr, "loadLuaHelperFile: %s err: %s\r\n", fwpath, lerr); ret = 0; } CLEAR_LUA_STACK sdsfree(fwpath); return ret; }
int redisContextSetTimeout(redisContext *c, struct timeval tv) { if (setsockopt(c->fd,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof(tv)) == -1) { __redisSetError(c,REDIS_ERR_IO, sdscatprintf(sdsempty(), "setsockopt(SO_RCVTIMEO): %s", strerror(errno))); return REDIS_ERR; } if (setsockopt(c->fd,SOL_SOCKET,SO_SNDTIMEO,&tv,sizeof(tv)) == -1) { __redisSetError(c,REDIS_ERR_IO, sdscatprintf(sdsempty(), "setsockopt(SO_SNDTIMEO): %s", strerror(errno))); return REDIS_ERR; } return REDIS_OK; }
cetcd_response *cetcd_rmdir(cetcd_client *cli, cetcd_string key, int recursive){ cetcd_request req; cetcd_response *resp; memset(&req, 0, sizeof(cetcd_request)); req.method = ETCD_HTTP_DELETE; req.uri = sdscatprintf(sdsempty(), "%s%s?dir=true", cli->keys_space, key); if (recursive){ req.uri = sdscatprintf(req.uri, "&recursive=true"); } resp = cetcd_cluster_request(cli, &req); sdsfree(req.uri); return resp; }
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 replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc) { listNode *ln; listIter li; int j; listRewind(slaves,&li); while((ln = listNext(&li))) { redisClient *slave = ln->value; /* Don't feed slaves that are still waiting for BGSAVE to start */ if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_START) continue; /* Feed slaves that are waiting for the initial SYNC (so these commands * are queued in the output buffer until the intial SYNC completes), * or are already in sync with the master. */ if (slave->slaveseldb != dictid) { robj *selectcmd; if (dictid >= 0 && dictid < REDIS_SHARED_SELECT_CMDS) { selectcmd = shared.select[dictid]; incrRefCount(selectcmd); } else { selectcmd = createObject(REDIS_STRING, sdscatprintf(sdsempty(),"select %d\r\n",dictid)); } addReply(slave,selectcmd); decrRefCount(selectcmd); slave->slaveseldb = dictid; } addReplyMultiBulkLen(slave,argc); for (j = 0; j < argc; j++) addReplyBulk(slave,argv[j]); } }
void keysCommand(redisClient *c) { dictIterator *di; dictEntry *de; sds pattern = c->argv[1]->ptr; int plen = sdslen(pattern); unsigned long numkeys = 0; robj *lenobj = createObject(REDIS_STRING,NULL); di = dictGetIterator(c->db->dict); addReply(c,lenobj); decrRefCount(lenobj); while((de = dictNext(di)) != NULL) { sds key = dictGetEntryKey(de); robj *keyobj; if ((pattern[0] == '*' && pattern[1] == '\0') || stringmatchlen(pattern,plen,key,sdslen(key),0)) { keyobj = createStringObject(key,sdslen(key)); if (expireIfNeeded(c->db,keyobj) == 0) { addReplyBulk(c,keyobj); numkeys++; } decrRefCount(keyobj); } } dictReleaseIterator(di); lenobj->ptr = sdscatprintf(sdsempty(),"*%lu\r\n",numkeys); }
static void cliInitHelp() { int commandslen = sizeof(commandHelp)/sizeof(struct commandHelp); int groupslen = sizeof(commandGroups)/sizeof(char*); int i, len, pos = 0; helpEntry tmp; helpEntriesLen = len = commandslen+groupslen; helpEntries = malloc(sizeof(helpEntry)*len); for (i = 0; i < groupslen; i++) { tmp.argc = 1; tmp.argv = malloc(sizeof(sds)); tmp.argv[0] = sdscatprintf(sdsempty(),"@%s",commandGroups[i]); tmp.full = tmp.argv[0]; tmp.type = CLI_HELP_GROUP; tmp.org = NULL; helpEntries[pos++] = tmp; } for (i = 0; i < commandslen; i++) { tmp.argv = sdssplitargs(commandHelp[i].name,&tmp.argc); tmp.full = sdsnew(commandHelp[i].name); tmp.type = CLI_HELP_COMMAND; tmp.org = &commandHelp[i]; helpEntries[pos++] = tmp; } }
static sds cliFormatReplyRaw(redisReply *r) { sds out = sdsempty(), tmp; size_t i; switch (r->type) { case REDIS_REPLY_NIL: /* Nothing... */ break; case REDIS_REPLY_ERROR: out = sdscatlen(out,r->str,r->len); out = sdscatlen(out,"\n",1); break; case REDIS_REPLY_STATUS: case REDIS_REPLY_STRING: out = sdscatlen(out,r->str,r->len); break; case REDIS_REPLY_INTEGER: out = sdscatprintf(out,"%lld",r->integer); break; case REDIS_REPLY_ARRAY: for (i = 0; i < r->elements; i++) { if (i > 0) out = sdscat(out,config.mb_delim); tmp = cliFormatReplyRaw(r->element[i]); out = sdscatlen(out,tmp,sdslen(tmp)); sdsfree(tmp); } break; default: fprintf(stderr,"Unknown reply type: %d\n", r->type); exit(1); } return out; }
static sds cliFormatReplyCSV(redisReply *r) { unsigned int i; sds out = sdsempty(); switch (r->type) { case REDIS_REPLY_ERROR: out = sdscat(out,"ERROR,"); out = sdscatrepr(out,r->str,strlen(r->str)); break; case REDIS_REPLY_STATUS: out = sdscatrepr(out,r->str,r->len); break; case REDIS_REPLY_INTEGER: out = sdscatprintf(out,"%lld",r->integer); break; case REDIS_REPLY_STRING: out = sdscatrepr(out,r->str,r->len); break; case REDIS_REPLY_NIL: out = sdscat(out,"NIL\n"); break; case REDIS_REPLY_ARRAY: for (i = 0; i < r->elements; i++) { sds tmp = cliFormatReplyCSV(r->element[i]); out = sdscatlen(out,tmp,sdslen(tmp)); if (i != r->elements-1) out = sdscat(out,","); sdsfree(tmp); } break; default: fprintf(stderr,"Unknown reply type: %d\n", r->type); exit(1); } return out; }