Merge branch 'wip-argparse'

Conflicts:
	src/rgw/rgw_admin.cc

19 files changed, 750 insertions, 657 deletions

diff --git a/src/cauthtool.cc b/src/cauthtool.cc
index 17256a70343..cde058917cd 100644
--- a/src/cauthtool.cc
+++ b/src/cauthtool.cc
@@ -15,6 +15,7 @@
 using namespace std;
 
 #include "common/config.h"
+#include "common/strtol.h"
 
 #include "common/ConfUtils.h"
 #include "common/ceph_argparse.h"
@@ -52,83 +53,94 @@ int main(int argc, const char **argv)
   vector<const char*> args;
   argv_to_vec(argc, argv, args);
   env_to_vec(args);
-  DEFINE_CONF_VARS(usage);
 
-  global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
-	      CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
-  common_init_finish(g_ceph_context);
-  EntityName ename(g_conf->name);
-
-  const char *me = argv[0];
-
-  const char *fn = 0;
   bool gen_key = false;
   bool gen_print_key = false;
-  const char *add_key = 0;
+  std::string add_key;
   bool list = false;
   bool print_key = false;
   bool create_keyring = false;
-  const char *caps_fn = NULL;
-  const char *import_keyring = NULL;
+  std::string caps_fn;
+  std::string import_keyring;
   bool set_auid = false;
   uint64_t auid = CEPH_AUTH_UID_DEFAULT;
   map<string,bufferlist> caps;
   bool bin_keyring = false;
+  std::string fn;
 
