memcached_st *
sstack_memcache_init(const char *config, int num_servers, log_ctx_t *ctx)
{
memcached_server_st *servers = NULL;
memcached_st *memc = NULL;
memcached_return_t rc;
memc = memcached_create(NULL);
if (NULL == memc) {
sfs_log(ctx, SFS_ERR, "%s: Unable to create memcached connection\n",
__FUNCTION__);
return NULL;
}
if (num_servers > 1) {
char *buf = strdup(config);
char **ptr = (char **) &buf;
char *server_name = NULL;
while((server_name = strsep(ptr, SEPERATOR)) != NULL) {
if (strlen(server_name) == 0)
continue;
servers = memcached_server_list_append(servers, server_name,
MEMCACHED_PORT, &rc);
rc = memcached_server_push(memc, servers);
if (rc != MEMCACHED_SUCCESS) {
sfs_log(ctx, SFS_ERR, "%s: memcached_server_push failed\n",
__FUNCTION__);
return NULL;
}
}
free(buf);
} else {
servers = memcached_server_list_append(servers, config,
MEMCACHED_PORT, &rc);
rc = memcached_server_push(memc, servers);
if (rc != MEMCACHED_SUCCESS) {
sfs_log(ctx, SFS_ERR, "%s: memcached_server_push failed\n",
__FUNCTION__);
return NULL;
}
}
sfs_log(ctx, SFS_INFO, "%s: memcached init succeeded\n", __FUNCTION__);
return memc;
}
void
BeatBoard::ApiMemcached::setUpMemcached( const std::string& memcached_host,
const int memcached_port )
{
memcached_server_st *servers;
memcached_return rc;
memcached_status = false;
memc = memcached_create(NULL);
servers = memcached_server_list_append(NULL, memcached_host.c_str(),
memcached_port, &rc);
if (rc != MEMCACHED_SUCCESS) {
std::cerr << memcached_strerror(memc, rc) << std::endl;
return;
}
rc = memcached_server_push(memc, servers);
if (rc != MEMCACHED_SUCCESS) {
std::cerr << memcached_strerror(memc, rc) << std::endl;
return;
}
memcached_server_list_free(servers);
memcached_status = true;
}
/* added by Wakamori */
static void opt_logcached(int mode, const char *optstr)
{
#if defined(HAVE_LIBMEMCACHED)
knh_syslog = memcached_syslog;
knh_vsyslog = memcached_vsyslog;
kbytes_t host_port = B(optstr);
kbytes_t host = knh_bytes_head(host_port, ':');
kint_t port;
if (!knh_bytes_parseint(knh_bytes_next(host_port, ':'), &port)) {
KNH_DIE("konoha: invalid arguments.");
}
memc = memcached_create(NULL);
char tmp = host.buf[host.len];
host.buf[host.len] = '\0';
memcached_return rc;
memcached_server_list_st servers;
servers = memcached_server_list_append(NULL, host.text, port, &rc);
if (rc != MEMCACHED_SUCCESS) {
KNH_DIE("konoha: cannot append a memcached server.");
}
host.buf[host.len] = tmp;
rc = memcached_server_push(memc, servers);
if (rc != MEMCACHED_SUCCESS) {
KNH_DIE("konoha: cannot push a memcached server.");
}
memcached_server_list_free(servers);
#else
KNH_DIE("konoha: memcached library is not installed.");
#endif /* defined(HAVE_LIBMEMCACHED) */
}
/* create a memcached structure */
static memcached_st *memc_new()
{
char config_string[1024];
memcached_st *memc = NULL;
memcached_server_st *servers = NULL;
unsigned long long getter;
memcached_return_t rc;
pthread_mutex_lock (&printmutex);
sprintf(config_string, "--SERVER=%s --BINARY-PROTOCOL", serverip);
printf("config_string = %s\n", config_string);
//memc = memcached(config_string, strlen(config_string));
memc = memcached_create(NULL);
servers = memcached_server_list_append(servers, serverip, 11211, &rc);
rc = memcached_server_push(memc, servers);
if (rc == MEMCACHED_SUCCESS)
fprintf(stderr, "Added server successfully\n");
else
fprintf(stderr, "Couldnt add server: %s\n", serverip);
getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
printf("No block: %lld\n", getter);
getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
printf("Socket send size: %lld\n", getter);
getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
printf("Socket recv size: %lld\n", getter);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
pthread_mutex_unlock (&printmutex);
return memc;
}
int main(int argc, char **argv)
{
if(argc < 2) {
fprintf(stderr, "usage: %s 'script.k'\n", argv[0]);
return 1;
}
memcached_st *mc = memcached_create(NULL);
memcached_server_list_st servers;
memcached_return_t rc;
servers = memcached_server_list_append(NULL, "127.0.0.1", 11211, &rc);
if(rc != MEMCACHED_SUCCESS) {
fprintf(stderr, "memcached_server_list_append failed\n");
}
rc = memcached_server_Push(mc, servers);
memcached_server_list_Free(servers);
logpool_t *logpool = logpool_open_client(NULL, "0.0.0.0", 14801);
size_t script_len;
char *script = loadFile(argv[1], &script_len);
memcached_set(mc, "dump_Init", strlen("dump_Init"), script, script_len, 0, 0);
logpool_procedure(logpool, "dump", strlen("dump"));
struct Log *logbuf = alloca(sizeof(struct Log) + 256);
while(1) {
if(logpool_client_get(logpool, logbuf, 256) == NULL) {
break;
}
log_dump(stderr, "log=(", logbuf, ")\n", 1);
usleep(1);
}
logpool_close(logpool);
free(script);
return 0;
}
int main(int argc, char **argv)
{
memcached_server_st *servers = NULL;
memcached_st *memc;
memcached_return rc;
char *key, *value;
size_t value_length;
memc = memcached_create(NULL);
servers = memcached_server_list_append(servers, "localhost", 11211, &rc);
rc = memcached_server_push(memc, servers);
if (rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcache: error: couldn't add server: %s\n.",
memcached_strerror(memc, rc));
memcached_free(memc);
return 1;
}
if (argc == 3) // Insert (key, value) pair
{
key = argv[1];
value = argv[2];
rc = memcached_set(memc, key, strlen(key), value, strlen(value),
(time_t)0, (uint32_t)0);
if (rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcache: error: couldn't store key: %s\n.",
memcached_strerror(memc, rc));
memcached_free(memc);
return 2;
}
}
else if (argc == 2) // Get value given key
{
key = argv[1];
value = memcached_get(memc, key, strlen(key), &value_length,
(uint32_t)0, &rc);
if (rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcache: error: couldn't get key: %s.\n",
memcached_strerror(memc, rc));
memcached_free(memc);
return 3;
}
printf("%s\n", value);
}
else
{
fprintf(stderr, "usage: memcache <key> [<value>]\n");
}
memcached_free(memc);
return 0;
}
void *logpool_memcache_init(logpool_t *ctx, logpool_param_t *p)
{
struct logpool_param_memcache *args = cast(struct logpool_param_memcache *, p);
const char *host = args->host;
long port = args->port;
mc_t *mc = cast(mc_t *, logpool_string_init(ctx, p));
memcached_return_t rc;
memcached_server_list_st servers;
mc->st = memcached_create(NULL);
#if 0
memcached_behavior_set (mc->st, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
#endif
#ifdef USE_BUFFER_REQ
memcached_behavior_set (mc->st, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
#endif
if (unlikely(mc->st == NULL)) {
/* TODO Error */
abort();
}
servers = memcached_server_list_append(NULL, host, port, &rc);
if (unlikely(rc != MEMCACHED_SUCCESS)) {
/* TODO Error */
fprintf(stderr, "Error!! '%s'\n", memcached_strerror(mc->st, rc));
abort();
}
rc = memcached_server_push(mc->st, servers);
if (unlikely(rc != MEMCACHED_SUCCESS)) {
/* TODO Error */
fprintf(stderr, "Error!! '%s'\n", memcached_strerror(mc->st, rc));
abort();
}
memcached_server_list_free(servers);
return cast(void *, mc);
}
bool ProxyConnPool::Reset() {
MCE_WARN("ProxyConnPool Reset(). index=" << proxy_index_);
{
IceUtil::Mutex::Lock lock(mutex_);
if (reseting) {
return true;
}
reseting = true;
while (!memc_pool_.empty()) {
memcached_free(memc_pool_.back());
memc_pool_.pop_back();
}
}
string endpoint;
try {
endpoint = MemcProxyAdapter::instance().GetEndpoint(proxy_index_);
} catch(Ice::Exception& e) {
MCE_WARN("MemcProxyAdapter::GetEndpoint Ice error : " << e);
} catch (...) {
MCE_WARN("MemcProxyAdapter::GetEndpoint error.");
}
size_t pos = endpoint.find(':');
if (pos != string::npos) {
proxy_addr_ = endpoint.substr(0, pos);
proxy_port_ = boost::lexical_cast<unsigned short>(endpoint.c_str() + pos + 1);
}
MCE_INFO("MemcProxy " << proxy_index_ << " endpoint : " << endpoint);
if (proxy_addr_.empty() || proxy_port_ <= 0) {
reseting = false;
return false;
}
memcached_return rc;
memcached_server_st * servers = NULL;
servers = memcached_server_list_append(servers, proxy_addr_.c_str(), proxy_port_, &rc);
memcached_st * memc = memcached_create(NULL);
rc = memcached_server_push(memc, servers); // 向服务集群添加server list
if (rc != MEMCACHED_SUCCESS) {
reseting = false;
return false;
}
{
IceUtil::Mutex::Lock lock(mutex_);
memc_pool_.push_back(memc);
reseting = false;
}
error_count_ = 0;
return true;
}
int memcached_connect_to_server(char *hostname, int port)
{
memc = memcached_create(NULL);
servers = memcached_server_list_append(NULL, hostname, port, NULL);
memcached_return rc;
rc = memcached_server_push(memc, servers);
memcached_connected = 0;
if (rc == MEMCACHED_SUCCESS)
return 0;
return -1;
}
int db_module_init() {
memcached_return rc;
//memcached_server_st *memcached_servers_parse (char *server_strings);
internal_memc= memcached_create(NULL);
syslog(LOG_INFO, "creating memcached server\n");
internal_servers= memcached_server_list_append(internal_servers, "localhost"/* server name */, 11211/* port */, &rc);
rc= memcached_server_push(internal_memc, internal_servers);
if (rc == MEMCACHED_SUCCESS)
syslog(LOG_INFO, "Added server successfully\n");
else
syslog(LOG_ERR, "Couldn't add server: %s\n",memcached_strerror(internal_memc, rc));
return 0;
}
// return:
// 0:succ 1:fail
int get_to_mc(char *mc_ip, int mc_port, char *mc_key, char *mc_value, size_t mc_value_size)
{
size_t nval = 0;
uint32_t flag = 0;
char *result = NULL;
int ret = 0;
memcached_st *memc = memcached_create(NULL);
memcached_return mrc;
memcached_server_st *mc_servers;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, mc_timeout);
mc_servers= memcached_server_list_append(NULL, mc_ip, atoi(mc_port), &mrc);
log_debug("memcached_server_list_append[%d]:%s:%d", mrc, mc_ip, mc_port);
if (MEMCACHED_SUCCESS == mrc) {
mrc= memcached_server_push(memc, mc_servers);
memcached_server_list_free(mc_servers);
if (MEMCACHED_SUCCESS == mrc) {
result = memcached_get(memc, mc_key, strlen(mc_key), (size_t *)&nval, &flag, &mrc);
if (MEMCACHED_SUCCESS == mrc) {
log_debug("get mc key:%s val:%s succ", mc_key, result);
snprintf(mc_value, mc_value_size, "%s", result);
ret = 0;
} else {
log_error("get mc key:%s val:%s failed:%s", mc_key, mc_value, memcached_strerror(memc, mrc));
ret = 1;
}
if (result != NULL) {
free(result);
result = NULL;
}
memcached_free(memc);
return ret;
}
}
log_error("set_to_mc:%s:%d connect fail:%s", mc_ip, mc_port, memcached_strerror(memc, mrc));
memcached_free(memc);
return 1;
}
int iSetupAndTestMemcached(void)
{
memcached_server_st *servers = NULL;
memcached_return rc;
char *key= "unxsLoadFromSPS";
char *value= "svn ID removed
//memcached_server_st *memcached_servers_parse(const char *server_strings);
gsMemc=memcached_create(NULL);
servers=memcached_server_list_append(servers,"localhost",11211,&rc);
rc=memcached_server_push(gsMemc, servers);
if(rc!=MEMCACHED_SUCCESS)
{
sprintf(gcQuery,"couldn't add server: %s",memcached_strerror(gsMemc, rc));
logfileLine("iSetupAndTestMemcached",gcQuery);
return(-1);
}
rc=memcached_set(gsMemc,key,strlen(key),value,strlen(value),(time_t)0,(uint32_t)0);
if(rc!=MEMCACHED_SUCCESS)
{
sprintf(gcQuery,"couldn't store test key: %s",memcached_strerror(gsMemc, rc));
logfileLine("iSetupAndTestMemcached",gcQuery);
return(-1);
}
char cValue[100]={""};
size_t size=100;
uint32_t flags=0;
sprintf(cValue,"%.99s",memcached_get(gsMemc,key,strlen(key),&size,&flags,&rc));
if(rc!=MEMCACHED_SUCCESS)
{
sprintf(gcQuery,"couldn't retrieve test key: %s",memcached_strerror(gsMemc, rc));
logfileLine("iSetupAndTestMemcached",gcQuery);
return(-1);
}
if(strncmp(cValue,value,size))
{
sprintf(gcQuery,"keys differ: (%s) (%s)",cValue,value);
logfileLine("iSetupAndTestMemcached",gcQuery);
return(-1);
}
logfileLine("iSetupAndTestMemcached","memcached running");
return(0);
}//int iSetupAndTestMemcached(void)
void inicializarMemcached() {
if (cache != 0) {
extern memcached_st *memcached;
memcached_server_st *servers = NULL;
memcached_return resultado;
memcached = memcached_create(NULL);
servers = memcached_server_list_append(servers, ipCache, puertoCache,
&resultado);
resultado = memcached_server_push(memcached, servers);
if (resultado == MEMCACHED_SUCCESS)
printf("Ahora esta conectado a Memcached\n");
else
printf("No se pudo conectar");
}
}
static memcached_st *new_memcached(const char *host)
{
int port = 11211;
memcached_return rc;
memcached_st *memc = memcached_create(NULL);
memcached_server_st *servers = memcached_server_list_append(NULL, host, port, &rc);
if (rc != MEMCACHED_SUCCESS) {
fprintf(stderr, "%s\n", memcached_strerror(memc, rc));
return 0;
}
rc = memcached_server_push(memc, servers);//servers ==> memc
if (rc != MEMCACHED_SUCCESS) {
fprintf(stderr, "%s\n", memcached_strerror(memc, rc));
return 0;
}
memcached_server_list_free(servers);
return memc;
}
static const char* append_server(cmd_parms* parms, void* _conf, const char* w1, const char* w2)
{
memcached_return r;
resize_conf* conf = (resize_conf*)_conf;
memcached_server_st* servers;
int port = atoi(w2);
if(port<=0 || port>65535) return "Bad port number.";
servers = memcached_server_list_append(NULL, w1, port, &r);
if(r!=MEMCACHED_SUCCESS) return "memcached_server_list_append() failed.";
r = memcached_server_push(conf->memc, servers);
if(r!=MEMCACHED_SUCCESS) {
memcached_server_list_free(servers);
return "memcached_server_push() failed.";
}
memcached_server_list_free(servers);
return NULL;
}
/**
* 从字符串创建memcacheq的实例
* params:
* addr: eg. 127.0.0.1:22201
* return memcacheq instance
**/
static memcached_st * create_memcacheq_from_str(const char *addr)
{
if (addr == NULL)
return NULL;
memcached_return rc;
memcached_st* ret = memcached_create(NULL);
memcached_server_st *servers = NULL;
int port;
char *ip;
get_addr_from_str(addr, &ip, &port);
fprintf(stderr, "addr:port is %s-> %s:%d\n", addr, ip, port);
servers = memcached_server_list_append(NULL, ip, port, &rc);
free(ip);
if (rc != MEMCACHED_SUCCESS)
{
memcached_free(ret);
return NULL;
}
memcached_server_push(ret, servers);
memcached_server_free(servers);
return ret;
}
//init Server
int ssMemcached::initServer(char *pServerInfo, int nPort) {
servers_ = memcached_server_list_append(servers_, pServerInfo, nPort, &retCode_);
retCode_ = memcached_server_push(memc_, servers_);
if (retCode_ == MEMCACHED_SUCCESS) {
//fprintf(stderr,"Added server successfully\n");
}
else {
fprintf(stderr, "Couldn't add server: %s\n", memcached_strerror(memc_, retCode_));
return 0;
}
//connect timeout
memcached_behavior_set(memc_, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 100);
//read timeout
memcached_behavior_set(memc_, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 200);
//write timeout
memcached_behavior_set(memc_, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 200);
memcached_behavior_set(memc_, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 400);
return 1;
}
void *bench_new(int queue, int iq, int type)
{
memcached_server_st *servers = NULL;
memcached_st *memc;
memcached_return rc;
char key[7];
char value[10];
int i = 0;
memcached_server_st *memcached_servers_parse (char *server_strings);
memc= memcached_create(NULL);
servers= memcached_server_list_append(servers, "127.0.0.1", 11212, &rc);
rc= memcached_server_push(memc, servers);
if (rc != MEMCACHED_SUCCESS)
return NULL;
sprintf(key, "queue%d", queue);
/* printf("%s\n", key); */
for(i = 0 ; i < iq; i++)
{
sprintf(value, "value%d", i);
if (type == 1) /* Test set */
memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0);
else /* Test get */
memcached_get (memc, key, strlen(key), (size_t *)strlen(value), (uint32_t)0, &rc);
}
return NULL;
}
// LogPool LogPool.loadFile(String key, String file);
static KMETHOD LogPool_loadFile(KonohaContext *kctx, KonohaStack *sfp)
{
logpool_t *lp = (logpool_t *) ((kRawPtr *) sfp[0].asObject)->rawptr;
kString *key = sfp[1].asString;
kString *file = sfp[2].s;
memcached_st *mc = memcached_create(NULL);
memcached_server_list_st servers;
memcached_return_t rc;
servers = memcached_server_list_append(NULL, "127.0.0.1", 11211, &rc);
if (rc != MEMCACHED_SUCCESS) {
fprintf(stderr, "memcached_server_list_append failed\n");
RETURNvoid_();
}
rc = memcached_server_push(mc, servers);
memcached_server_list_free(servers);
size_t len;
char *script = loadFile(S_text(file), &len);
memcached_set(mc, S_text(key), S_size(key), script, len, 0, 0);
logpool_procedure(lp, (char*)S_text(key), S_size(key));
free(script);
RETURNvoid_();
}
//Remove -gw and -did keys that are no longer in db
void DelOldKeys(char const *cCluster)
{
memcached_return rc;
if(!guSilent) printf("DelOldKeys() start\n");
unsigned uCluster=uGetCluster(cCluster);
if(!uCluster)
{
logfileLine("DelOldKeys cluster not found",cCluster);
return;
}
void vKeyPrinter(const memcached_st *gsMemc, const char *cKey)
{
MYSQL_RES *res;
char *cp;
unsigned uRc;
memcached_st *gsLocalMemc;
memcached_server_st *servers = NULL;
gsLocalMemc=memcached_create(NULL);
servers=memcached_server_list_append(servers,"localhost",11211,&rc);
rc=memcached_server_push(gsLocalMemc,servers);
if(rc!=MEMCACHED_SUCCESS)
{
sprintf(gcQuery,"couldn't add server: %s",memcached_strerror(gsLocalMemc,rc));
logfileLine("vKeyPrinter",gcQuery);
if(!guSilent) printf("%s\n",gcQuery);
return;
}
if(strstr(cKey,"-did"))
{
if((cp=strchr(cKey,'-')))
*cp=0;
if(!guSilent) printf("%s-did\n",cKey);
sprintf(gcQuery,"SELECT uDID FROM tDID WHERE cDID='%s' AND uCluster=%u",cKey,uCluster);
mysql_query(&gMysql,gcQuery);
if(mysql_errno(&gMysql))
{
printf(gcQuery);
logfileLine("DelOldKeys",mysql_error(&gMysql));
mysql_close(&gMysql);
exit(2);
}
res=mysql_store_result(&gMysql);
if(mysql_num_rows(res)<1)
{
*cp='-';
uRc=memcached_delete(gsLocalMemc,cKey,strlen(cKey),(time_t)0);
if(uRc!=MEMCACHED_SUCCESS)
{
if(guLogLevel>2)
{
logfileLine("DelOldKeys not found",cKey);
}
if(!guSilent) printf("DelOldKeys() %s not found\n",cKey);
}
else
{
if(guLogLevel>2)
{
logfileLine("DelOldKeys",cKey);
}
if(!guSilent) printf("DelOldKeys() %s\n",cKey);
}
}
}
else if(strstr(cKey,"-gw"))
{
unsigned uPort=5060;
char *cp2=NULL;
if((cp=strchr(cKey,'-')))
*cp=0;
if((cp2=strchr(cKey,':')))
{
*cp2=0;
sscanf(cp2+1,"%u",&uPort);
}
if(!guSilent)
{
if(cp2)
printf("%s:%u-gw\n",cKey,uPort);
else
printf("%s-gw\n",cKey);
}
sprintf(gcQuery,"SELECT tAddress.uAddress FROM tAddress,tGateway,tPBX"
" WHERE tAddress.cIP='%s' AND tAddress.uPort=%u"
" AND ("
" ( tAddress.uGateway=tGateway.uGateway"
" AND tGateway.uCluster=%u"
" ) OR ("
" ( tAddress.uPBX=tPBX.uPBX"
" AND tPBX.uCluster=%u) )"
" )",cKey,uPort,uCluster,uCluster);
mysql_query(&gMysql,gcQuery);
if(mysql_errno(&gMysql))
{
printf(gcQuery);
logfileLine("DelOldKeys",mysql_error(&gMysql));
mysql_close(&gMysql);
exit(2);
}
res=mysql_store_result(&gMysql);
if(mysql_num_rows(res)<1)
{
*cp='-';
if(cp2)
*cp2=':';
uRc=memcached_delete(gsLocalMemc,cKey,strlen(cKey),(time_t)0);
if(uRc!=MEMCACHED_SUCCESS)
{
if(guLogLevel>2)
{
logfileLine("DelOldKeys not found",cKey);
}
if(!guSilent) printf("DelOldKeys() %s not found\n",cKey);
}
else
{
if(guLogLevel>2)
{
logfileLine("DelOldKeys",cKey);
}
if(!guSilent) printf("DelOldKeys() %s\n",cKey);
}
}
}
}
int main(int argc, char **argv)
{
struct nfq_handle *h;
struct nfq_q_handle *qh;
int fd;
int rv;
char buf[4096] __attribute__ ((aligned));
printf("Obteniendo el handle de la libreria: ");
h = nfq_open();
if (!h)
{
fprintf(stderr, "Ha fallado\n");
exit(1);
}
else printf(" OK !\n");
printf("Haciendo unbind (por si existe alguno de AF_INET): ");
if (nfq_unbind_pf(h, AF_INET) < 0)
{
fprintf(stderr, "error nfq_unbind_pf()\n");
exit(1);
}
else printf(" OK!\n");
printf("Vinculando nfnetlink_queue de tipo nf_queue handler para AF_INET:");
if (nfq_bind_pf(h, AF_INET) < 0)
{
fprintf(stderr, "error nfq_bind_pf()\n");
exit(1);
}
else printf(" OK!\n");
printf("Creando la vinculacion de la funcion callback con Queue 0, socket receptor: ");
qh = nfq_create_queue(h, 0, &cb, NULL);
if (!qh) {
fprintf(stderr, "error during nfq_create_queue()\n");
exit(1);
}
else printf(" OK !\n");
printf("Definiendo que cantidad de paquete queremos recibir (no queremos todo para estas pruebas): ");
if (nfq_set_mode(qh, NFQNL_COPY_PACKET, 0xffff) < 0) {
fprintf(stderr, "FALLO el COPY_META mode\n");
exit(1);
}
else printf("OK\n");
fd = nfq_fd(h);
printf("Realizando conexión a memcache: ");
memc= memcached_create(NULL);
servers= memcached_server_list_append(servers, "localhost", 11211, &rc);
rc= memcached_server_push(memc, servers);
if (rc == MEMCACHED_SUCCESS)
printf(" OK ! \n");
else {
printf("error conectando a memcache: %s\n",memcached_strerror(memc, rc));
exit(0);
}
printf("Realizando INIT de MySQL: ");
con = mysql_init(NULL);
if (con == NULL)
{
printf(" FAIL\n");
exit(1);
}
else printf("OK\n");
printf("Realizando Conexion a MYQSL: ");
if (mysql_real_connect(con, "localhost", "root", "FIXMEPASSWORD", "nfqueue", 0, NULL, 0) == NULL)
{
printf(" FAILED\n");
exit(1);
}
else printf(" OKI\n");
printf("Todo Listo !\n Entrando en bucle principal de recepcion ..\n");
while ((rv = recv(fd, buf, sizeof(buf), 0)))
{
// Si todo ha ido bien, gestionamos el paquete:
if (rv>=0)
nfq_handle_packet(h, buf, rv);
// es posible que tengamos packet loss porque
// nuestro codigo es lento y se llena la queue:
else if ( errno == ENOBUFS)
{
fflush(stdout);
printf("!");
}
// O "simplemente", que algo haya ido mal:
else {
printf("ERROR \n");
fflush(stdout);
break;
}
}
// Teoricamente, nunca llegaremos aqui, pero si llegamos
// Habra que liberar bien y tal:
printf("unbinding de queue 0\n");
nfq_destroy_queue(qh);
printf("cerrando library handle\n");
nfq_close(h);
exit(0);
}
int main() {
//memcached_t 时client handle
//memcached_return_t 返回的消息类型
memcached_st *memcli = NULL;
//EE create a connect
memcli = memcached_create(NULL); //NULL 为你分配空间
if (memcli == NULL) {
perror("memcached_create failed");
exit(1);
}
memcached_return_t rtmsg ;
//EE connecting to server
//memcached_server_st server handle
//connect memcache server
//加入serverlist
//port
memcached_server_st * memser = memcached_server_list_append(NULL, "127.0.0.1", 11211, &rtmsg);
if (memser == NULL || rtmsg != MEMCACHED_SUCCESS) {
perror("memcached_server_list_append failed");
exit(1);
}
//connect client and server
rtmsg = memcached_server_push(memcli, memser);
if (rtmsg != MEMCACHED_SUCCESS) {
printf(" memcached_server_push faled: %s\n",
memcached_strerror(memcli, rtmsg));
exit(1);
}
//Add v-k to server
char *key = "foll";
char value[] ="hello";
//EE 所有的设置操作
//都是相同的 最后时时间和flags
//len 不包括'\0'结尾
rtmsg = memcached_set(memcli, //client
key, strlen(key), //key and keylen
value, strlen(value), //value, valuelen
(time_t)0, //Experimental time
0); //flags
//EE check rtmsg
if (rtmsg != MEMCACHED_SUCCESS) {
printf(" memcached_set faled: %s\n",
memcached_strerror(memcli, rtmsg));
exit(1);
}
char buf[1024];
//EE get v-k
size_t valuelen=0;
uint32_t flags=0;
char *v = memcached_get(memcli,
key, strlen(key),
&valuelen,
&flags,
&rtmsg);
memcpy(buf, v, valuelen);
buf[valuelen]='\0';
printf("vlen:%ld, flags:%u, value:%s\n", valuelen, flags, buf);
// memcached_return_t //
// memcached_mget (memcached_st *ptr,
// const char * const *keys,
// const size_t *key_length,
// size_t number_of_keys);
//EE free server
memcached_server_free(memser);
//EE free client
memcached_free(memcli);
return 0;
}
static int mcache_ping_servers(pr_memcache_t *mcache) {
memcached_server_st *alive_server_list;
memcached_return res;
memcached_st *clone;
uint32_t server_count;
register unsigned int i;
/* We always start with the configured list of servers. */
clone = memcached_clone(NULL, mcache->mc);
if (clone == NULL) {
errno = ENOMEM;
return -1;
}
memcached_servers_reset(clone);
/* Bug#4242: Don't use memcached_server_push() if we're using
* libmemcached-1.0.18 or earlier. Doing so leads to a segfault, due to
* this libmemcached bug:
*
* https://bugs.launchpad.net/libmemcached/+bug/1154159
*/
#if LIBMEMCACHED_VERSION_HEX > 0x01000018
memcached_server_push(clone, configured_server_list);
#endif
server_count = memcached_server_count(clone);
pr_trace_msg(trace_channel, 16,
"pinging %lu memcached %s", (unsigned long) server_count,
server_count != 1 ? "servers" : "server");
alive_server_list = NULL;
for (i = 0; i < server_count; i++) {
memcached_server_instance_st server;
server = memcached_server_instance_by_position(clone, i);
pr_trace_msg(trace_channel, 17, "pinging server %s:%d",
memcached_server_name(server), memcached_server_port(server));
if (libmemcached_util_ping(memcached_server_name(server),
memcached_server_port(server), &res) == FALSE) {
pr_trace_msg(trace_channel, 4,
"error pinging %s:%d: %s", memcached_server_name(server),
memcached_server_port(server), memcached_strerror(clone, res));
} else {
pr_trace_msg(trace_channel, 17, "server %s:%d is alive",
memcached_server_name(server), memcached_server_port(server));
alive_server_list = memcached_server_list_append(alive_server_list,
memcached_server_name(server), memcached_server_port(server), &res);
if (alive_server_list == NULL) {
pr_trace_msg(trace_channel, 1,
"error appending server %s:%d to list: %s",
memcached_server_name(server), memcached_server_port(server),
memcached_strerror(clone, res));
memcached_free(clone);
errno = EPERM;
return -1;
}
}
}
if (alive_server_list != NULL) {
memcached_servers_reset(mcache->mc);
res = memcached_server_push(mcache->mc, alive_server_list);
if (res != MEMCACHED_SUCCESS) {
unsigned int count;
count = memcached_server_list_count(alive_server_list);
pr_trace_msg(trace_channel, 2,
"error adding %u alive memcached %s to connection: %s",
count, count != 1 ? "servers" : "server",
memcached_strerror(mcache->mc, res));
memcached_free(clone);
errno = EPERM;
return -1;
} else {
unsigned int count;
count = memcached_server_list_count(alive_server_list);
pr_trace_msg(trace_channel, 9,
"now using %d alive memcached %s", count,
count != 1 ? "servers" : "server");
memcached_server_list_free(alive_server_list);
}
}
memcached_free(clone);
return 0;
}
/*!
* \brief Module initialization function
* \return 0 on success, -1 on failure
*/
static int mod_init(void) {
char *server, *port;
unsigned int len = 0;
memcached_return rc;
struct memcached_server_st *svt;
if ((port = strchr(mcd_srv_str, ':')) != NULL) {
port = port + 1;
len = strlen(mcd_srv_str) - strlen(port) - 1;
} else {
LM_DBG("no port definition, using default port\n");
port = "11211";
len = strlen(mcd_srv_str) ;
}
server = pkg_malloc(len+1);
if (server == NULL) {
PKG_MEM_ERROR;
return -1;
}
strncpy(server, mcd_srv_str, len);
server[len] = '\0';
memcached_h = memcached_create(NULL);
if (memcached_h == NULL) {
LM_ERR("could not create memcached structure\n");
pkg_free(server);
return -1;
}
LM_DBG("allocated new server handle at %p", memcached_h);
if (mcd_memory == 1) {
LM_INFO("Use internal kamailio memory manager for memcached client library\n");
#if LIBMEMCACHED_VERSION_HEX >= 0x00038000
rc = memcached_set_memory_allocators(memcached_h, (memcached_malloc_fn)mcd_malloc,
(memcached_free_fn)mcd_free, (memcached_realloc_fn)mcd_realloc,
(memcached_calloc_fn)mcd_calloc, NULL);
#else
rc = memcached_set_memory_allocators(memcached_h, (memcached_malloc_function)mcd_malloc_compat,
(memcached_free_function)mcd_free_compat, (memcached_realloc_function)mcd_realloc_compat,
(memcached_calloc_function)mcd_calloc_compat);
#endif
if (rc == MEMCACHED_SUCCESS) {
LM_DBG("memory manager callbacks set\n");
} else {
LM_ERR("memory manager callbacks not set, returned %s.\n", memcached_strerror(memcached_h, rc));
pkg_free(server);
return -1;
}
} else {
LM_INFO("Use system memory manager for memcached client library\n");
}
svt = memcached_server_list_append(servers, server, atoi(port), &rc);
if(svt==NULL) {
LM_ERR("failed to append server\n");
if(servers) {
memcached_server_list_free(servers);
servers = NULL;
}
pkg_free(server);
return -1;
}
servers = svt;
if (memcached_behavior_set(memcached_h, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, mcd_timeout) != MEMCACHED_SUCCESS) {
LM_ERR("could not set server connection timeout\n");
pkg_free(server);
return -1;
}
rc = memcached_server_push(memcached_h, servers);
if (rc == MEMCACHED_SUCCESS) {
LM_DBG("added server list to structure\n");
} else {
LM_ERR("attempt to add server list to structure returned %s.\n", memcached_strerror(memcached_h, rc));
pkg_free(server);
return -1;
}
pkg_free(server);
/** \todo FIXME logic to handle connection errors on startup
memcached_server_cursor(memcached_h, (const memcached_server_fn*) &mcd_check_connection, NULL, 1);
*/
LM_INFO("libmemcached version is %s\n", memcached_lib_version());
return 0;
}
