/* LibMemcached
+ * Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/
* Copyright (C) 2006-2009 Brian Aker
* All rights reserved.
*
*
*/
-#include "config.h"
+#include <mem_config.h>
-#include <stdio.h>
-#include <inttypes.h>
-#include <string.h>
-#include <unistd.h>
+#include <cstdio>
+#include <cstring>
#include <getopt.h>
-#include <libmemcached/memcached.h>
+#include <iostream>
+#include <unistd.h>
+#include <libmemcached-1.0/memcached.h>
#include "utilities.h"
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;
+ int return_code= EXIT_SUCCESS;
options_parse(argc, argv);
initialize_sockets();
- if (!opt_servers)
+ if (opt_servers == NULL)
{
char *temp;
if ((temp= getenv("MEMCACHED_SERVERS")))
+ {
opt_servers= strdup(temp);
- else
+ }
+
+ if (opt_servers == NULL)
{
- fprintf(stderr, "No Servers provided\n");
- exit(1);
+ std::cerr << "No servers provied" << std::endl;
+ exit(EXIT_FAILURE);
}
}
- memc= memcached_create(NULL);
- process_hash_option(memc, opt_hash);
+ memcached_server_st* servers= memcached_servers_parse(opt_servers);
+ if (servers == NULL or memcached_server_list_count(servers) == 0)
+ {
+ std::cerr << "Invalid server list provided:" << opt_servers << std::endl;
+ return EXIT_FAILURE;
+ }
- servers= memcached_servers_parse(opt_servers);
+ memcached_st* memc= memcached_create(NULL);
+ process_hash_option(memc, opt_hash);
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))
+ if (opt_username and LIBMEMCACHED_WITH_SASL_SUPPORT == 0)
{
memcached_free(memc);
+ std::cerr << "--username was supplied, but binary was not built with SASL support." << std::endl;
return EXIT_FAILURE;
}
+ if (opt_username)
+ {
+ memcached_return_t ret;
+ if (memcached_failed(ret= memcached_set_sasl_auth_data(memc, opt_username, opt_passwd)))
+ {
+ std::cerr << memcached_last_error_message(memc) << std::endl;
+ memcached_free(memc);
+ return EXIT_FAILURE;
+ }
+ }
+
while (optind < argc)
{
string= memcached_get(memc, argv[optind], strlen(argv[optind]),
if (opt_displayflag)
{
if (opt_verbose)
- printf("key: %s\nflags: ", argv[optind]);
- printf("%x\n", flags);
+ {
+ std::cout << "key: " << argv[optind] << std::endl << "flags: " << flags << std::endl;
+ }
}
else
{
if (opt_verbose)
{
- printf("key: %s\nflags: %x\nlength: %lu\nvalue: ",
- argv[optind], flags, (unsigned long)string_length);
+ std::cout << "key: " << argv[optind] << std::endl << "flags: " << flags << std::endl << "length: " << string_length << std::endl << "value: ";
}
if (opt_file)
{
- FILE *fp;
- size_t written;
-
- fp= fopen(opt_file, "w");
- if (!fp)
+ FILE *fp= fopen(opt_file, "w");
+ if (fp == NULL)
{
perror("fopen");
- return_code= -1;
+ return_code= EXIT_FAILURE;
break;
}
- written= fwrite(string, 1, string_length, fp);
+ size_t written= fwrite(string, 1, string_length, fp);
if (written != string_length)
{
- fprintf(stderr, "error writing file (written %lu, should be %lu)\n", (unsigned long)written, (unsigned long)string_length);
- return_code= -1;
+ std::cerr << "error writing file to file " << opt_file << " wrote " << written << ", should have written" << string_length << std::endl;
+ return_code= EXIT_FAILURE;
break;
}
if (fclose(fp))
{
- fprintf(stderr, "error closing file\n");
- return_code= -1;
+ std::cerr << "error closing " << opt_file << std::endl;
+ return_code= EXIT_FAILURE;
break;
}
}
else
{
- printf("%.*s\n", (int)string_length, string);
+ std::cout.write(string, string_length);
+ std::cout << std::endl;
}
free(string);
}
}
else if (rc != MEMCACHED_NOTFOUND)
{
- fprintf(stderr, "memcat: %s: memcache error %s",
- argv[optind], memcached_strerror(memc, rc));
+ std::cerr << "error on " << argv[optind] << "(" << memcached_strerror(memc, rc) << ")";
if (memcached_last_error_errno(memc))
{
- fprintf(stderr, " system error %s", strerror(memcached_last_error_errno(memc)));
+ std::cerr << " system error (" << strerror(memcached_last_error_errno(memc)) << ")" << std::endl;
}
- fprintf(stderr, "\n");
+ std::cerr << std::endl;
- return_code= -1;
+ return_code= EXIT_FAILURE;
break;
}
else // Unknown Issue
{
- fprintf(stderr, "memcat: %s not found\n", argv[optind]);
- return_code= -1;
+ std::cerr << "error on " << argv[optind] << "("<< memcached_strerror(NULL, rc) << ")" << std::endl;
+ return_code= EXIT_FAILURE;
}
optind++;
}
memcached_free(memc);
if (opt_servers)
+ {
free(opt_servers);
+ }
if (opt_hash)
+ {
free(opt_hash);
-
- shutdown_sasl();
+ }
return return_code;
}
void options_parse(int argc, char *argv[])
{
int option_index= 0;
- int option_rv;
memcached_programs_help_st help_options[]=
{
{
{(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION},
{(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP},
+ {(OPTIONSTRING)"quiet", no_argument, NULL, OPT_QUIET},
{(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE},
{(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG},
{(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS},
while (1)
{
- option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
+ int option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
if (option_rv == -1) break;
switch (option_rv)
{
case OPT_FILE:
opt_file= optarg;
break;
+
+ case OPT_QUIET:
+ close_stdio();
+ break;
+
case '?':
/* getopt_long already printed an error message. */
- exit(1);
+ exit(EXIT_FAILURE);
default:
abort();
}
projects / awesomized / libmemcached / blobdiff