dbgp_control_info_t *retrieve_control_info(struct transit * transit) { redisContext *c; redisReply* reply; dbgp_control_info_t *control_info; /* Input sanity checks */ assert(transit != NULL && transit->val != NULL); /** * @note: (rajas) I am using this as a hook to attch to the bgpd * process for debugging */ //sleep(50); /* First retrieve the lookup key */ assert(transit->length == sizeof(dbgp_lookup_key_t)); /* Get D-BGP control info from lookup service */ c = connect_to_redis(); reply = redisCommand(c, "GET %"PRIu32"", *(dbgp_lookup_key_t *)transit->val); if(reply->type == REDIS_REPLY_ERROR) { zlog_err("%s:, failed to retrieve D-BGP control info. Key=%"PRIu32"", __func__, *(dbgp_lookup_key_t *)transit->val); assert(0); } control_info = unpack_redis_reply(reply->str, reply->len); free(reply); free(c); return(control_info); }
int RetrieveWiserCosts(int as1, int as2) { redisContext *c; redisReply* reply; char* command = malloc(100); sprintf(command,"GET %i-%i", as1, as2 ); /* Get D-BGP control info from lookup service */ c = connect_to_redis(); reply = redisCommand(c, command); if(reply->type == REDIS_REPLY_ERROR) { zlog_err("dbgp_lookup::RetreiveWiserCosts: failed to get wiser costs for key %i-%i", as1, as2); assert(0); } if(reply->type == REDIS_REPLY_NIL) { zlog_debug("dbgp_lookup::RetreiveWiserCosts: Key (%i-%i) did not exist for retrieving", as1, as2); return -1; } if(reply->type != REDIS_REPLY_INTEGER){ zlog_debug("dbgp_lookup::RetrieveWiserCosts: Key(%i-%i) exist and got back STRING cost %s", as1, as2, reply->str); return strtol(reply->str, NULL, 0); } int return_val = reply->integer; zlog_debug("dbgp_lookup::RetrieveWiserCosts: Key(%i-%i) exist and got back cost %i", as1, as2, return_val); free(reply); free(c); return return_val; }
int main(int argc, char **argv){ printf("starting ...\n"); load_confs(NULL); connect_to_redis(); //syslog(LOG_NOTICE, "Starting URLDUMP2 v%s . PID : %d", APP_VERSION, getpid()); //connect_cache(); capture_traffic(); return 0; }
dbgp_result_status_t set_control_info(struct transit *transit, dbgp_control_info_t *control_info) { uint32_t *key = NULL; redisContext *c; redisReply* reply; char packed_val[control_info->integrated_advertisement_size]; /* Input sanity checks */ assert(transit != NULL && transit->val != NULL && control_info != NULL); /** @note: (rajas) I am using this as a hook to attch to the bgpd * process for debugging */ //sleep(50); /* Get a number that will serve as the new lookup key */ if (g_rand_init == 0) { /** @bug: rajas - sleep to guarantee two instances * of Quagga started by MiniNExT don't use same seed */ sleep(2); srand(mix(clock(), time(NULL), pthread_self())); g_rand_init = 1; } key = (dbgp_lookup_key_t *)malloc(sizeof(dbgp_lookup_key_t)); do { *key = rand(); } while (*key == DBGP_LOOKUP_SVC_PATH); assert(pack_dbgp_control_info(control_info, packed_val) == DBGP_SUCCESS); /* Store control info in lookup service */ c = connect_to_redis(); reply = redisCommand(c, "SET %"PRIu32" %s", *key, packed_val); if (reply->type == REDIS_REPLY_ERROR) { zlog_err("%s: failed to store control info. Key=%"PRIu32", control info=%s", __func__, *key, packed_val); assert(0); } /* Add key to advertisement */ transit->length = sizeof(dbgp_lookup_key_t); transit->val = (u_char *)key; free(reply); free(c); return(DBGP_SUCCESS); }
void test_redis_set() { char cmd[200]; int64_t index=0; redisReply* reply; int n=1; redisContext* rc=NULL; while (1) { for (int i=0;i<n;i++) { if (NULL==rc) { rc=connect_to_redis(); } sprintf(cmd,"set yjb_%lld %s",index++,"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); reply=(redisReply* )redisCommand(rc,cmd); mutex_.lock(); all_count+=1; mutex_.unlock(); if (NULL==reply) { printf("%s","redis_client set fail, network error"); if (rc) { redisFree(rc); } mutex_.lock(); fail_count+=1; mutex_.unlock(); continue; } //printf("type=%d, str=%s\n", reply->type, reply->str); if( !(reply->type == REDIS_REPLY_STATUS && strcasecmp(reply->str,"OK")==0)) { printf("%s","redis_client set fail"); freeReplyObject(reply); mutex_.lock(); fail_count+=1; mutex_.unlock(); continue; } mutex_.lock(); suc_count+=1; mutex_.unlock(); freeReplyObject(reply); } usleep(500);//500us } }
int main(int argc, char * argv[]) { opts_dump_t opts = {{DEFAULT_HOST, DEFAULT_PORT, NULL, DEFAULT_DBNUM}, DEFAULT_KEYS_FILTER}; parse_argv_for_dump(argc, argv, &opts); redisContext * conn = connect_to_redis(&(opts.base)); redisReply * keys_rply, * dump_rply; char * cmd = (char*) malloc(CMD_SIZE); int unsigned i; char * dump_str; long long ttl; sprintf(cmd, "KEYS %s", opts.keys_filter); keys_rply = process_redis_command(conn, cmd); for (i = 0; i < keys_rply->elements; ++i) { sprintf(cmd, "PTTL %s", keys_rply->element[i]->str); dump_rply = process_redis_command(conn, cmd); ttl = dump_rply->integer; if (ttl < 0) ttl = 0; freeReplyObject(dump_rply); sprintf(cmd, "DUMP %s", keys_rply->element[i]->str); dump_rply = process_redis_command(conn, cmd); dump_str = (char*) malloc(dump_rply->len * 2 + 1); bin2hex(dump_rply->str, dump_rply->len, dump_str); freeReplyObject(dump_rply); printf("%s %lld %s\n", keys_rply->element[i]->str, ttl, dump_str); free(dump_str); } freeReplyObject(keys_rply); redisFree(conn); return EXIT_SUCCESS; }
void IncrementWiserCosts(int as1, int as2, int increment_by){ redisContext *c; redisReply* reply; char* key = malloc(100); char* increment_by_str = malloc(100); char* command = malloc(100); // zero out so that strings is guranteed to be null terminated memset(key, 0, 100); memset(increment_by_str, 0, 100); memset(command, 0, 100); sprintf(key, "%i-%i", as1, as2); sprintf(increment_by_str, "%i", increment_by); sprintf(command, "INCRBY %s %s", key, increment_by_str); zlog_debug("dbgp_lookup::IncrementWiserCosts: Command sent to Redis: %s", command); c = connect_to_redis(); /* reply = redisCommand(c, "INCRBY %s %s", *key, *increment_by_str); */ reply = redisCommand(c, command); if (reply->type == REDIS_REPLY_ERROR) { zlog_err("dbgp_lookup::IncrementWiserCosts: failed to increment wiser costs for key %s", key); assert(0); } // free dynamically allocated memory. free(reply); free(c); free(command); free(increment_by_str); free(key); }
int main(int argc, char * argv[]) { opts_restore_t opts = {{DEFAULT_HOST, DEFAULT_PORT, NULL, DEFAULT_DBNUM}, STRATEGY_NONE}; parse_argv_for_restore(argc, argv, &opts); redisContext * conn = connect_to_redis(&(opts.base)); redisReply * rply; int unsigned i = 0, j = 0; char * key = (char*) malloc(KEY_SIZE + 1); char * dump_str = (char* ) malloc(BUFF_SIZE + 1); char * dump_bin = (char* ) malloc(BUFF_SIZE + 1); char * ttl = (char*) malloc(KEY_SIZE + 1); const char * rstr_argv[4] = {"RESTORE", key, ttl, dump_bin}; size_t rstr_argvlen[4] = {7, 0, 0, 0}; char * cmd = (char*) malloc(CMD_SIZE + 1); short int key_exists = 0; FILE * fin = fdopen(0, "r"); if (fin == NULL) { fprintf(stderr, "error: %s", strerror(errno)); return EXIT_FAILURE; } if (opts.strategy == STRATEGY_FLUSH) { rply = process_redis_command(conn, "FLUSHDB"); freeReplyObject(rply); }; while (!feof(fin)) { ++i; j = fscanf(fin, "%s %s %s", key, ttl, dump_str); if (j != 3) { if (j != EOF) { fprintf(stderr, "#%d error: %s\n", i, strerror(errno)); } continue; } if (opts.strategy == STRATEGY_IGNORE) { sprintf(cmd, "EXISTS %s", key); rply = process_redis_command(conn, cmd); key_exists = rply->integer; freeReplyObject(rply); if (key_exists) continue; } if (opts.strategy == STRATEGY_REPLACE) { sprintf(cmd, "DEL %s", key); rply = process_redis_command(conn, cmd); freeReplyObject(rply); } hex2bin(dump_str, dump_bin); rstr_argvlen[1] = strlen(key); rstr_argvlen[2] = strlen(ttl); rstr_argvlen[3] = strlen(dump_str) / 2; rply = redisCommandArgv(conn, 4, rstr_argv, rstr_argvlen); if (rply == NULL) { fprintf(stderr, "#%d connection error: %s\n", i, conn->errstr); exit(EXIT_FAILURE); } if (rply->type == REDIS_REPLY_ERROR) { fprintf(stderr, "#%d Redis error: %s\n", i, rply->str); } freeReplyObject(rply); } redisFree(conn); return EXIT_SUCCESS; }