Exemplo n.º 1
0
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);
    }
}
Exemplo n.º 2
0
Arquivo: t4c.c Projeto: alphaKAI/t4c
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));
}
Exemplo n.º 3
0
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);
}
Exemplo n.º 4
0
/**
 * 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;
}
Exemplo n.º 5
0
/**
 * 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();
}
Exemplo n.º 6
0
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;
}
Exemplo n.º 7
0
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;
}
Exemplo n.º 8
0
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;
    }
Exemplo n.º 9
0
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;
}
Exemplo n.º 10
0
Arquivo: sds.c Projeto: 734839030/zimg
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);
}
Exemplo n.º 11
0
/*
 * 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;
}
Exemplo n.º 12
0
// 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;
}
Exemplo n.º 13
0
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);
    }
}
Exemplo n.º 14
0
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;
}
Exemplo n.º 15
0
Arquivo: t4c.c Projeto: alphaKAI/t4c
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);
}
Exemplo n.º 16
0
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;
}
Exemplo n.º 17
0
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;
}
Exemplo n.º 18
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;
}
Exemplo n.º 19
0
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;
}
Exemplo n.º 20
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);
}
Exemplo n.º 21
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;
}
Exemplo n.º 22
0
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;
}
Exemplo n.º 23
0
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;
}
Exemplo n.º 24
0
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;
}
Exemplo n.º 25
0
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));
}
Exemplo n.º 26
0
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]);
    }
}
Exemplo n.º 27
0
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);
}
Exemplo n.º 28
0
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;
    }
}
Exemplo n.º 29
0
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;
}
Exemplo n.º 30
0
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;
}