c++: fix incompatible types

[awesomized/libmemcached] / clients / memstat.cc

diff --git a/clients/memstat.cc b/clients/memstat.cc
index e50f24530e3bdf9f419e01c4df0079e833a18d7c..e5bac9165a26d171734b690589a110d334c17129 100644 (file)
--- a/clients/memstat.cc
+++ b/clients/memstat.cc
@@ -47,6 +47,8 @@ static bool opt_analyze= false;
 static char *opt_servers= NULL;
 static char *stat_args= NULL;
 static char *analyze_mode= NULL;
+static char *opt_username;
+static char *opt_passwd;
 
 static struct option long_options[]=
 {
@@ -60,16 +62,18 @@ static struct option long_options[]=
   {(OPTIONSTRING)"server-version", no_argument, NULL, OPT_SERVER_VERSION},
   {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS},
   {(OPTIONSTRING)"analyze", optional_argument, NULL, OPT_ANALYZE},
+  {(OPTIONSTRING)"username", required_argument, NULL, OPT_USERNAME},
+  {(OPTIONSTRING)"password", required_argument, NULL, OPT_PASSWD},
   {0, 0, 0, 0},
 };
 
 
-static memcached_return_t stat_printer(memcached_server_instance_st instance,
+static memcached_return_t stat_printer(const memcached_instance_st * instance,
                                        const char *key, size_t key_length,
                                        const char *value, size_t value_length,
                                        void *context)
 {
-  static memcached_server_instance_st last= NULL;
+  static const memcached_instance_st * last= NULL;
   (void)context;
 
   if (last != instance)
@@ -85,7 +89,7 @@ static memcached_return_t stat_printer(memcached_server_instance_st instance,
 }
 
 static memcached_return_t server_print_callback(const memcached_st *,
-                                                memcached_server_instance_st instance,
+                                                const memcached_instance_st * instance,
                                                 void *)
 {
   std::cerr << memcached_server_name(instance) << ":" << memcached_server_port(instance) <<
@@ -101,29 +105,57 @@ int main(int argc, char *argv[])
   options_parse(argc, argv);
   initialize_sockets();
 
-  if (opt_servers == false)
+  if (opt_servers == NULL)
   {
     char *temp;
     if ((temp= getenv("MEMCACHED_SERVERS")))
     {
       opt_servers= strdup(temp);
     }
-    else
+
+    if (opt_servers == NULL)
     {
       std::cerr << "No Servers provided" << std::endl;
       return EXIT_FAILURE;
     }
   }
 
+  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;
+  }
+  
+  if (opt_servers)
+  {
+    free(opt_servers);
+  }
+
   memcached_st *memc= memcached_create(NULL);
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, opt_binary);
 
-  memcached_server_st *servers= memcached_servers_parse(opt_servers);
-  free(opt_servers);
-
   memcached_return_t rc= memcached_server_push(memc, servers);
   memcached_server_list_free(servers);
 
+  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;
+    }
+  }
+
   if (rc != MEMCACHED_SUCCESS and rc != MEMCACHED_SOME_ERRORS)
   {
     printf("Failure to communicate with servers (%s)\n",
@@ -189,9 +221,8 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat)
     uint32_t num_of_tests= 32;
     const char *test_key= "libmemcached_test_key";
 
-    memcached_st **servers;
-    servers= static_cast<memcached_st**>(malloc(sizeof(memcached_st*) * server_count));
-    if (not servers)
+    memcached_st **servers= static_cast<memcached_st**>(malloc(sizeof(memcached_st*) * server_count));
+    if (servers == NULL)
     {
       fprintf(stderr, "Failed to allocate memory\n");
       return;
@@ -199,20 +230,25 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat)
 
     for (uint32_t x= 0; x < server_count; x++)
     {
-      memcached_server_instance_st instance=
+      const memcached_instance_st * instance=
         memcached_server_instance_by_position(memc, x);
 
       if ((servers[x]= memcached_create(NULL)) == NULL)
       {
         fprintf(stderr, "Failed to memcached_create()\n");
         if (x > 0)
+        {
           memcached_free(servers[0]);
+        }
         x--;
 
         for (; x > 0; x--)
+        {
           memcached_free(servers[x]);
+        }
 
         free(servers);
+
         return;
       }
       memcached_server_add(servers[x],
@@ -227,7 +263,7 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat)
 
     for (uint32_t x= 0; x < server_count; x++)
     {
-      memcached_server_instance_st instance=
+      const memcached_instance_st * instance=
         memcached_server_instance_by_position(memc, x);
       gettimeofday(&start_time, NULL);
 
@@ -236,8 +272,10 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat)
         size_t vlen;
         char *val= memcached_get(servers[x], test_key, strlen(test_key),
                                  &vlen, &flags, &rc);
-        if (rc != MEMCACHED_NOTFOUND && rc != MEMCACHED_SUCCESS)
+        if (rc != MEMCACHED_NOTFOUND and rc != MEMCACHED_SUCCESS)
+        {
           break;
+        }
         free(val);
       }
       gettimeofday(&end_time, NULL);
@@ -268,7 +306,7 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat)
 
     if (server_count > 1 && slowest_time > 0)
     {
-      memcached_server_instance_st slowest=
+      const memcached_instance_st * slowest=
         memcached_server_instance_by_position(memc, slowest_server);
 
       printf("---\n");
@@ -280,7 +318,9 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat)
     printf("\n");
 
     for (uint32_t x= 0; x < server_count; x++)
+    {
       memcached_free(servers[x]);
+    }
 
     free(servers);
     free(analyze_mode);
@@ -297,9 +337,9 @@ static void print_analysis_report(memcached_st *memc,
                                   
 {
   uint32_t server_count= memcached_server_count(memc);
-  memcached_server_instance_st most_consumed_server= memcached_server_instance_by_position(memc, report->most_consumed_server);
-  memcached_server_instance_st least_free_server= memcached_server_instance_by_position(memc, report->least_free_server);
-  memcached_server_instance_st oldest_server= memcached_server_instance_by_position(memc, report->oldest_server);
+  const memcached_instance_st * most_consumed_server= memcached_server_instance_by_position(memc, report->most_consumed_server);
+  const memcached_instance_st * least_free_server= memcached_server_instance_by_position(memc, report->least_free_server);
+  const memcached_instance_st * oldest_server= memcached_server_instance_by_position(memc, report->oldest_server);
 
   printf("Memcached Cluster Analysis Report\n\n");
 
@@ -386,7 +426,7 @@ static void options_parse(int argc, char *argv[])
       break;
 
     case OPT_ANALYZE: /* --analyze or -a */
-      opt_analyze= OPT_ANALYZE;
+      opt_analyze= true;
       analyze_mode= (optarg) ? strdup(optarg) : NULL;
       break;
 
@@ -394,6 +434,15 @@ static void options_parse(int argc, char *argv[])
       close_stdio();
       break;
 
+    case OPT_USERNAME:
+      opt_username= optarg;
+      opt_binary= true;
+      break;
+
+    case OPT_PASSWD:
+      opt_passwd= optarg;
+      break;
+
     case '?':
       /* getopt_long already printed an error message. */
       exit(1);