-  FOR_EACH_ARG(args) {
-    if (CEPH_ARGPARSE_EQ("gen-key", 'g')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&gen_key, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("gen-print-key", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&gen_print_key, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("add-key", 'a')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&add_key, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("list", 'l')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&list, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("caps", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&caps_fn, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("cap", '\0')) {
-      const char *key, *val;
-      CEPH_ARGPARSE_SET_ARG_VAL(&key, OPT_STR);
-      CEPH_ARGPARSE_SET_ARG_VAL(&val, OPT_STR);
-      ::encode(val, caps[key]);
-    } else if (CEPH_ARGPARSE_EQ("print-key", 'p')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&print_key, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("create-keyring", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&create_keyring, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("import-keyring", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&import_keyring, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("set-uid", 'u')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&auid, OPT_LONGLONG);
+  global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
+	      CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
+  std::vector<const char*>::iterator i;
+  for (i = args.begin(); i != args.end(); ) {
+    std::string val;
+    if (ceph_argparse_double_dash(args, i)) {
+      break;
+    } else if (ceph_argparse_flag(args, i, "-g", "--gen-key", (char*)NULL)) {
+      gen_key = true;
+    } else if (ceph_argparse_flag(args, i, "--gen-print-key", (char*)NULL)) {
+      gen_print_key = true;
+    } else if (ceph_argparse_witharg(args, i, &val, "-a", "--add-key", (char*)NULL)) {
+      add_key = val;
+    } else if (ceph_argparse_flag(args, i, &val, "-l", "--list", (char*)NULL)) {
+      list = true;
+    } else if (ceph_argparse_witharg(args, i, &val, "--caps", (char*)NULL)) {
+      caps_fn = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "--cap", (char*)NULL)) {
+      std::string my_key = val;
+      if (i == args.end()) {
+	cerr << "must give two arguments to --cap: key and val." << std::endl;
+	exit(1);
+      }
+      std::string my_val = *i;
+      ++i;
+      ::encode(my_val, caps[my_key]);
+    } else if (ceph_argparse_flag(args, i, "-p", "--print-key", (char*)NULL)) {
+      print_key = true;
+    } else if (ceph_argparse_flag(args, i, "--create-keyring", (char*)NULL)) {
+      create_keyring = true;
+    } else if (ceph_argparse_witharg(args, i, &val, "--import-keyring", (char*)NULL)) {
+      import_keyring = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "-u", "--set-uid", (char*)NULL)) {
+      std::string err;
+      auid = strict_strtoll(val.c_str(), 10, &err);
+      if (!err.empty()) {
+	cerr << "error parsing UID: " << err << std::endl;
+	exit(1);
+      }
       set_auid = true;
-    } else if (CEPH_ARGPARSE_EQ("bin", 'b')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&bin_keyring, OPT_BOOL);
-    } else if (!fn) {
-      fn = args[i];
-    } else 
+    } else if (ceph_argparse_flag(args, i, "-b", "--bin", (char*)NULL)) {
+      bin_keyring = true;
+    } else if (fn.empty()) {
+      fn = *i++;
+    } else {
       usage();
+    }
   }
-  if (!fn && !gen_print_key) {
-    cerr << me << ": must specify filename" << std::endl;
+  if (fn.empty() && !gen_print_key) {
+    cerr << argv[0] << ": must specify filename" << std::endl;
     usage();
   }
   if (!(gen_key ||
 	gen_print_key ||
-	add_key ||
+	!add_key.empty() ||
 	list ||
-	caps_fn ||
+	!caps_fn.empty() ||
 	caps.size() ||
 	set_auid ||
 	print_key ||
 	create_keyring ||
-	import_keyring)) {
+	!import_keyring.empty())) {
     cerr << "no command specified" << std::endl;
     usage();
   }
-  if (gen_key && add_key) {
+  if (gen_key && (!add_key.empty())) {
     cerr << "can't both gen_key and add_key" << std::endl;
     usage();
   }	
 
+  common_init_finish(g_ceph_context);
+  EntityName ename(g_conf->name);
+
   if (gen_print_key) {
     CryptoKey key;
     key.create(g_ceph_context, CEPH_CRYPTO_AES);
@@ -147,7 +159,7 @@ int main(int argc, const char **argv)
     modified = true;
   } else {
     std::string err;
-    r = bl.read_file(fn, &err);
+    r = bl.read_file(fn.c_str(), &err);
     if (r >= 0) {
       try {
 	bufferlist::iterator iter = bl.begin();
@@ -163,11 +175,11 @@ int main(int argc, const char **argv)
   }
 
   // write commands
-  if (import_keyring) {
+  if (!import_keyring.empty()) {
     KeyRing other;
     bufferlist obl;
     std::string err;
-    int r = obl.read_file(import_keyring, &err);
+    int r = obl.read_file(import_keyring.c_str(), &err);
     if (r >= 0) {
       try {
 	bufferlist::iterator iter = obl.begin();
@@ -192,11 +204,10 @@ int main(int argc, const char **argv)
     keyring.add(ename, eauth);
     modified = true;
   }
-  if (add_key) {
+  if (!add_key.empty()) {
     EntityAuth eauth;
-    string ekey(add_key);
     try {
-      eauth.key.decode_base64(ekey);
+      eauth.key.decode_base64(add_key);
     } catch (const buffer::error &err) {
       cerr << "can't decode key '" << add_key << "'" << std::endl;
       exit(1);
@@ -205,7 +216,7 @@ int main(int argc, const char **argv)
     modified = true;
     cout << "added entity " << ename << " auth " << eauth << std::endl;
   }
-  if (caps_fn) {
+  if (!caps_fn.empty()) {
     ConfFile cf;
     std::deque<std::string> parse_errors;
     if (cf.parse_file(caps_fn, &parse_errors) != 0) {
@@ -257,7 +268,7 @@ int main(int argc, const char **argv)
     } else {
       keyring.encode_plaintext(bl);
     }
-    r = bl.write_file(fn, 0600);
+    r = bl.write_file(fn.c_str(), 0600);
     if (r < 0) {
       cerr << "could not write " << fn << std::endl;
     }
diff --git a/src/cfuse.cc b/src/cfuse.cc
index fe33113046c..18eaa9e42d9 100644
--- a/src/cfuse.cc
+++ b/src/cfuse.cc
@@ -45,7 +45,6 @@ void usage()
 }
 
 int main(int argc, const char **argv, const char *envp[]) {
-  DEFINE_CONF_VARS(usage);
   int filer_flags = 0;
   //cerr << "cfuse starting " << myrank << "/" << world << std::endl;
   vector<const char*> args;
@@ -54,20 +53,19 @@ int main(int argc, const char **argv, const char *envp[]) {
 
   global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_DAEMON,
 	      CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS);
-
-  vector<const char*> nargs;
-  FOR_EACH_ARG(args) {
-    if (CEPH_ARGPARSE_EQ("localize-reads", '\0')) {
+  for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
+    if (ceph_argparse_double_dash(args, i)) {
+      break;
+    } else if (ceph_argparse_flag(args, i, "--localize-reads", (char*)NULL)) {
       cerr << "setting CEPH_OSD_FLAG_LOCALIZE_READS" << std::endl;
       filer_flags |= CEPH_OSD_FLAG_LOCALIZE_READS;
-    }
-    else {
-      nargs.push_back(args[i]);
+    } else {
+      ++i;
     }
   }
 
   // args for fuse
-  vec_to_argv(nargs, argc, argv);
+  vec_to_argv(args, argc, argv);
 
   // FUSE will chdir("/"); be ready.
   g_conf->chdir = "/";
diff --git a/src/cmds.cc b/src/cmds.cc
index a8606160b76..04bfd852c91 100644
--- a/src/cmds.cc
+++ b/src/cmds.cc
@@ -120,7 +120,6 @@ static int parse_rank(const char *opt_name, const std::string &val)
 
 int main(int argc, const char **argv) 
 {
-  DEFINE_CONF_VARS(usage);
   vector<const char*> args;
   argv_to_vec(argc, argv, args);
   env_to_vec(args);
diff --git a/src/cmon.cc b/src/cmon.cc
index 7be51c3e398..c8b2e767f18 100644
--- a/src/cmon.cc
+++ b/src/cmon.cc
@@ -52,11 +52,9 @@ void usage()
 int main(int argc, const char **argv) 
 {
   int err;
-  DEFINE_CONF_VARS(usage);
 
   bool mkfs = false;
-  const char *osdmapfn = 0;
-  const char *inject_monmap = 0;
+  std::string osdmapfn, inject_monmap;
 
   vector<const char*> args;
   argv_to_vec(argc, argv, args);
@@ -64,15 +62,26 @@ int main(int argc, const char **argv)
 
   global_init(args, CEPH_ENTITY_TYPE_MON, CODE_ENVIRONMENT_DAEMON, 0);
 
-  FOR_EACH_ARG(args) {
-    if (CEPH_ARGPARSE_EQ("mkfs", '\0')) {
-      mkfs = true;
-    } else if (CEPH_ARGPARSE_EQ("osdmap", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&osdmapfn, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("inject_monmap", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&inject_monmap, OPT_STR);
-    } else
+  std::string val;
+  for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
+    if (ceph_argparse_double_dash(args, i)) {
+      break;
+    } else if (ceph_argparse_flag(args, i, "-h", "--help", (char*)NULL)) {
       usage();
+      exit(0);
+    } else if (ceph_argparse_flag(args, i, "--mkfs", (char*)NULL)) {
+      mkfs = true;
+    } else if (ceph_argparse_witharg(args, i, &val, "--osdmap", (char*)NULL)) {
+      osdmapfn = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "--inject_monmap", (char*)NULL)) {
+      inject_monmap = val;
+    } else {
+      ++i;
+    }
+  }
+  if (!args.empty()) {
+    cerr << "too many arguments" << std::endl;
+    usage();
   }
 
   if (g_conf->mon_data.empty()) {
@@ -83,7 +92,7 @@ int main(int argc, const char **argv)
   // -- mkfs --
   if (mkfs) {
     common_init_finish(g_ceph_context);
-    if (g_conf->monmap.empty() || !osdmapfn)
+    if (g_conf->monmap.empty() || osdmapfn.empty())
       usage();
 
     // make sure it doesn't already exist
@@ -107,7 +116,7 @@ int main(int argc, const char **argv)
     MonMap monmap(ceph_clock_now(g_ceph_context));
     monmap.decode(monmapbl);
     
-    err = osdmapbl.read_file(osdmapfn, &error);
+    err = osdmapbl.read_file(osdmapfn.c_str(), &error);
     if (err < 0) {
       cout << argv[0] << ": error reading " << osdmapfn << ": "
 	   << error << std::endl;
@@ -174,10 +183,10 @@ int main(int argc, const char **argv)
 
 
   // inject new monmap?
-  if (inject_monmap) {
+  if (!inject_monmap.empty()) {
     bufferlist bl;
     std::string error;
-    int r = bl.read_file(inject_monmap, &error);
+    int r = bl.read_file(inject_monmap.c_str(), &error);
     if (r) {
       cerr << "unable to read monmap from " << inject_monmap << ": "
 	   << error << std::endl;
diff --git a/src/common/ceph_argparse.cc b/src/common/ceph_argparse.cc
index a7e8313e8b1..b4dbfd70c96 100644
--- a/src/common/ceph_argparse.cc
+++ b/src/common/ceph_argparse.cc
@@ -13,17 +13,16 @@
  */
 
 #include "auth/Auth.h"
+#include "common/ConfUtils.h"
 #include "common/ceph_argparse.h"
 #include "common/common_init.h"
-#include "global/global_init.h"
-#include "common/ConfUtils.h"
-#include "common/version.h"
 #include "common/config.h"
+#include "common/strtol.h"
+#include "common/version.h"
 #include "include/intarith.h"
 #include "include/str_list.h"
 #include "msg/msg_types.h"
 
-#include <deque>
 #include <errno.h>
 #include <stdarg.h>
 #include <stdlib.h>
@@ -46,91 +45,6 @@
 #undef generic_dout
 #undef dendl
 
-static bool cmd_is_char(const char *cmd)
-{
-  return ((cmd[0] == '-') &&
-    cmd[1] && !cmd[2]);
-}
-
-bool ceph_argparse_cmd_equals(const char *cmd, const char *opt, char char_opt,
-			      unsigned int *val_pos)
-{
-  unsigned int i;
-  unsigned int len = strlen(opt);
-
-  *val_pos = 0;
-
-  if (!*cmd)
-    return false;
-
-  if (char_opt && cmd_is_char(cmd))
-    return (char_opt == cmd[1]);
-
-  if ((cmd[0] != '-') || (cmd[1] != '-'))
-    return false;
-
-  for (i=0; i<len; i++) {
-    if ((opt[i] == '_') || (opt[i] == '-')) {
-      switch (cmd[i+2]) {
-      case '-':
-      case '_':
-        continue;
-      default:
-        break;
-      }
-    }
-
-    if (cmd[i+2] != opt[i])
-      return false;
-  }
-
-  if (cmd[i+2] == '=')
-    *val_pos = i+3;
-  else if (cmd[i+2])
-    return false;
-
-  return true;
-}
-
-bool ceph_argparse_cmdline_val(void *field, int type, const char *val)
-{
-  switch (type) {
-  case OPT_BOOL:
-    if (strcasecmp(val, "false") == 0)
-      *(bool *)field = false;
-    else if (strcasecmp(val, "true") == 0)
-      *(bool *)field = true;
-    else
-      *(bool *)field = (bool)atoi(val);
-    break;
-  case OPT_INT:
-    *(int *)field = atoi(val);
-    break;
-  case OPT_LONGLONG:
-    *(long long *)field = atoll(val);
-    break;
-  case OPT_STR:
-    if (val)
-      *(char **)field = strdup(val);
-    else
-      *(char **)field = NULL;
-    break;
-  case OPT_FLOAT:
-    *(float *)field = atof(val);
-    break;
-  case OPT_DOUBLE:
-    *(double *)field = strtod(val, NULL);
-    break;
-  case OPT_ADDR:
-    ((entity_addr_t *)field)->parse(val);
-    break;
-  default:
-    return false;
-  }
-
-  return true;
-}
-
 void env_to_vec(std::vector<const char*>& args)
 {
   char *p = getenv("CEPH_ARGS");
@@ -154,27 +68,6 @@ void env_to_vec(std::vector<const char*>& args)
   }
 }
 
-void env_to_deq(std::deque<const char*>& args)
-{
-  char *p = getenv("CEPH_ARGS");
-  if (!p) return;
-
-  static char buf[1000];
-  int len = MIN(strlen(p), sizeof(buf)-1);  // bleh.
-  memcpy(buf, p, len);
-  buf[len] = 0;
-
-  p = buf;
-  while (*p && p < buf + len) {
-    char *e = p;
-    while (*e && *e != ' ')
-      e++;
-    *e = 0;
-    args.push_back(p);
-    p = e+1;
-  }
-}
-
 void argv_to_vec(int argc, const char **argv,
                  std::vector<const char*>& args)
 {
@@ -182,13 +75,6 @@ void argv_to_vec(int argc, const char **argv,
     args.push_back(argv[i]);
 }
 
-void argv_to_deq(int argc, const char **argv,
-                 std::deque<const char*>& args)
-{
-  for (int i=1; i<argc; i++)
-    args.push_back(argv[i]);
-}
-
 void vec_to_argv(std::vector<const char*>& args,
                  int& argc, const char **&argv)
 {
@@ -279,31 +165,32 @@ bool ceph_argparse_flag(std::vector<const char*> &args,
   va_start(ap, i);
   while (1) {
     a = va_arg(ap, char*);
-    if (a == NULL)
+    if (a == NULL) {
+      va_end(ap);
       return false;
+    }
     char a2[strlen(a)+1];
     dashes_to_underscores(a, a2);
     if (strcmp(a2, first) == 0) {
       i = args.erase(i);
+      va_end(ap);
       return true;
     }
   }
 }
 
-bool ceph_argparse_binary_flag(std::vector<const char*> &args,
+static bool va_ceph_argparse_binary_flag(std::vector<const char*> &args,
 	std::vector<const char*>::iterator &i, int *ret,
-	std::ostringstream *oss, ...)
+	std::ostringstream *oss, va_list ap)
 {
   const char *first = *i;
   char tmp[strlen(first)+1];
   dashes_to_underscores(first, tmp);
   first = tmp;
   const char *a;
-  va_list ap;
   int strlen_a;
 
   // does this argument match any of the possibilities?
-  va_start(ap, oss);
   while (1) {
     a = va_arg(ap, char*);
     if (a == NULL)
@@ -339,19 +226,29 @@ bool ceph_argparse_binary_flag(std::vector<const char*> &args,
   }
 }
 
-bool ceph_argparse_witharg(std::vector<const char*> &args,
-	std::vector<const char*>::iterator &i, std::string *ret, ...)
+bool ceph_argparse_binary_flag(std::vector<const char*> &args,
+	std::vector<const char*>::iterator &i, int *ret,
+	std::ostringstream *oss, ...)
+{
+  bool r;
+  va_list ap;
+  va_start(ap, oss);
+  r = va_ceph_argparse_binary_flag(args, i, ret, oss, ap);
+  va_end(ap);
+  return r;
+}
+
+static bool va_ceph_argparse_witharg(std::vector<const char*> &args,
+	std::vector<const char*>::iterator &i, std::string *ret, va_list ap)
 {
   const char *first = *i;
   char tmp[strlen(first)+1];
   dashes_to_underscores(first, tmp);
   first = tmp;
   const char *a;
-  va_list ap;
   int strlen_a;
 
   // does this argument match any of the possibilities?
-  va_start(ap, ret);
   while (1) {
     a = va_arg(ap, char*);
     if (a == NULL)
@@ -380,6 +277,63 @@ bool ceph_argparse_witharg(std::vector<const char*> &args,
   }
 }
 
+bool ceph_argparse_witharg(std::vector<const char*> &args,
+	std::vector<const char*>::iterator &i, std::string *ret, ...)
+{
+  bool r;
+  va_list ap;
+  va_start(ap, ret);
+  r = va_ceph_argparse_witharg(args, i, ret, ap);
+  va_end(ap);
+  return r;
+}
+
+bool ceph_argparse_withint(std::vector<const char*> &args,
+	std::vector<const char*>::iterator &i, int *ret,
+	std::ostringstream *oss, ...)
+{
+  bool r;
+  va_list ap;
+  std::string str;
+  va_start(ap, oss);
+  r = va_ceph_argparse_witharg(args, i, &str, ap);
+  va_end(ap);
+  if (!r) {
+    return false;
+  }
+
+  std::string err;
+  int myret = strict_strtol(str.c_str(), 10, &err);
+  *ret = myret;
+  if (!err.empty()) {
+    *oss << err;
+  }
+  return true;
+}
+
+bool ceph_argparse_withlonglong(std::vector<const char*> &args,
+	std::vector<const char*>::iterator &i, long long *ret,
+	std::ostringstream *oss, ...)
+{
+  bool r;
+  va_list ap;
+  std::string str;
+  va_start(ap, oss);
+  r = va_ceph_argparse_witharg(args, i, &str, ap);
+  va_end(ap);
+  if (!r) {
+    return false;
+  }
+
+  std::string err;
+  long long myret = strict_strtoll(str.c_str(), 10, &err);
+  *ret = myret;
+  if (!err.empty()) {
+    *oss << err;
+  }
+  return true;
+}
+
 CephInitParameters ceph_argparse_early_args
 	  (std::vector<const char*>& args, uint32_t module_type, int flags,
 	   std::string *conf_file_list)
@@ -387,8 +341,9 @@ CephInitParameters ceph_argparse_early_args
   CephInitParameters iparams(module_type);
   std::string val;
   for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
-    if (strcmp(*i, "--") == 0)
+    if (ceph_argparse_double_dash(args, i)) {
       break;
+    }
     else if (ceph_argparse_flag(args, i, "--version", "-v", (char*)NULL)) {
       cout << pretty_version_to_str() << std::endl;
       _exit(0);
diff --git a/src/common/ceph_argparse.h b/src/common/ceph_argparse.h
index b2f4a3c651d..50168be4125 100644
--- a/src/common/ceph_argparse.h
+++ b/src/common/ceph_argparse.h
@@ -31,45 +31,6 @@
 #include "common/entity_name.h"
 #include "msg/msg_types.h"
 
-/////////////////////// Macros ///////////////////////
-#define FOR_EACH_ARG(args) \
-	__isarg = 1 < args.size(); \
-	for (unsigned i=0; i<args.size(); i++, __isarg = i+1 < args.size())
-
-#define DEFINE_CONF_VARS(usage_func) \
-	unsigned int val_pos __attribute__((unused)); \
-	void (*args_usage)() __attribute__((unused)) = usage_func; \
-	bool __isarg __attribute__((unused))
-
-#define CEPH_ARGPARSE_NEXT_VAL (val_pos ? &args[i][val_pos] : args[++i])
-
-#define CEPH_ARGPARSE_VAL args[i]
-
-#define CEPH_ARGPARSE_SET_ARG_VAL(dest, type) \
-	do { \
-          __isarg = i+1 < args.size(); \
-          if (__isarg && !val_pos && \
-              args[i+1][0] == '-' && args[i+1][1] != '\0') \
-              __isarg = false; \
-          if (type == OPT_BOOL) { \
-		if (val_pos) { \
-			ceph_argparse_cmdline_val(dest, type, CEPH_ARGPARSE_NEXT_VAL); \
-		} else \
-			ceph_argparse_cmdline_val(dest, type, "true"); \
-          } else if (__isarg || val_pos) { \
-		ceph_argparse_cmdline_val(dest, type, CEPH_ARGPARSE_NEXT_VAL); \
-	  } else if (args_usage) \
-		args_usage(); \
-	} while (0)
-
-#define CEPH_ARGPARSE_EQ(str_cmd, char_cmd) \
-	ceph_argparse_cmd_equals(args[i], str_cmd, char_cmd, &val_pos)
-
-extern bool ceph_argparse_cmdline_val(void *field, int type,
-				      const char *val);
-extern bool ceph_argparse_cmd_equals(const char *cmd, const char *opt,
-				     char char_opt, unsigned int *val_pos);
-
 /////////////////////// Types ///////////////////////
 class CephInitParameters
 {
@@ -83,11 +44,8 @@ public:
 
 /////////////////////// Functions ///////////////////////
 extern void env_to_vec(std::vector<const char*>& args);
-extern void env_to_deq(std::deque<const char*>& args);
 extern void argv_to_vec(int argc, const char **argv,
                  std::vector<const char*>& args);
-extern void argv_to_deq(int argc, const char **argv,
-                 std::deque<const char*>& args);
 extern void vec_to_argv(std::vector<const char*>& args,
                  int& argc, const char **&argv);
 
@@ -104,6 +62,12 @@ bool ceph_argparse_binary_flag(std::vector<const char*> &args,
 extern CephInitParameters ceph_argparse_early_args
 	    (std::vector<const char*>& args, uint32_t module_type, int flags,
 	     std::string *conf_file_list);
+extern bool ceph_argparse_withint(std::vector<const char*> &args,
+	std::vector<const char*>::iterator &i, int *ret,
+	std::ostringstream *oss, ...);
+extern bool ceph_argparse_withlonglong(std::vector<const char*> &args,
+	std::vector<const char*>::iterator &i, long long *ret,
+	std::ostringstream *oss, ...);
 extern void generic_server_usage();
 extern void generic_client_usage();
 
diff --git a/src/cosd.cc b/src/cosd.cc
index 7e16deba766..e2ce3cc347d 100644
--- a/src/cosd.cc
+++ b/src/cosd.cc
@@ -50,7 +50,6 @@ void usage()
 
 int main(int argc, const char **argv) 
 {
-  DEFINE_CONF_VARS(usage);
   vector<const char*> args;
   argv_to_vec(argc, argv, args);
   env_to_vec(args);
@@ -65,31 +64,41 @@ int main(int argc, const char **argv)
   bool mkkey = false;
   bool flushjournal = false;
   bool convertfilestore = false;
-  char *dump_pg_log = 0;
-  FOR_EACH_ARG(args) {
-    if (CEPH_ARGPARSE_EQ("mkfs", '\0')) {
+  std::string dump_pg_log;
+
+  std::string val;
+  for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
+    if (ceph_argparse_double_dash(args, i)) {
+      break;
+    } else if (ceph_argparse_flag(args, i, "-h", "--help", (char*)NULL)) {
+      usage();
+      exit(0);
+    } else if (ceph_argparse_flag(args, i, "--mkfs", (char*)NULL)) {
       mkfs = true;
-    } else if (CEPH_ARGPARSE_EQ("mkjournal", '\0')) {
+    } else if (ceph_argparse_flag(args, i, "--mkjournal", (char*)NULL)) {
       mkjournal = true;
-    } else if (CEPH_ARGPARSE_EQ("mkkey", '\0')) {
+    } else if (ceph_argparse_flag(args, i, "--mkkey", (char*)NULL)) {
       mkkey = true;
-    } else if (CEPH_ARGPARSE_EQ("flush-journal", '\0')) {
+    } else if (ceph_argparse_flag(args, i, "--flush-journal", (char*)NULL)) {
       flushjournal = true;
-    } else if (CEPH_ARGPARSE_EQ("convert-filestore", '\0')) {
+    } else if (ceph_argparse_flag(args, i, "--convert-filestore", (char*)NULL)) {
       convertfilestore = true;
-    } else if (CEPH_ARGPARSE_EQ("dump-pg-log", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&dump_pg_log, OPT_STR);
+    } else if (ceph_argparse_witharg(args, i, &val, "--dump-pg-log", (char*)NULL)) {
+      dump_pg_log = val;
     } else {
-      derr << "unrecognized arg " << args[i] << dendl;
-      usage();
+      ++i;
     }
   }
+  if (!args.empty()) {
+    derr << "unrecognized arg " << args[0] << dendl;
+    usage();
+  }
 
-  if (dump_pg_log) {
+  if (!dump_pg_log.empty()) {
     common_init_finish(g_ceph_context);
     bufferlist bl;
     std::string error;
-    int r = bl.read_file(dump_pg_log, &error);
+    int r = bl.read_file(dump_pg_log.c_str(), &error);
     if (r >= 0) {
       PG::Log::Entry e;
       bufferlist::iterator p = bl.begin();
diff --git a/src/crushtool.cc b/src/crushtool.cc
index 64aaaad8b3f..06429363f0c 100644
--- a/src/crushtool.cc
+++ b/src/crushtool.cc
@@ -818,21 +818,16 @@ int main(int argc, const char **argv)
   argv_to_vec(argc, argv, args);
 
   const char *me = argv[0];
-  const char *infn = 0;
-  const char *srcfn = 0;
+  std::string infn, srcfn, outfn, add_name, remove_name, reweight_name;
   bool compile = false;
   bool decompile = false;
   bool test = false;
   bool verbose = false;
-  const char *outfn = 0;
 
   bool reweight = false;
   int add_item = -1;
   float add_weight = 0;
-  const char *add_name = 0;
   map<string,string> add_loc;
-  const char *remove_name = 0;		      
-  const char *reweight_name = 0;
   float reweight_weight = 0;
 
   int build = 0;
@@ -842,92 +837,164 @@ int main(int argc, const char **argv)
   int min_x = 0, max_x = 10000-1;
   int min_rule = 0, max_rule = 1000;
   map<int, int> device_weight;
-  DEFINE_CONF_VARS(usage);
 
   vector<const char *> empty_args;  // we use -c, don't confuse the generic arg parsing
   global_init(empty_args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
 	      CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
   common_init_finish(g_ceph_context);
 
-  FOR_EACH_ARG(args) {
-    if (CEPH_ARGPARSE_EQ("decompile", 'd')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&infn, OPT_STR);
+  std::string val;
+  std::ostringstream err;
+  int tmp;
+  for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
+    if (ceph_argparse_double_dash(args, i)) {
+      break;
+    } else if (ceph_argparse_witharg(args, i, &val, "-d", "--decompile", (char*)NULL)) {
+      infn = val;
       decompile = true;
-    } else if (CEPH_ARGPARSE_EQ("infn", 'i')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&infn, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("outfn", 'o')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&outfn, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("verbose", 'v')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&verbose, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("compile", 'c')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&srcfn, OPT_STR);
+    } else if (ceph_argparse_witharg(args, i, &val, "-i", "--infn", (char*)NULL)) {
+      infn = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "-o", "--outfn", (char*)NULL)) {
+      outfn = val;
+    } else if (ceph_argparse_flag(args, i, "-v", "--verbose", (char*)NULL)) {
+      verbose = true;
+    } else if (ceph_argparse_witharg(args, i, &val, "-c", "--compile", (char*)NULL)) {
+      srcfn = val;
       compile = true;
-    } else if (CEPH_ARGPARSE_EQ("test", 't')) {
+    } else if (ceph_argparse_flag(args, i, "-t", "--test", (char*)NULL)) {
       test = true;
-    } else if (CEPH_ARGPARSE_EQ("reweight", '\0')) {
+    } else if (ceph_argparse_flag(args, i, "--reweight", (char*)NULL)) {
       reweight = true;
-    } else if (CEPH_ARGPARSE_EQ("add_item", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&add_item, OPT_INT);
-      CEPH_ARGPARSE_SET_ARG_VAL(&add_weight, OPT_FLOAT);
-      CEPH_ARGPARSE_SET_ARG_VAL(&add_name, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("loc", '\0')) {
-      const char *type, *name;
-      CEPH_ARGPARSE_SET_ARG_VAL(&type, OPT_STR);
-      CEPH_ARGPARSE_SET_ARG_VAL(&name, OPT_STR);
+    } else if (ceph_argparse_withint(args, i, &add_item, &err, "--add_item", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+      if (i == args.end())
+	usage();
+      i = args.erase(i);
+      if (i == args.end())
+	usage();
+      add_weight = atof(*i);
+      i = args.erase(i);
+      if (i == args.end())
+	usage();
+      add_name.assign(*i);
+      i = args.erase(i);
+    } else if (ceph_argparse_witharg(args, i, &val, "--loc", (char*)NULL)) {
+      std::string type(val);
+      if (i == args.end())
+	usage();
+      i = args.erase(i);
+      if (i == args.end())
+	usage();
+      std::string name(*i);
+      i = args.erase(i);
       add_loc[type] = name;
-    } else if (CEPH_ARGPARSE_EQ("remove_item", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&remove_name, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("reweight_item", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&reweight_name, OPT_STR);
-      CEPH_ARGPARSE_SET_ARG_VAL(&reweight_weight, OPT_FLOAT);      
-    } else if (CEPH_ARGPARSE_EQ("verbose", 'v')) {
-      verbose = true;
-    } else if (CEPH_ARGPARSE_EQ("build", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&build, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("num_osds", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&num_osds, OPT_INT);
-    } else if (CEPH_ARGPARSE_EQ("num_rep", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&num_rep, OPT_INT);
-    } else if (CEPH_ARGPARSE_EQ("max_x", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&max_x, OPT_INT);
-    } else if (CEPH_ARGPARSE_EQ("min_x", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&min_x, OPT_INT);
-    } else if (CEPH_ARGPARSE_EQ("x", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&min_x, OPT_INT);
+    } else if (ceph_argparse_witharg(args, i, &val, "--remove_item", (char*)NULL)) {
+      remove_name = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "--reweight_item", (char*)NULL)) {
+      reweight_name = val;
+      if (i == args.end())
+	usage();
+      i = args.erase(i);
+      if (i == args.end())
+	usage();
+      reweight_weight = atof(*i);
+      i = args.erase(i);
+    } else if (ceph_argparse_flag(args, i, "--build", (char*)NULL)) {
+      build = true;
+    } else if (ceph_argparse_withint(args, i, &num_osds, &err, "--num_osds", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+    } else if (ceph_argparse_withint(args, i, &num_rep, &err, "--num_rep", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+    } else if (ceph_argparse_withint(args, i, &max_x, &err, "--max_x", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+    } else if (ceph_argparse_withint(args, i, &min_x, &err, "--min_x", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+    } else if (ceph_argparse_withint(args, i, &min_x, &err, "--x", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
       max_x = min_x;
-    } else if (CEPH_ARGPARSE_EQ("max_rule", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&max_rule, OPT_INT);
-    } else if (CEPH_ARGPARSE_EQ("min_rule", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&min_rule, OPT_INT);
-    } else if (CEPH_ARGPARSE_EQ("rule", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&min_rule, OPT_INT);
+    } else if (ceph_argparse_withint(args, i, &max_rule, &err, "--max_rule", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+    } else if (ceph_argparse_withint(args, i, &min_rule, &err, "--min_rule", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+    } else if (ceph_argparse_withint(args, i, &min_rule, &err, "--rule", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
       max_rule = min_rule;
-    } else if (CEPH_ARGPARSE_EQ("weight", 'w')) {
-      int dev;
-      CEPH_ARGPARSE_SET_ARG_VAL(&dev, OPT_INT);
-      float f;
-      CEPH_ARGPARSE_SET_ARG_VAL(&f, OPT_FLOAT);
+    } else if (ceph_argparse_withint(args, i, &tmp, &err, "--weight", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+      int dev = tmp;
+      if (i == args.end())
+	usage();
+      i = args.erase(i);
+      if (i == args.end())
+	usage();
+      float f = atof(*i);
       int w = (int)(f * 0x10000);
       if (w < 0)
 	w = 0;
       if (w > 0x10000)
 	w = 0x10000;
       device_weight[dev] = w;
-    } else if (!build)
-      usage();
-    else if (i + 3 <= args.size()) {
-      layer_t l;
-      l.name = args[i++];
-      l.buckettype = args[i++];
-      l.size = atoi(args[i]);
-      layers.push_back(l);
-    }      
+    }
+    else {
+      ++i;
+    }
   }
-  if (decompile + compile + build > 1)
+
+  if (decompile + compile + build > 1) {
     usage();
+  }
   if (!compile && !decompile && !build && !test && !reweight && add_item < 0 &&
-      !remove_name && !reweight_name)
+      remove_name.empty() && reweight_name.empty()) {
     usage();
+  }
+  if ((!build) && (args.size() > 0)) {
+    cerr << "too many arguments!" << std::endl;
+    usage();
+  }
+  else {
+    if ((args.size() % 3) != 0U) {
+      cerr << "layers must be specified with 3-tuples of (name, buckettype, size)"
+    	   << std::endl;
+      usage();
+    }
+    for (size_t j = 0; j < args.size(); j += 3) {
+      layer_t l;
+      l.name = args[j];
+      l.buckettype = args[j+1];
+      l.size = atoi(args[j+2]);
+      layers.push_back(l);
+    }
+  }
 
   /*
   if (outfn) cout << "outfn " << outfn << std::endl;
@@ -938,10 +1005,10 @@ int main(int argc, const char **argv)
   CrushWrapper crush;
   bool modified = false;
 
-  if (infn) {
+  if (!infn.empty()) {
     bufferlist bl;
     std::string error;
-    int r = bl.read_file(infn, &error);
+    int r = bl.read_file(infn.c_str(), &error);
     if (r < 0) {
       cerr << me << ": error reading '" << infn << "': " 
 	   << error << std::endl;
@@ -952,9 +1019,9 @@ int main(int argc, const char **argv)
   }
 
   if (decompile) {
-    if (outfn) {
+    if (!outfn.empty()) {
       ofstream o;
-      o.open(outfn, ios::out | ios::binary | ios::trunc);
+      o.open(outfn.c_str(), ios::out | ios::binary | ios::trunc);
       if (!o.is_open()) {
 	cerr << me << ": error writing '" << outfn << "'" << std::endl;
 	exit(1);
@@ -967,7 +1034,7 @@ int main(int argc, const char **argv)
 
   if (compile) {
     crush.create();
-    int r = compile_crush_file(srcfn, crush);
+    int r = compile_crush_file(srcfn.c_str(), crush);
     crush.finalize();
     if (r < 0) 
       exit(1);
@@ -1081,14 +1148,14 @@ int main(int argc, const char **argv)
     modified = true;
   }
 
-  if (reweight_name) {
+  if (!reweight_name.empty()) {
     cout << me << " reweighting item " << reweight_name << " to " << reweight_weight << std::endl;
     int r;
-    if (!crush.name_exists(reweight_name)) {
+    if (!crush.name_exists(reweight_name.c_str())) {
       cerr << " name " << reweight_name << " dne" << std::endl;
       r = -ENOENT;
     } else {
-      int item = crush.get_item_id(reweight_name);
+      int item = crush.get_item_id(reweight_name.c_str());
       r = crush.adjust_item_weightf(item, reweight_weight);
     }
     if (r == 0)
@@ -1099,14 +1166,14 @@ int main(int argc, const char **argv)
     }
         
   }
-  if (remove_name) {
+  if (!remove_name.empty()) {
     cout << me << " removing item " << remove_name << std::endl;
     int r;
-    if (!crush.name_exists(remove_name)) {
+    if (!crush.name_exists(remove_name.c_str())) {
       cerr << " name " << remove_name << " dne" << std::endl;
       r = -ENOENT;
     } else {
-      int remove_item = crush.get_item_id(remove_name);
+      int remove_item = crush.get_item_id(remove_name.c_str());
       r = crush.remove_item(remove_item);
     }
     if (r == 0)
@@ -1119,7 +1186,7 @@ int main(int argc, const char **argv)
   if (add_item >= 0) {
     cout << me << " adding item " << add_item << " weight " << add_weight
 	 << " at " << add_loc << std::endl;
-    int r = crush.insert_item(add_item, (int)(add_weight * (float)0x10000), add_name, add_loc);
+    int r = crush.insert_item(add_item, (int)(add_weight * (float)0x10000), add_name.c_str(), add_loc);
     if (r == 0)
       modified = true;
     else {
@@ -1133,12 +1200,12 @@ int main(int argc, const char **argv)
   }
 
   if (modified) {
-    if (!outfn) {
+    if (outfn.empty()) {
       cout << me << " successfully built or modified map.  Use '-o <file>' to write it out." << std::endl;
     } else {
       bufferlist bl;
       crush.encode(bl);
-      int r = bl.write_file(outfn);
+      int r = bl.write_file(outfn.c_str());
       if (r < 0) {
 	char buf[80];
 	cerr << me << ": error writing '" << outfn << "': " << strerror_r(-r, buf, sizeof(buf)) << std::endl;
diff --git a/src/librados-config.cc b/src/librados-config.cc
index 07b1f12e32a..ca84724d07f 100644
--- a/src/librados-config.cc
+++ b/src/librados-config.cc
@@ -36,7 +36,6 @@ void usage_exit()
 int main(int argc, const char **argv) 
 {
   vector<const char*> args;
-  DEFINE_CONF_VARS(usage_exit);
   argv_to_vec(argc, argv, args);
   env_to_vec(args);
 
@@ -60,9 +59,6 @@ int main(int argc, const char **argv)
   global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
   common_init_finish(g_ceph_context);
 
-  FOR_EACH_ARG(args) {
-    usage_exit();
-  }
   if (!opt_version && !opt_vernum)
     usage_exit();
 
diff --git a/src/monmaptool.cc b/src/monmaptool.cc
index aa56e6ec35b..de35ba3cc8e 100644
--- a/src/monmaptool.cc
+++ b/src/monmaptool.cc
@@ -37,11 +37,10 @@ int main(int argc, const char **argv)
 {
   vector<const char*> args;
   argv_to_vec(argc, argv, args);
-  DEFINE_CONF_VARS(usage);
 
   const char *me = argv[0];
 
-  const char *fn = 0;
+  std::string fn;
   bool print = false;
   bool create = false;
   bool clobber = false;
@@ -52,45 +51,49 @@ int main(int argc, const char **argv)
   global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
 	      CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
   common_init_finish(g_ceph_context);
-  FOR_EACH_ARG(args) {
-    if (CEPH_ARGPARSE_EQ("help", '\0')) {
+  std::string val;
+  for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
+    if (ceph_argparse_double_dash(args, i)) {
+      break;
+    } else if (ceph_argparse_flag(args, i, "-h", "--help", (char*)NULL)) {
       usage();
-    } else if (CEPH_ARGPARSE_EQ("print", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&print, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("create", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&create, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("clobber", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&clobber, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("add", '\0')) {
-      if (++i >= args.size())
-	usage();
-      string name = args[i];
-      if (++i >= args.size())
+    } else if (ceph_argparse_flag(args, i, "-p", "--print", (char*)NULL)) {
+      print = true;
+    } else if (ceph_argparse_flag(args, i, "--create", (char*)NULL)) {
+      create = true;
+    } else if (ceph_argparse_flag(args, i, "--clobber", (char*)NULL)) {
+      clobber = true;
+    } else if (ceph_argparse_flag(args, i, "--add", (char*)NULL)) {
+      string name = *i;
+      i = args.erase(i);
+      if (i == args.end())
 	usage();
       entity_addr_t addr;
-      if (!addr.parse(args[i])) {
-	cerr << me << ": invalid ip:port '" << args[i] << "'" << std::endl;
+      if (!addr.parse(*i)) {
+	cerr << me << ": invalid ip:port '" << *i << "'" << std::endl;
 	return -1;
       }
       if (addr.get_port() == 0)
 	addr.set_port(CEPH_MON_PORT);
       add[name] = addr;
       modified = true;
-    } else if (CEPH_ARGPARSE_EQ("rm", '\0')) {
-      if (++i >= args.size())
-	usage();
-      string name = args[i];
-      rm.push_back(name);
+      i = args.erase(i);
+    } else if (ceph_argparse_witharg(args, i, &val, "--rm", (char*)NULL)) {
+      rm.push_back(val);
       modified = true;
-    } else if (!fn)
-      fn = args[i];
-    else {
-      cout << "invalid argument: '" << args[i] << "'" << std::endl;
-      usage();
+    } else {
+      ++i;
     }
   }
-  if (!fn)
+  if (args.size() < 1) {
+    cerr << me << ": must specify monmap filename" << std::endl;
     usage();
+  }
+  else if (args.size() > 1) {
+    cerr << me << ": too many arguments" << std::endl;
+    usage();
+  }
+  fn = args[0];
   
   MonMap monmap(ceph_clock_now(g_ceph_context));
 
@@ -99,7 +102,7 @@ int main(int argc, const char **argv)
   int r = 0;
   if (!(create && clobber)) {
     try {
-      r = monmap.read(fn);
+      r = monmap.read(fn.c_str());
     } catch (...) {
       cerr << me << ": unable to read monmap file" << std::endl;
       return -1;
@@ -158,7 +161,7 @@ int main(int argc, const char **argv)
 	 << " to " << fn
 	 << " (" << monmap.size() << " monitors)" 
 	 << std::endl;
-    int r = monmap.write(fn);
+    int r = monmap.write(fn.c_str());
     if (r < 0) {
       cerr << "monmaptool: error writing to '" << fn << "': " << strerror_r(-r, buf, sizeof(buf)) << std::endl;
       return 1;
diff --git a/src/osdmaptool.cc b/src/osdmaptool.cc
index e4a26670efb..ab06d12721d 100644
--- a/src/osdmaptool.cc
+++ b/src/osdmaptool.cc
@@ -39,15 +39,11 @@ void usage()
   exit(1);
 }
 
-
-
-
 int main(int argc, const char **argv)
 {
   vector<const char*> args;
   argv_to_vec(argc, argv, args);
   env_to_vec(args);
-  DEFINE_CONF_VARS(usage);
 
   global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
 	      CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
@@ -55,7 +51,7 @@ int main(int argc, const char **argv)
 
   const char *me = argv[0];
 
-  const char *fn = 0;
+  std::string fn;
   bool print = false;
   bool print_json = false;
   bool tree = false;
@@ -66,54 +62,74 @@ int main(int argc, const char **argv)
   int lpg_bits = g_conf->osd_lpg_bits;
   bool clobber = false;
   bool modified = false;
-  const char *export_crush = 0;
-  const char *import_crush = 0;
+  std::string export_crush, import_crush, test_map_pg, test_map_object;
   list<entity_addr_t> add, rm;
-  const char *test_map_pg = 0;
-  const char *test_map_object = 0;
   bool test_crush = false;
 
-  FOR_EACH_ARG(args) {
-    if (CEPH_ARGPARSE_EQ("help", 'h')) {
+  std::string val;
+  std::ostringstream err;
+  for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
+    if (ceph_argparse_double_dash(args, i)) {
+      break;
+    } else if (ceph_argparse_flag(args, i, "-h", "--help", (char*)NULL)) {
       usage();
-    } else if (CEPH_ARGPARSE_EQ("print", 'p')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&print, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("dump_json", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&print_json, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("tree", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&tree, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("createsimple", '\0')) {
+    } else if (ceph_argparse_flag(args, i, "-p", "--print", (char*)NULL)) {
+      print = true;
+    } else if (ceph_argparse_flag(args, i, "--dump-json", (char*)NULL)) {
+      print_json = true;
+    } else if (ceph_argparse_flag(args, i, "--tree", (char*)NULL)) {
+      tree = true;
+    } else if (ceph_argparse_withint(args, i, &num_osd, &err, "--createsimple", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
       createsimple = true;
-      CEPH_ARGPARSE_SET_ARG_VAL(&num_osd, OPT_INT);
-    } else if (CEPH_ARGPARSE_EQ("clobber", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&clobber, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("pg_bits", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&pg_bits, OPT_INT);
-    } else if (CEPH_ARGPARSE_EQ("pgp_bits", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&pgp_bits, OPT_INT);
-    } else if (CEPH_ARGPARSE_EQ("lpg_bits", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&lpg_bits, OPT_INT);
-    } else if (CEPH_ARGPARSE_EQ("num_dom", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&num_dom, OPT_INT);
-    } else if (CEPH_ARGPARSE_EQ("export_crush", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&export_crush, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("import_crush", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&import_crush, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("test_map_pg", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&test_map_pg, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("test_map_object", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&test_map_object, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("test_crush", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&test_crush, OPT_BOOL);
-    } else if (!fn)
-      fn = args[i];
-    else 
-      usage();
+    } else if (ceph_argparse_flag(args, i, "--clobber", (char*)NULL)) {
+      clobber = true;
+    } else if (ceph_argparse_withint(args, i, &pg_bits, &err, "--pg_bits", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+    } else if (ceph_argparse_withint(args, i, &pgp_bits, &err, "--pg_bits", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+    } else if (ceph_argparse_withint(args, i, &lpg_bits, &err, "--lpg_bits", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+    } else if (ceph_argparse_withint(args, i, &num_dom, &err, "--num_dom", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+    } else if (ceph_argparse_witharg(args, i, &val, "--export_crush", (char*)NULL)) {
+      export_crush = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "--import_crush", (char*)NULL)) {
+      import_crush = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "--test_map_pg", (char*)NULL)) {
+      test_map_pg = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "--test_map_object", (char*)NULL)) {
+      test_map_object = val;
+    } else if (ceph_argparse_flag(args, i, "--test_crush", (char*)NULL)) {
+      test_crush = true;
+    } else {
+      ++i;
+    }
   }
-  if (!fn) {
+  if (args.size() < 1) {
     cerr << me << ": must specify osdmap filename" << std::endl;
     usage();
   }
+  else if (args.size() > 1) {
+    cerr << me << ": too many arguments" << std::endl;
+    usage();
+  }
+  fn = args[0];
   
   OSDMap osdmap;
   bufferlist bl;
@@ -124,7 +140,7 @@ int main(int argc, const char **argv)
   struct stat st;
   if (!createsimple && !clobber) {
     std::string error;
-    r = bl.read_file(fn, &error);
+    r = bl.read_file(fn.c_str(), &error);
     if (r == 0) {
       try {
 	osdmap.decode(bl);
@@ -139,7 +155,7 @@ int main(int argc, const char **argv)
       return -1;
     }
   }
-  else if (createsimple && !clobber && ::stat(fn, &st) == 0) {
+  else if (createsimple && !clobber && ::stat(fn.c_str(), &st) == 0) {
     cerr << me << ": " << fn << " exists, --clobber to overwrite" << std::endl;
     return -1;
   }
@@ -155,10 +171,10 @@ int main(int argc, const char **argv)
     modified = true;
   }
 
-  if (import_crush) {
+  if (!import_crush.empty()) {
     bufferlist cbl;
     std::string error;
-    r = cbl.read_file(import_crush, &error);
+    r = cbl.read_file(import_crush.c_str(), &error);
     if (r) {
       cerr << me << ": error reading crush map from " << import_crush
 	   << ": " << error << std::endl;
@@ -186,10 +202,10 @@ int main(int argc, const char **argv)
     modified = true;
   }
 
-  if (export_crush) {
+  if (!export_crush.empty()) {
     bufferlist cbl;
     osdmap.crush.encode(cbl);
-    r = cbl.write_file(export_crush);
+    r = cbl.write_file(export_crush.c_str());
     if (r < 0) {
       cerr << me << ": error writing crush map to " << import_crush << std::endl;
       exit(1);
@@ -197,7 +213,7 @@ int main(int argc, const char **argv)
     cout << me << ": exported crush map to " << export_crush << std::endl;
   }  
 
-  if (test_map_object) {
+  if (!test_map_object.empty()) {
     object_t oid(test_map_object);
     ceph_object_layout ol = osdmap.make_object_layout(oid, 0);
     
@@ -211,9 +227,9 @@ int main(int argc, const char **argv)
 	 << " -> " << acting
 	 << std::endl;
   }  
-  if (test_map_pg) {
+  if (!test_map_pg.empty()) {
     pg_t pgid;
-    if (pgid.parse(test_map_pg) < 0) {
+    if (pgid.parse(test_map_pg.c_str()) < 0) {
       cerr << me << ": failed to parse pg '" << test_map_pg
 	   << "', r = " << r << std::endl;
       usage();
@@ -256,7 +272,9 @@ int main(int argc, const char **argv)
     }
   }
 
-  if (!print && !print_json && !tree && !modified && !export_crush && !import_crush && !test_map_pg && !test_map_object) {
+  if (!print && !print_json && !tree && !modified && 
+      export_crush.empty() && import_crush.empty() && 
+      test_map_pg.empty() && test_map_object.empty()) {
     cerr << me << ": no action specified?" << std::endl;
     usage();
   }
@@ -279,7 +297,7 @@ int main(int argc, const char **argv)
     cout << me << ": writing epoch " << osdmap.get_epoch()
 	 << " to " << fn
 	 << std::endl;
-    int r = bl.write_file(fn);
+    int r = bl.write_file(fn.c_str());
     if (r) {
       cerr << "osdmaptool: error writing to '" << fn << "': "
 	   << cpp_strerror(r) << std::endl;
diff --git a/src/rados.cc b/src/rados.cc
index 1cadf2e8d94..8b43bb08375 100644
--- a/src/rados.cc
+++ b/src/rados.cc
@@ -1243,7 +1243,6 @@ static int rados_tool_common(const std::map < std::string, std::string > &opts,
 
 int main(int argc, const char **argv)
 {
-  DEFINE_CONF_VARS(usage_exit);
   vector<const char*> args;
   argv_to_vec(argc, argv, args);
   env_to_vec(args);
diff --git a/src/rbd.cc b/src/rbd.cc
index 6a7f991fc65..bc745551df1 100644
--- a/src/rbd.cc
+++ b/src/rbd.cc
@@ -823,7 +823,6 @@ int main(int argc, const char **argv)
   librbd::Image image;
 
   vector<const char*> args;
-  DEFINE_CONF_VARS(usage_exit);
 
   argv_to_vec(argc, argv, args);
   env_to_vec(args);
@@ -837,42 +836,55 @@ int main(int argc, const char **argv)
   int order = 0;
   const char *imgname = NULL, *snapname = NULL, *destname = NULL, *dest_poolname = NULL, *path = NULL, *secretfile = NULL, *user = NULL, *devpath = NULL;
   bool is_snap_cmd = false;
-  FOR_EACH_ARG(args) {
-    if (CEPH_ARGPARSE_EQ("help", 'h')) {
+
+  std::string val;
+  std::ostringstream err;
+  long long sizell = 0;
+  for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
+    if (ceph_argparse_double_dash(args, i)) {
+      break;
+    } else if (ceph_argparse_flag(args, i, "-h", "--help", (char*)NULL)) {
       usage();
       exit(0);
-    } else if (CEPH_ARGPARSE_EQ("pool", 'p')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&poolname, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("dest-pool", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&dest_poolname, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("snap", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&snapname, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("image", 'i')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&imgname, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("size", 's')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&size, OPT_LONGLONG);
-      size <<= 20; // MB -> bytes
-    } else if (CEPH_ARGPARSE_EQ("order", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&order, OPT_INT);
-    } else if (CEPH_ARGPARSE_EQ("path", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&path, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("dest", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&destname, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("secret", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&secretfile, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("user", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&user, OPT_STR);
+    } else if (ceph_argparse_witharg(args, i, &val, "-p", "--pool", (char*)NULL)) {
+      poolname = strdup(val.c_str());
+    } else if (ceph_argparse_witharg(args, i, &val, "--dest-pool", (char*)NULL)) {
+      dest_poolname = strdup(val.c_str());
+    } else if (ceph_argparse_witharg(args, i, &val, "--snap", (char*)NULL)) {
+      snapname = strdup(val.c_str());
+    } else if (ceph_argparse_witharg(args, i, &val, "-i", "--image", (char*)NULL)) {
+      imgname = strdup(val.c_str());
+    } else if (ceph_argparse_withlonglong(args, i, &sizell, &err, "-s", "--size", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+      size = sizell;
+    } else if (ceph_argparse_withint(args, i, &order, &err, "--order", (char*)NULL)) {
+      if (!err.str().empty()) {
+	cerr << err.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+    } else if (ceph_argparse_witharg(args, i, &val, "--path", (char*)NULL)) {
+      path = strdup(val.c_str());
+    } else if (ceph_argparse_witharg(args, i, &val, "--dest", (char*)NULL)) {
+      destname = strdup(val.c_str());
+    } else if (ceph_argparse_witharg(args, i, &val, "--secret", (char*)NULL)) {
+      secretfile = strdup(val.c_str());
+    } else if (ceph_argparse_witharg(args, i, &val, "--user", (char*)NULL)) {
+      user = strdup(val.c_str());
     } else {
+      const char *v = *i;
       if (!opt_cmd) {
-        opt_cmd = get_cmd(CEPH_ARGPARSE_VAL, &is_snap_cmd);
+        opt_cmd = get_cmd(v, &is_snap_cmd);
         if (opt_cmd < 0) {
-          cerr << "invalid command: " << CEPH_ARGPARSE_VAL << std::endl;
+          cerr << "invalid command: " << v << std::endl;
           usage_exit();
         }
       } else {
         switch (opt_cmd) {
           case OPT_LIST:
-            set_conf_param(CEPH_ARGPARSE_VAL, &poolname, NULL);
+            set_conf_param(v, &poolname, NULL);
             break;
           case OPT_INFO:
           case OPT_CREATE:
@@ -884,20 +896,20 @@ int main(int argc, const char **argv)
           case OPT_SNAP_LIST:
           case OPT_WATCH:
           case OPT_MAP:
-            set_conf_param(CEPH_ARGPARSE_VAL, &imgname, NULL);
+            set_conf_param(v, &imgname, NULL);
             break;
           case OPT_UNMAP:
-            set_conf_param(CEPH_ARGPARSE_VAL, &devpath, NULL);
+            set_conf_param(v, &devpath, NULL);
             break;
           case OPT_EXPORT:
-            set_conf_param(CEPH_ARGPARSE_VAL, &imgname, &path);
+            set_conf_param(v, &imgname, &path);
             break;
           case OPT_IMPORT:
-            set_conf_param(CEPH_ARGPARSE_VAL, &path, &destname);
+            set_conf_param(v, &path, &destname);
             break;
           case OPT_COPY:
           case OPT_RENAME:
-            set_conf_param(CEPH_ARGPARSE_VAL, &imgname, &destname);
+            set_conf_param(v, &imgname, &destname);
             break;
         }
       }
diff --git a/src/rgw/rgw_admin.cc b/src/rgw/rgw_admin.cc
index a5aca96c795..dd6d31f9f85 100644
--- a/src/rgw/rgw_admin.cc
+++ b/src/rgw/rgw_admin.cc
@@ -525,7 +525,6 @@ int process_intent_log(rgw_bucket& bucket, string& oid, time_t epoch, int flags,
 
 int main(int argc, char **argv) 
 {
-  DEFINE_CONF_VARS(_usage);
   vector<const char*> args;
   argv_to_vec(argc, (const char **)argv, args);
   env_to_vec(args);
@@ -533,25 +532,14 @@ int main(int argc, char **argv)
   global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
   common_init_finish(g_ceph_context);
 
-  const char *user_id = 0;
-  const char *access_key = 0;
-  const char *secret_key = 0;
-  const char *user_email = 0;
-  const char *display_name = 0;
-  const char *bucket_name = 0;
+  std::string user_id, access_key, secret_key, user_email, display_name;
+  std::string bucket_name, object, swift_user, swift_key;
+  std::string date, time, subuser, access, format;
   rgw_bucket bucket;
-  const char *object = 0;
-  const char *swift_user = 0;
-  const char *swift_key = 0;
-  const char *date = 0;
-  const char *time = 0;
-  const char *subuser = 0;
-  const char *access = 0;
   uint32_t perm_mask = 0;
   uint64_t auid = -1;
   RGWUserInfo info;
   RGWAccess *store;
-  const char *prev_cmd = NULL;
   int opt_cmd = OPT_NO_CMD;
   bool need_more;
   bool gen_secret;
@@ -560,86 +548,101 @@ int main(int argc, char **argv)
   char public_id_buf[PUBLIC_ID_LEN + 1];
   bool user_modify_op;
   int64_t bucket_id = -1;
-  const char *format = 0;
   Formatter *formatter = &default_formatter;
   bool purge_data = false;
   RGWPoolInfo pool_info;
   bool pretty_format = false;
 
-  FOR_EACH_ARG(args) {
-    if (CEPH_ARGPARSE_EQ("help", 'h')) {
+  std::string val;
+  std::ostringstream errs;
+  long long tmp = 0;
+  for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
+    if (ceph_argparse_double_dash(args, i)) {
+      break;
+    } else if (ceph_argparse_flag(args, i, "-h", "--help", (char*)NULL)) {
       usage();
       return 0;
-    } else if (CEPH_ARGPARSE_EQ("uid", 'i')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&user_id, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("access-key", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&access_key, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("subuser", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&subuser, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("secret", 's')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&secret_key, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("email", 'e')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&user_email, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("display-name", 'n')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&display_name, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("bucket", 'b')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&bucket_name, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("object", 'o')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&object, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("gen-access-key", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&gen_key, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("gen-secret", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&gen_secret, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("auth-uid", 'a')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&auid, OPT_LONGLONG);
-    } else if (CEPH_ARGPARSE_EQ("swift-user", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&swift_user, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("swift-secret", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&swift_key, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("date", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&date, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("time", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&time, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("access", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&access, OPT_STR);
-      perm_mask = str_to_perm(access);
-    } else if (CEPH_ARGPARSE_EQ("bucket-id", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&bucket_id, OPT_LONGLONG);
+    } else if (ceph_argparse_witharg(args, i, &val, "-i", "--uid", (char*)NULL)) {
+      user_id = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "--access-key", (char*)NULL)) {
+      access_key = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "--subuser", (char*)NULL)) {
+      subuser = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "--secret", (char*)NULL)) {
+      secret_key = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "-e", "--email", (char*)NULL)) {
+      user_email = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "-n", "--display-name", (char*)NULL)) {
+      display_name = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "-b", "--bucket", (char*)NULL)) {
+      bucket_name = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "-o", "--object", (char*)NULL)) {
+      object = val;
+    } else if (ceph_argparse_flag(args, i, "--gen-access-key", (char*)NULL)) {
+      gen_key = true;
+    } else if (ceph_argparse_flag(args, i, "--gen-secret", (char*)NULL)) {
+      gen_secret = true;
+    } else if (ceph_argparse_withlonglong(args, i, &tmp, &errs, "-a", "--auth-uid", (char*)NULL)) {
+      if (!errs.str().empty()) {
+	cerr << errs.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+      auid = tmp;
+    } else if (ceph_argparse_witharg(args, i, &val, "--os-user", (char*)NULL)) {
+      swift_user = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "--os-secret", (char*)NULL)) {
+      swift_key = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "--date", (char*)NULL)) {
+      date = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "--time", (char*)NULL)) {
+      time = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "--access", (char*)NULL)) {
+      access = val;
+      perm_mask = str_to_perm(access.c_str());
+    } else if (ceph_argparse_withlonglong(args, i, &tmp, &errs, "--bucket-id", (char*)NULL)) {
+      if (!errs.str().empty()) {
+	cerr << errs.str() << std::endl;
+	exit(EXIT_FAILURE);
+      }
+      bucket_id = tmp;
       if (bucket_id < 0) {
         cerr << "bad bucket-id: " << bucket_id << std::endl;
         return usage();
       }
-    } else if (CEPH_ARGPARSE_EQ("format", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&format, OPT_STR);
-    } else if (CEPH_ARGPARSE_EQ("pretty-format", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&pretty_format, OPT_BOOL);
-    } else if (CEPH_ARGPARSE_EQ("purge-data", '\0')) {
-      CEPH_ARGPARSE_SET_ARG_VAL(&purge_data, OPT_BOOL);
+    } else if (ceph_argparse_witharg(args, i, &val, "--format", (char*)NULL)) {
+      format = val;
+    } else if (ceph_argparse_witharg(args, i, &val, "--pretty-format", (char*)NULL)) {
+      pretty_format = true;
+    } else if (ceph_argparse_witharg(args, i, &val, "--purge-data", (char*)NULL)) {
+      purge_data = true;
     } else {
-      if (!opt_cmd) {
-        opt_cmd = get_cmd(CEPH_ARGPARSE_VAL, prev_cmd, &need_more);
-        if (opt_cmd < 0) {
-          cerr << "unrecognized arg " << args[i] << std::endl;
-          return usage();
-        }
-        if (need_more) {
-          prev_cmd = CEPH_ARGPARSE_VAL;
-          continue;
-        }
-      } else {
-        cerr << "unrecognized arg " << args[i] << std::endl;
-        return usage();
-      }
+      ++i;
     }
   }
 
-  if (opt_cmd == OPT_NO_CMD)
+  if (args.size() == 0) {
     return usage();
+  }
+  else {
+    const char *prev_cmd = NULL;
+    for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ++i) {
+      opt_cmd = get_cmd(*i, prev_cmd, &need_more);
+      if (opt_cmd < 0) {
+	cerr << "unrecognized arg " << *i << std::endl;
+	return usage();
+      }
+      if (!need_more)
+	break;
+      prev_cmd = *i;
+    }
+    if (opt_cmd == OPT_NO_CMD)
+      return usage();
+  }
 
-  if (format) {
-    if (strcmp(format, "xml") == 0)
+  if (!format.empty()) {
+    if (format ==  "xml")
       formatter = new XMLFormatter(pretty_format);
-    else if (strcmp(format, "json") == 0)
+    else if (format == "json")
       formatter = new JSONFormatter(pretty_format);
     else {
       cerr << "unrecognized format: " << format << std::endl;
@@ -647,25 +650,25 @@ int main(int argc, char **argv)
     }
   }
 
-  if (subuser) {
-    char *suser = strdup(subuser);
+  if (!subuser.empty()) {
+    char *suser = strdup(subuser.c_str());
     char *p = strchr(suser, ':');
-    if (!p) {
-      free(suser);
-    } else {
+    if (p) {
       *p = '\0';
-      if (user_id) {
-        if (strcmp(user_id, suser) != 0) {
+      if (!user_id.empty()) {
+        if (user_id != suser) {
           cerr << "bad subuser " << subuser << " for uid " << user_id << std::endl;
           return 1;
         }
-      } else
+      } else {
         user_id = suser;
+      }
       subuser = p + 1;
     }
+    free(suser);
   }
 
-  if (opt_cmd == OPT_KEY_RM && !access_key) {
+  if (opt_cmd == OPT_KEY_RM && access_key.empty()) {
     cerr << "error: access key was not specified" << std::endl;
     return usage();
   }
@@ -681,10 +684,10 @@ int main(int argc, char **argv)
     return 5; //EIO
   }
 
-  if (opt_cmd != OPT_USER_CREATE && opt_cmd != OPT_LOG_SHOW && !user_id) {
+  if (opt_cmd != OPT_USER_CREATE && opt_cmd != OPT_LOG_SHOW && user_id.empty()) {
     bool found = false;
     string s;
-    if (!found && user_email) {
+    if (!found && (!user_email.empty())) {
       s = user_email;
       if (rgw_get_user_info_by_email(s, info) >= 0) {
 	found = true;
@@ -692,7 +695,7 @@ int main(int argc, char **argv)
 	cerr << "could not find user by specified email" << std::endl;
       }
     }
-    if (!found && access_key) {
+    if (!found && (!access_key.empty())) {
       s = access_key;
       if (rgw_get_user_info_by_access_key(s, info) >= 0) {
 	found = true;
@@ -700,7 +703,7 @@ int main(int argc, char **argv)
 	cerr << "could not find user by specified access key" << std::endl;
       }
     }
-    if (!found && swift_user) {
+    if (!found && (!swift_user.empty())) {
       s = swift_user;
       if (rgw_get_user_info_by_swift(s, info) >= 0) {
 	found = true;
@@ -715,14 +718,12 @@ int main(int argc, char **argv)
   if (user_modify_op || opt_cmd == OPT_USER_CREATE ||
       opt_cmd == OPT_USER_INFO || opt_cmd == OPT_BUCKET_UNLINK || opt_cmd == OPT_BUCKET_LINK ||
       opt_cmd == OPT_USER_SUSPEND || opt_cmd == OPT_USER_ENABLE) {
-    if (!user_id) {
+    if (user_id.empty()) {
       cerr << "user_id was not specified, aborting" << std::endl;
       return usage();
     }
 
-    string user_id_str = user_id;
-
-    bool found = (rgw_get_user_info_by_uid(user_id_str, info) >= 0);
+    bool found = (rgw_get_user_info_by_uid(user_id, info) >= 0);
 
     if (opt_cmd == OPT_USER_CREATE) {
       if (found) {
@@ -737,7 +738,7 @@ int main(int argc, char **argv)
 
   if (opt_cmd == OPT_SUBUSER_CREATE || opt_cmd == OPT_SUBUSER_MODIFY ||
       opt_cmd == OPT_SUBUSER_RM) {
-    if (!subuser) {
+    if (subuser.empty()) {
       cerr << "subuser creation was requires specifying subuser name" << std::endl;
       return 1;
     }
@@ -754,18 +755,18 @@ int main(int argc, char **argv)
     }
   }
 
-  bool keys_not_requested = (!access_key && !secret_key && !gen_secret && !gen_key &&
+  bool keys_not_requested = (access_key.empty() && secret_key.empty() && !gen_secret && !gen_key &&
                              opt_cmd != OPT_KEY_CREATE);
 
   if (opt_cmd == OPT_USER_CREATE || (user_modify_op && !keys_not_requested)) {
     int ret;
 
-    if (opt_cmd == OPT_USER_CREATE && !display_name) {
+    if (opt_cmd == OPT_USER_CREATE && display_name.empty()) {
       cerr << "display name was not specified, aborting" << std::endl;
       return 0;
     }
 
-    if (!secret_key || gen_secret) {
+    if (secret_key.empty() || gen_secret) {
       ret = gen_rand_base64(secret_key_buf, sizeof(secret_key_buf));
       if (ret < 0) {
         cerr << "aborting" << std::endl;
@@ -773,7 +774,7 @@ int main(int argc, char **argv)
       }
       secret_key = secret_key_buf;
     }
-    if (!access_key || gen_key) {
+    if (access_key.empty() || gen_key) {
       RGWUserInfo duplicate_check;
       string duplicate_check_id;
       do {
@@ -792,7 +793,7 @@ int main(int argc, char **argv)
   map<string, RGWSubUser>::iterator uiter;
   RGWUserInfo old_info = info;
 
-  if (bucket_name || bucket_id >= 0) {
+  if ((!bucket_name.empty()) || bucket_id >= 0) {
     if (bucket_id >= 0) {
       int ret = rgw_retrieve_pool_info(bucket_id, pool_info);
       if (ret < 0) {
@@ -800,7 +801,7 @@ int main(int argc, char **argv)
         return ret;
       }
       bucket = pool_info.bucket;
-      if (bucket_name && bucket.name.compare(bucket_name) != 0) {
+      if ((!bucket_name.empty()) && bucket.name.compare(bucket_name.c_str()) != 0) {
         cerr << "bucket name does not match bucket id (expected bucket name: " << bucket.name << ")" << std::endl;
         return -EINVAL;
       }
@@ -828,30 +829,30 @@ int main(int argc, char **argv)
   case OPT_SUBUSER_CREATE:
   case OPT_SUBUSER_MODIFY:
   case OPT_KEY_CREATE:
-    if (user_id)
+    if (!user_id.empty())
       info.user_id = user_id;
-    if (access_key && secret_key) {
+    if ((!access_key.empty()) && (!secret_key.empty())) {
       RGWAccessKey k;
       k.id = access_key;
       k.key = secret_key;
-      if (subuser)
+      if (!subuser.empty())
         k.subuser = subuser;
       info.access_keys[access_key] = k;
-   } else if (access_key || secret_key) {
+   } else if ((!access_key.empty()) || (!secret_key.empty())) {
       cerr << "access key modification requires both access key and secret key" << std::endl;
       return 1;
     }
-    if (display_name)
+    if (!display_name.empty())
       info.display_name = display_name;
-    if (user_email)
+    if (!user_email.empty())
       info.user_email = user_email;
     if (auid != (uint64_t)-1)
       info.auid = auid;
-    if (swift_user)
+    if (!swift_user.empty())
       info.swift_name = swift_user;
-    if (swift_key)
+    if (!swift_key.empty())
       info.swift_key = swift_key;
-    if (subuser) {
+    if (!subuser.empty()) {
       RGWSubUser u;
       u.name = subuser;
       u.perm_mask = perm_mask;
@@ -865,7 +866,7 @@ int main(int argc, char **argv)
 
     remove_old_indexes(old_info, info);
 
-    show_user_info(info, format, formatter);
+    show_user_info(info, format.c_str(), formatter);
     break;
 
   case OPT_SUBUSER_RM:
@@ -876,7 +877,7 @@ int main(int argc, char **argv)
       cerr << "error storing user info: " << cpp_strerror(-err) << std::endl;
       break;
     }
-    show_user_info(info, format, formatter);
+    show_user_info(info, format.c_str(), formatter);
     break;
 
   case OPT_KEY_RM:
@@ -891,20 +892,17 @@ int main(int argc, char **argv)
         break;
       }
     }
-    show_user_info(info, format, formatter);
+    show_user_info(info, format.c_str(), formatter);
     break;
 
   case OPT_USER_INFO:
-    show_user_info(info, format, formatter);
+    show_user_info(info, format.c_str(), formatter);
     break;
   }
 
   if (opt_cmd == OPT_POLICY) {
     bufferlist bl;
-    if (!object)
-      object = "";
-    string object_str(object);
-    rgw_obj obj(bucket, object_str);
+    rgw_obj obj(bucket, object);
     int ret = store->get_attr(NULL, obj, RGW_ATTR_ACL, bl);
 
     RGWAccessControlPolicy policy;
@@ -925,7 +923,7 @@ int main(int argc, char **argv)
     string id;
     RGWAccessHandle handle;
 
-    if (user_id) {
+    if (!user_id.empty()) {
       RGWUserBuckets buckets;
       if (rgw_read_user_buckets(user_id, buckets, false) < 0) {
         cout << "could not get buckets for uid " << user_id << std::endl;
@@ -952,7 +950,7 @@ int main(int argc, char **argv)
   }
 
   if (opt_cmd == OPT_BUCKET_LINK) {
-    if (!bucket_name) {
+    if (bucket_name.empty()) {
       cerr << "bucket name was not specified" << std::endl;
       return usage();
     }
@@ -982,14 +980,14 @@ int main(int argc, char **argv)
       }
     }
 
-    r = create_bucket(bucket_name, uid_str, info.display_name, info.auid);
+    r = create_bucket(bucket_name.c_str(), uid_str, info.display_name, info.auid);
     if (r < 0)
         cerr << "error linking bucket to user: r=" << r << std::endl;
     return -r;
   }
 
   if (opt_cmd == OPT_BUCKET_UNLINK) {
-    if (!bucket_name) {
+    if (bucket_name.empty()) {
       cerr << "bucket name was not specified" << std::endl;
       return usage();
     }
@@ -1001,7 +999,7 @@ int main(int argc, char **argv)
   }
 
   if (opt_cmd == OPT_TEMP_REMOVE) {
-    if (!date) {
+    if (date.empty()) {
       cerr << "date wasn't specified" << std::endl;
       return usage();
     }
@@ -1015,14 +1013,13 @@ int main(int argc, char **argv)
       return -EINVAL;
     }
 
-    if (time) {
-      string time_str = time;
-      if (time_str.size() != 5 && time_str.size() != 8) {
+    if (!time.empty()) {
+      if (time.size() != 5 && time.size() != 8) {
         cerr << "bad time format" << std::endl;
         return -EINVAL;
       }
       format.append(" %H:%M:%S");
-      datetime.append(time);
+      datetime.append(time.c_str());
     }
     const char *s = strptime(datetime.c_str(), format.c_str(), &tm);
     if (s && *s) {
@@ -1039,7 +1036,7 @@ int main(int argc, char **argv)
 
     int max = 1000;
     bool is_truncated;
-    IntentLogNameFilter filter(date, &tm);
+    IntentLogNameFilter filter(date.c_str(), &tm);
     do {
       int r = store->list_objects(id, bucket, max, prefix, delim, marker,
                           objs, common_prefixes, false, ns,
@@ -1058,14 +1055,14 @@ int main(int argc, char **argv)
   }
 
   if (opt_cmd == OPT_LOG_SHOW) {
-    if (!object && (!date || !bucket_name || bucket_id < 0)) {
+    if (object.empty() && (date.empty() || bucket_name.empty() || bucket_id < 0)) {
       cerr << "object or (at least one of date, bucket, bucket-id) were not specified" << std::endl;
       return usage();
     }
 
     rgw_bucket log_bucket(RGW_LOG_POOL_NAME);
     string oid;
-    if (object) {
+    if (!object.empty()) {
       oid = object;
     } else {
       char buf[16];
@@ -1098,7 +1095,7 @@ int main(int argc, char **argv)
     struct rgw_log_entry entry;
     const char *delim = " ";
 
-    if (format) {
+    if (!format.empty()) {
       formatter->reset();
       formatter->open_object_section("log");
 
@@ -1123,7 +1120,7 @@ int main(int argc, char **argv)
 
       uint64_t total_time =  entry.total_time.sec() * 1000000LL * entry.total_time.usec();
 
-      if (!format) { // for now, keeping backward compatibility a bit
+      if (format.empty()) { // for now, keeping backward compatibility a bit
         cout << (entry.owner.size() ? entry.owner : "-" ) << delim
              << entry.bucket << delim
              << entry.time << delim
@@ -1167,7 +1164,7 @@ int main(int argc, char **argv)
       }
     }
 
-    if (format) {
+    if (!format.empty()) {
       formatter->close_section();
       formatter->close_section();
       formatter->flush(cout);
@@ -1180,7 +1177,7 @@ int main(int argc, char **argv)
   }
 
   if (opt_cmd == OPT_POOL_INFO) {
-    if (!bucket_name && bucket_id < 0) {
+    if (bucket_name.empty() && bucket_id < 0) {
       cerr << "either bucket or bucket-id needs to be specified" << std::endl;
       return usage();
     }
@@ -1195,7 +1192,7 @@ int main(int argc, char **argv)
   }
 
   if (opt_cmd == OPT_BUCKET_STATS) {
-    if (!bucket_name && bucket_id < 0) {
+    if (bucket_name.empty() && bucket_id < 0) {
       cerr << "either bucket or bucket-id needs to be specified" << std::endl;
       return usage();
     }
@@ -1236,7 +1233,7 @@ int main(int argc, char **argv)
   }
 
   if (opt_cmd == OPT_POOL_CREATE) {
-    if (!bucket_name)
+    if (bucket_name.empty())
       return usage();
     string no_object;
     int ret;
@@ -1273,7 +1270,7 @@ int main(int argc, char **argv)
     string id;
     __u8 disable = (opt_cmd == OPT_USER_SUSPEND ? 1 : 0);
 
-    if (!user_id) {
+    if (user_id.empty()) {
       cerr << "uid was not specified" << std::endl;
       return usage();
     }
diff --git a/src/test/TestSignalHandlers.cc b/src/test/TestSignalHandlers.cc
index 171060506fa..0e85f5148ab 100644
--- a/src/test/TestSignalHandlers.cc
+++ b/src/test/TestSignalHandlers.cc
@@ -39,7 +39,7 @@ static int* get_null()
 
 static void simple_segv_test()
 {
-  dout(0) << "triggering SIGSEGV..." << dendl;
+  dout(-1) << "triggering SIGSEGV..." << dendl;
   int i = *get_null();
   std::cout << "i = " << i << std::endl;
 }
@@ -55,42 +55,18 @@ static void infinite_recursion_test()
   infinite_recursion_test_impl();
 }
 
-static std::string get_tmp_filename()
-{
-  char tmp[PATH_MAX];
-  memset(tmp, 0, sizeof(tmp));
-
-  const char *tdir = getenv("TMPDIR");
-  if (!tdir)
-    tdir = "/tmp";
-
-  snprintf(tmp, sizeof(tmp), "%s/%s", tdir, "test_signal_handlers_XXXXXX");
-  int fd = TEMP_FAILURE_RETRY(::mkstemp(tmp));
-  if (fd < 0) {
-    std::cout << __PRETTY_FUNCTION__ << ": mkstemp failed: "
-	      << cpp_strerror(errno) << std::endl;
-    return "";
-  }
-  TEMP_FAILURE_RETRY(::close(fd));
-  return string(tmp);
-}
-
 static void usage()
 {
-  derr << "usage: TestSignalHandlers [test]" << dendl;
-  derr << "Tests:" << dendl;
-  derr << "   simple_segv" << dendl;
-  derr << "   infinite_recursion" << dendl;
+  cerr << "usage: TestSignalHandlers [test]" << std::endl;
+  cerr << "--simple_segv: run simple_segv test" << std::endl;
+  cerr << "--infinite_recursion: run infinite_recursion test" << std::endl;
   generic_client_usage(); // Will exit()
 }
 
+typedef void (*test_fn_t)(void);
+
 int main(int argc, const char **argv)
 {
-  string tmp_log_file(get_tmp_filename());
-  if (tmp_log_file.empty())
-    return 1;
-  std::cout << "tmp_log_file = " << tmp_log_file << std::endl;
-
   vector<const char*> args;
   argv_to_vec(argc, argv, args);
   env_to_vec(args);
@@ -98,19 +74,25 @@ int main(int argc, const char **argv)
   global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
   common_init_finish(g_ceph_context);
 
-  DEFINE_CONF_VARS(usage);
-  FOR_EACH_ARG(args) {
-    if (CEPH_ARGPARSE_EQ("simple_segv", 's')) {
-      simple_segv_test();
-    }
-    else if (CEPH_ARGPARSE_EQ("infinite_recursion", 'r')) {
-      infinite_recursion_test();
-    }
-    else if (CEPH_ARGPARSE_EQ("help", 'h')) {
+  test_fn_t fn = NULL;
+  for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
+    if (ceph_argparse_double_dash(args, i)) {
+      break;
+    } else if (ceph_argparse_flag(args, i, "-h", "--help", (char*)NULL)) {
+      usage();
+    } else if (ceph_argparse_flag(args, i, "--infinite_recursion", (char*)NULL)) {
+      fn = infinite_recursion_test;
+    } else if (ceph_argparse_flag(args, i, "-s", "--simple_segv", (char*)NULL)) {
+      fn = simple_segv_test;
+    } else {
+      cerr << "Garbage at end of command line." << std::endl;
       usage();
     }
   }
-
-  std::cout << "Please select a test to run." << std::endl;
+  if (!fn) {
+    std::cerr << "Please select a test to run. Type -h for help." << std::endl;
+    usage();
+  }
+  fn();
   return 0;
 }
diff --git a/src/test/ceph_argparse.cc b/src/test/ceph_argparse.cc
index d0f1625b48d..c8e996765f0 100644
--- a/src/test/ceph_argparse.cc
+++ b/src/test/ceph_argparse.cc
@@ -270,3 +270,70 @@ TEST(CephArgParse, WithDashesAndUnderscores) {
   }
   ASSERT_EQ(found_baz, "");
 }
+
+extern bool ceph_argparse_withint(std::vector<const char*> &args,
+	std::vector<const char*>::iterator &i, int *ret,
+	std::ostringstream *oss, ...);
+
+TEST(CephArgParse, WithInt) {
+  const char *BAZSTUFF1[] = { "./myprog", "--foo", "50", "--bar", "52", NULL };
+  const char *BAZSTUFF2[] = { "./myprog", "--foo", "--bar", "52", NULL };
+  const char *BAZSTUFF3[] = { "./myprog", "--foo", "40", "--", "--bar", "42", NULL };
+
+  // normal test
+  VectorContainer bazstuff1(BAZSTUFF1);
+  ostringstream err;
+  int foo = -1, bar = -1;
+  for (std::vector<const char*>::iterator i = bazstuff1.arr.begin();
+       i != bazstuff1.arr.end(); )
+  {
+    if (ceph_argparse_double_dash(bazstuff1.arr, i)) {
+      break;
+    } else if (ceph_argparse_withint(bazstuff1.arr, i, &foo, &err, "--foo", (char*)NULL)) {
+      ASSERT_EQ(string(""), err.str());
+    } else if (ceph_argparse_withint(bazstuff1.arr, i, &bar, &err, "--bar", (char*)NULL)) {
+      ASSERT_EQ(string(""), err.str());
+    }
+    else {
+      ++i;
+    }
+  }
+  ASSERT_EQ(foo, 50);
+  ASSERT_EQ(bar, 52);
+
+  // parse error test
+  VectorContainer bazstuff2(BAZSTUFF2);
+  ostringstream err2;
+  for (std::vector<const char*>::iterator i = bazstuff2.arr.begin();
+       i != bazstuff2.arr.end(); )
+  {
+    if (ceph_argparse_double_dash(bazstuff2.arr, i)) {
+      break;
+    } else if (ceph_argparse_withint(bazstuff2.arr, i, &foo, &err2, "--foo", (char*)NULL)) {
+      ASSERT_NE(string(""), err2.str());
+    }
+    else {
+      ++i;
+    }
+  }
+
+  // double dash test
+  VectorContainer bazstuff3(BAZSTUFF3);
+  foo = -1, bar = -1;
+  for (std::vector<const char*>::iterator i = bazstuff3.arr.begin();
+       i != bazstuff3.arr.end(); )
+  {
+    if (ceph_argparse_double_dash(bazstuff3.arr, i)) {
+      break;
+    } else if (ceph_argparse_withint(bazstuff3.arr, i, &foo, &err, "--foo", (char*)NULL)) {
+      ASSERT_EQ(string(""), err.str());
+    } else if (ceph_argparse_withint(bazstuff3.arr, i, &bar, &err, "--bar", (char*)NULL)) {
+      ASSERT_EQ(string(""), err.str());
+    }
+    else {
+      ++i;
+    }
+  }
+  ASSERT_EQ(foo, 40);
+  ASSERT_EQ(bar, -1);
+}
diff --git a/src/test/cli/monmaptool/create-print.t b/src/test/cli/monmaptool/create-print.t
index bede746b208..ef7104eeadf 100644
--- a/src/test/cli/monmaptool/create-print.t
+++ b/src/test/cli/monmaptool/create-print.t
@@ -9,3 +9,10 @@
   fsid [0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12} (re)
   last_changed \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+ (re)
   created \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+ (re)
+
+  $ monmaptool --print -- mymonmap
+  monmaptool: monmap file mymonmap
+  epoch 1
+  fsid [0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12} (re)
+  last_changed \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+ (re)
+  created \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+ (re)
diff --git a/src/test/cli/monmaptool/simple.t b/src/test/cli/monmaptool/simple.t
index 9acd15919d5..0eae4bbdc69 100644
--- a/src/test/cli/monmaptool/simple.t
+++ b/src/test/cli/monmaptool/simple.t
@@ -1,3 +1,4 @@
   $ monmaptool
+  monmaptool: must specify monmap filename
    usage: [--print] [--create [--clobber]] [--add name 1.2.3.4:567] [--rm name] <mapfilename>
   [1]
diff --git a/src/tools/gceph.cc b/src/tools/gceph.cc
index 9fd0b9f5e5e..5557b775294 100644
--- a/src/tools/gceph.cc
+++ b/src/tools/gceph.cc
@@ -31,18 +31,20 @@ static std::ostringstream gss;
 
 static void usage()
 {
-  derr << "usage: gceph [options]" << dendl;
-  derr << dendl;
-  derr << "Runs the ceph graphical monitor" << dendl;
+  cerr << "usage: gceph [options]\n\n";
+  cerr << "Runs the ceph graphical monitor\n";
   generic_client_usage(); // Will exit()
 }
 
-static void parse_gceph_args(const vector<const char*> &args)
+static void parse_gceph_args(vector<const char*> &args)
 {
-  DEFINE_CONF_VARS(usage);
-  FOR_EACH_ARG(args) {
-    if (CEPH_ARGPARSE_EQ("help", 'h')) {
+  std::vector<const char*>::iterator i;
+  std::string val;
+  for (i = args.begin(); i != args.end(); ) {
+    if (ceph_argparse_flag(args, i, "-h", "--help", (char*)NULL)) {
       usage();
+    } else {
+      ++i;
     }
   }
 }
@@ -73,18 +75,15 @@ int main(int argc, const char **argv)
 {
   int ret = 0;
 
-  DEFINE_CONF_VARS(usage);
   vector<const char*> args;
   argv_to_vec(argc, argv, args);
   env_to_vec(args);
 
+  parse_gceph_args(args);
   global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
   common_init_finish(g_ceph_context);
-
   vec_to_argv(args, argc, argv);
 
-  parse_gceph_args(args);
-
   ctx = ceph_tool_common_init(CEPH_TOOL_MODE_GUI, false);
   if (!ctx) {
     derr << "cephtool_common_init failed." << dendl;