X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=clients%2Fmemcp.cc;h=d76faeecca8d31da36e6f23d2ebec9a3e1ea813d;hb=93d6c28365c4a5c378e0bc4687e5c4cb694396b9;hp=4f4f8e1097243ac10e4a754ae244a3ae54dca6f7;hpb=956d15b5b1f3f3518eb374a3a9e0393e9dacd3b6;p=awesomized%2Flibmemcached diff --git a/clients/memcp.cc b/clients/memcp.cc index 4f4f8e10..d76faeec 100644 --- a/clients/memcp.cc +++ b/clients/memcp.cc @@ -1,4 +1,5 @@ /* LibMemcached + * Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/ * Copyright (C) 2006-2009 Brian Aker * All rights reserved. * @@ -9,7 +10,7 @@ * */ -#include "config.h" +#include "mem_config.h" #include #include @@ -30,7 +31,7 @@ #include -#include +#include #include "client_options.h" #include "utilities.h" @@ -42,6 +43,8 @@ static void options_parse(int argc, char *argv[]); static bool opt_binary= false; +static bool opt_udp= false; +static bool opt_buffer= false; static int opt_verbose= 0; static char *opt_servers= NULL; static char *opt_hash= NULL; @@ -61,17 +64,17 @@ static long strtol_wrapper(const char *nptr, int base, bool *error) /* Check for various possible errors */ - if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN)) - || (errno != 0 && val == 0)) + if ((errno == ERANGE and (val == LONG_MAX or val == LONG_MIN)) + or (errno != 0 && val == 0)) { *error= true; - return EXIT_SUCCESS; + return 0; } if (endptr == nptr) { *error= true; - return EXIT_SUCCESS; + return 0; } *error= false; @@ -82,9 +85,47 @@ int main(int argc, char *argv[]) { options_parse(argc, argv); + + if (optind >= argc) + { + fprintf(stderr, "Expected argument after options\n"); + exit(EXIT_FAILURE); + } + initialize_sockets(); memcached_st *memc= memcached_create(NULL); + + if (opt_udp) + { + if (opt_verbose) + { + std::cout << "Enabling UDP" << std::endl; + } + + if (memcached_failed(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, opt_udp))) + { + memcached_free(memc); + std::cerr << "Could not enable UDP protocol." << std::endl; + return EXIT_FAILURE; + } + } + + if (opt_buffer) + { + if (opt_verbose) + { + std::cout << "Enabling MEMCACHED_BEHAVIOR_BUFFER_REQUESTS" << std::endl; + } + + if (memcached_failed(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, opt_buffer))) + { + memcached_free(memc); + std::cerr << "Could not enable MEMCACHED_BEHAVIOR_BUFFER_REQUESTS." << std::endl; + return EXIT_FAILURE; + } + } + process_hash_option(memc, opt_hash); if (opt_servers == NULL) @@ -95,28 +136,30 @@ int main(int argc, char *argv[]) { opt_servers= strdup(temp); } - else +#if 0 + else if (argc >= 1 and argv[--argc]) + { + opt_servers= strdup(argv[argc]); + } +#endif + + if (opt_servers == NULL) { std::cerr << "No Servers provided" << std::endl; exit(EXIT_FAILURE); } } - memcached_server_st *servers; - if (opt_servers) + memcached_server_st* servers= memcached_servers_parse(opt_servers); + if (servers == NULL or memcached_server_list_count(servers) == 0) { - servers= memcached_servers_parse(opt_servers); - } - else - { - servers= memcached_servers_parse(argv[--argc]); + std::cerr << "Invalid server list provided:" << opt_servers << std::endl; + return EXIT_FAILURE; } memcached_server_push(memc, servers); memcached_server_list_free(servers); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, - (uint64_t)opt_binary); - + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, opt_binary); if (opt_username and LIBMEMCACHED_WITH_SASL_SUPPORT == 0) { memcached_free(memc); @@ -143,7 +186,7 @@ int main(int argc, char *argv[]) { if (opt_verbose) { - fprintf(stderr, "memcp: %s: %s\n", argv[optind], strerror(errno)); + std::cerr << "memcp " << argv[optind] << " " << strerror(errno) << std::endl; optind++; } exit_code= EXIT_FAILURE; @@ -151,7 +194,13 @@ int main(int argc, char *argv[]) } struct stat sbuf; - (void)fstat(fd, &sbuf); + if (fstat(fd, &sbuf) == -1) + { + std::cerr << "memcp " << argv[optind] << " " << strerror(errno) << std::endl; + optind++; + exit_code= EXIT_FAILURE; + continue; + } char *ptr= rindex(argv[optind], '/'); if (ptr) @@ -172,62 +221,82 @@ int main(int argc, char *argv[]) ptr, opt_flags, (unsigned long)opt_expires); } - char *file_buffer_ptr; - if ((file_buffer_ptr= (char *)malloc(sizeof(char) * (size_t)sbuf.st_size)) == NULL) + // The file may be empty + char *file_buffer_ptr= NULL; + if (sbuf.st_size > 0) { - fprintf(stderr, "malloc: %s\n", strerror(errno)); - exit(EXIT_FAILURE); - } + if ((file_buffer_ptr= (char *)malloc(sizeof(char) * (size_t)sbuf.st_size)) == NULL) + { + std::cerr << "Error allocating file buffer(" << strerror(errno) << ")" << std::endl; + close(fd); + exit(EXIT_FAILURE); + } - ssize_t read_length; - if ((read_length= read(fd, file_buffer_ptr, (size_t)sbuf.st_size)) == -1) - { - fprintf(stderr, "read: %s\n", strerror(errno)); - exit(EXIT_FAILURE); - } + ssize_t read_length; + if ((read_length= ::read(fd, file_buffer_ptr, (size_t)sbuf.st_size)) == -1) + { + std::cerr << "Error while reading file " << file_buffer_ptr << " (" << strerror(errno) << ")" << std::endl; + close(fd); + free(file_buffer_ptr); + exit(EXIT_FAILURE); + } - if (read_length != sbuf.st_size) - { - fprintf(stderr, "Failure reading from file\n"); - exit(1); + if (read_length != sbuf.st_size) + { + std::cerr << "Failure while reading file. Read length was not equal to stat() length" << std::endl; + close(fd); + free(file_buffer_ptr); + exit(EXIT_FAILURE); + } } memcached_return_t rc; 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) + if (memcached_failed(rc)) { - fprintf(stderr, "memcp: %s: memcache error %s", - ptr, memcached_strerror(memc, rc)); - if (memcached_last_error_errno(memc)) - fprintf(stderr, " system error %s", strerror(memcached_last_error_errno(memc))); - fprintf(stderr, "\n"); - + std::cerr << "Error occrrured during memcached_set(): " << memcached_last_error_message(memc) << std::endl; exit_code= EXIT_FAILURE; } - free(file_buffer_ptr); - close(fd); + ::free(file_buffer_ptr); + ::close(fd); optind++; } + if (opt_verbose) + { + std::cout << "Calling memcached_free()" << std::endl; + } + memcached_free(memc); if (opt_servers) + { free(opt_servers); + } + if (opt_hash) + { free(opt_hash); + } return exit_code; } @@ -244,6 +313,8 @@ static void options_parse(int argc, char *argv[]) {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION}, {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP}, {(OPTIONSTRING)"quiet", no_argument, NULL, OPT_QUIET}, + {(OPTIONSTRING)"udp", no_argument, NULL, OPT_UDP}, + {(OPTIONSTRING)"buffer", no_argument, NULL, OPT_BUFFER}, {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE}, {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG}, {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS}, @@ -274,6 +345,7 @@ static void options_parse(int argc, char *argv[]) { case 0: break; + case OPT_BINARY: opt_binary= true; break; @@ -313,10 +385,10 @@ static void options_parse(int argc, char *argv[]) case OPT_EXPIRE: /* --expire */ { bool strtol_error; - opt_expires= (time_t)strtol_wrapper(optarg, 16, &strtol_error); + opt_expires= (time_t)strtol_wrapper(optarg, 10, &strtol_error); if (strtol_error == true) { - fprintf(stderr, "Bad value passed via --flag\n"); + fprintf(stderr, "Bad value passed via --expire\n"); exit(1); } } @@ -350,6 +422,14 @@ static void options_parse(int argc, char *argv[]) close_stdio(); break; + case OPT_UDP: + opt_udp= true; + break; + + case OPT_BUFFER: + opt_buffer= true; + break; + case '?': /* getopt_long already printed an error message. */ exit(1);