int main(int argc, char *argv[])
{
memcached_st *memc;
memcached_return rc;
memcached_server_st *servers;
options_parse(argc, argv);
if (!opt_servers)
{
char *temp;
if ((temp= getenv("MEMCACHED_SERVERS")))
opt_servers= strdup(temp);
else
{
fprintf(stderr, "No Servers provided\n");
exit(1);
}
}
memc= memcached_create(NULL);
process_hash_option(memc, opt_hash);
servers= memcached_servers_parse(opt_servers);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, opt_binary);
while (optind < argc)
{
if (opt_verbose)
printf("key: %s\nexpires: %llu\n", argv[optind], (unsigned long long)opt_expire);
rc = memcached_delete(memc, argv[optind], strlen(argv[optind]), opt_expire);
if (rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memrm: %s: memcache error %s",
argv[optind], memcached_strerror(memc, rc));
if (memc->cached_errno)
fprintf(stderr, " system error %s", strerror(memc->cached_errno));
fprintf(stderr, "\n");
}
optind++;
}
memcached_free(memc);
if (opt_servers)
free(opt_servers);
if (opt_hash)
free(opt_hash);
return 0;
}
int main(int argc, char *argv[])
{
memcached_st *memc;
char *string;
size_t string_length;
uint32_t flags;
memcached_return_t rc;
memcached_server_st *servers;
int return_code= 0;
options_parse(argc, argv);
if (!opt_servers)
{
char *temp;
if ((temp= getenv("MEMCACHED_SERVERS")))
opt_servers= strdup(temp);
else
{
fprintf(stderr, "No Servers provided\n");
exit(1);
}
}
memc= memcached_create(NULL);
process_hash_option(memc, opt_hash);
servers= memcached_servers_parse(opt_servers);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
(uint64_t)opt_binary);
while (optind < argc)
{
string= memcached_get(memc, argv[optind], strlen(argv[optind]),
&string_length, &flags, &rc);
if (rc == MEMCACHED_SUCCESS)
{
if (opt_displayflag)
{
if (opt_verbose)
printf("key: %s\nflags: ", argv[optind]);
printf("%x\n", flags);
}
else
{
if (opt_verbose)
printf("key: %s\nflags: %x\nlength: %zu\nvalue: ",
argv[optind], flags, string_length);
printf("%.*s\n", (int)string_length, string);
free(string);
}
}
else if (rc != MEMCACHED_NOTFOUND)
{
fprintf(stderr, "memcat: %s: memcache error %s",
argv[optind], memcached_strerror(memc, rc));
if (memc->cached_errno)
fprintf(stderr, " system error %s", strerror(memc->cached_errno));
fprintf(stderr, "\n");
return_code= -1;
break;
}
else // Unknown Issue
{
fprintf(stderr, "memcat: %s not found\n", argv[optind]);
return_code= -1;
}
optind++;
}
memcached_free(memc);
if (opt_servers)
free(opt_servers);
if (opt_hash)
free(opt_hash);
return return_code;
}
int main(int argc, char *argv[])
{
memcached_st *memc;
memcached_return_t rc;
memcached_server_st *servers;
memcached_dump_fn callbacks[1];
callbacks[0]= &key_printer;
options_parse(argc, argv);
memc= memcached_create(NULL);
process_hash_option(memc, opt_hash);
if (!opt_servers)
{
char *temp;
if ((temp= getenv("MEMCACHED_SERVERS")))
opt_servers= strdup(temp);
else
{
fprintf(stderr, "No Servers provided\n");
exit(1);
}
}
if (opt_servers)
servers= memcached_servers_parse(opt_servers);
else
servers= memcached_servers_parse(argv[--argc]);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
(uint64_t)opt_binary);
if (!initialize_sasl(memc, opt_username, opt_passwd))
{
memcached_free(memc);
return EXIT_FAILURE;
}
rc= memcached_dump(memc, callbacks, NULL, 1);
if (rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memdump: memcache error %s", memcached_strerror(memc, rc));
if (memcached_last_error_errno(memc))
fprintf(stderr, " system error %s", strerror(memcached_last_error_errno(memc)));
fprintf(stderr, "\n");
}
memcached_free(memc);
if (opt_servers)
free(opt_servers);
if (opt_hash)
free(opt_hash);
shutdown_sasl();
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
memcached_st *memc;
memcached_return_t rc;
memcached_server_st *servers;
int return_code= 0;
options_parse(argc, argv);
initialize_sockets();
memc= memcached_create(NULL);
process_hash_option(memc, opt_hash);
if (!opt_servers)
{
char *temp;
if ((temp= getenv("MEMCACHED_SERVERS")))
{
opt_servers= strdup(temp);
}
else
{
fprintf(stderr, "No Servers provided\n");
exit(1);
}
}
if (opt_servers)
servers= memcached_servers_parse(opt_servers);
else
servers= memcached_servers_parse(argv[--argc]);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
(uint64_t)opt_binary);
if (!initialize_sasl(memc, opt_username, opt_passwd))
{
memcached_free(memc);
return 1;
}
while (optind < argc)
{
struct stat sbuf;
int fd;
char *ptr;
ssize_t read_length;
char *file_buffer_ptr;
fd= open(argv[optind], O_RDONLY);
if (fd < 0)
{
fprintf(stderr, "memcp: %s: %s\n", argv[optind], strerror(errno));
optind++;
continue;
}
(void)fstat(fd, &sbuf);
ptr= rindex(argv[optind], '/');
if (ptr)
ptr++;
else
ptr= argv[optind];
if (opt_verbose)
{
static const char *opstr[] = { "set", "add", "replace" };
printf("op: %s\nsource file: %s\nlength: %zu\n"
"key: %s\nflags: %x\nexpires: %llu\n",
opstr[opt_method - OPT_SET], argv[optind], (size_t)sbuf.st_size,
ptr, opt_flags, (unsigned long long)opt_expires);
}
if ((file_buffer_ptr= (char *)malloc(sizeof(char) * (size_t)sbuf.st_size)) == NULL)
{
fprintf(stderr, "malloc: %s\n", strerror(errno));
exit(1);
}
if ((read_length= read(fd, file_buffer_ptr, (size_t)sbuf.st_size)) == -1)
{
fprintf(stderr, "read: %s\n", strerror(errno));
exit(1);
}
if (read_length != sbuf.st_size)
{
fprintf(stderr, "Failure reading from file\n");
exit(1);
}
if (opt_method == OPT_ADD)
rc= memcached_add(memc, ptr, strlen(ptr),
file_buffer_ptr, (size_t)sbuf.st_size,
opt_expires, opt_flags);
else if (opt_method == OPT_REPLACE)
rc= memcached_replace(memc, ptr, strlen(ptr),
file_buffer_ptr, (size_t)sbuf.st_size,
opt_expires, opt_flags);
else
rc= memcached_set(memc, ptr, strlen(ptr),
file_buffer_ptr, (size_t)sbuf.st_size,
opt_expires, opt_flags);
if (rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcp: %s: memcache error %s",
ptr, memcached_strerror(memc, rc));
if (memc->cached_errno)
fprintf(stderr, " system error %s", strerror(memc->cached_errno));
fprintf(stderr, "\n");
return_code= -1;
}
free(file_buffer_ptr);
close(fd);
optind++;
}
memcached_free(memc);
if (opt_servers)
free(opt_servers);
if (opt_hash)
free(opt_hash);
shutdown_sasl();
return return_code;
}
int main(int argc, char *argv[])
{
memcached_st *memc;
char *string;
size_t string_length;
uint32_t flags;
memcached_return_t rc;
memcached_server_st *servers;
int return_code= 0;
options_parse(argc, argv);
initialize_sockets();
if (!opt_servers)
{
char *temp;
if ((temp= getenv("MEMCACHED_SERVERS")))
opt_servers= strdup(temp);
else
{
fprintf(stderr, "No Servers provided\n");
exit(1);
}
}
memc= memcached_create(NULL);
process_hash_option(memc, opt_hash);
servers= memcached_servers_parse(opt_servers);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
(uint64_t)opt_binary);
if (!initialize_sasl(memc, opt_username, opt_passwd))
{
memcached_free(memc);
return EXIT_FAILURE;
}
while (optind < argc)
{
string= memcached_get(memc, argv[optind], strlen(argv[optind]),
&string_length, &flags, &rc);
if (rc == MEMCACHED_SUCCESS)
{
if (opt_displayflag)
{
if (opt_verbose)
printf("key: %s\nflags: ", argv[optind]);
printf("%x\n", flags);
}
else
{
if (opt_verbose)
{
printf("key: %s\nflags: %x\nlength: %zu\nvalue: ",
argv[optind], flags, string_length);
}
if (opt_file)
{
FILE *fp;
size_t written;
fp= fopen(opt_file, "w");
if (!fp)
{
perror("fopen");
return_code= -1;
break;
}
written= fwrite(string, 1, string_length, fp);
if (written != string_length)
{
fprintf(stderr, "error writing file (written %zu, should be %zu)\n", written, string_length);
return_code= -1;
break;
}
if (fclose(fp))
{
fprintf(stderr, "error closing file\n");
return_code= -1;
break;
}
}
else
{
printf("%.*s\n", (int)string_length, string);
}
free(string);
}
}
else if (rc != MEMCACHED_NOTFOUND)
{
fprintf(stderr, "memcat: %s: memcache error %s",
argv[optind], memcached_strerror(memc, rc));
if (memcached_last_error_errno(memc))
{
fprintf(stderr, " system error %s", strerror(memcached_last_error_errno(memc)));
}
fprintf(stderr, "\n");
return_code= -1;
break;
}
else // Unknown Issue
{
fprintf(stderr, "memcat: %s not found\n", argv[optind]);
return_code= -1;
}
optind++;
}
memcached_free(memc);
if (opt_servers)
free(opt_servers);
if (opt_hash)
free(opt_hash);
shutdown_sasl();
return return_code;
}
