Index: aim.c
===================================================================
--- aim.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ aim.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -136,7 +136,7 @@
   priv=g_new0(struct owlfaim_priv, 1);
 
-  priv->screenname = owl_strdup(screenname);
-  priv->password = owl_strdup(password);
-  priv->server = owl_strdup(FAIM_LOGIN_SERVER);
+  priv->screenname = g_strdup(screenname);
+  priv->password = g_strdup(password);
+  priv->server = g_strdup(FAIM_LOGIN_SERVER);
   sess->aux_data = priv;
 
@@ -346,5 +346,5 @@
   /* there is a max away message lentgh we should check against */
 
-  foo=owl_strdup(msg);
+  foo=g_strdup(msg);
   len=strlen(foo);
   if (len>500) {
@@ -1025,5 +1025,5 @@
 
   if (!args->msg) {
-    realmsg = owl_strdup("");
+    realmsg = g_strdup("");
   } else if (args->icbmflags & AIM_IMFLAGS_UNICODE) {
     realmsg = g_convert(args->msg, args->msglen, "UTF-8", "UCS-2BE",
@@ -1033,9 +1033,9 @@
                         NULL, NULL, NULL);
   } else {
-    realmsg = owl_strdup(args->msg);
+    realmsg = g_strdup(args->msg);
   }
 
   if (!realmsg) {
-    realmsg = owl_strdup("[Error decoding incoming IM]");
+    realmsg = g_strdup("[Error decoding incoming IM]");
   }
 
Index: buddy.c
===================================================================
--- buddy.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ buddy.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -4,5 +4,5 @@
 {
   b->proto=proto;
-  b->name=owl_strdup(name);
+  b->name=g_strdup(name);
   b->idlesince=0;
 }
Index: cmd.c
===================================================================
--- cmd.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ cmd.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -88,5 +88,5 @@
   char *retval = NULL;
 
-  tmpbuff=owl_strdup(cmdbuff);
+  tmpbuff=g_strdup(cmdbuff);
   argv=owl_parseline(tmpbuff, &argc);
   if (argc < 0) {
@@ -135,9 +135,9 @@
   *cmd = *templ;
   if (!templ->name) return(-1);
-  cmd->name = owl_strdup(templ->name);
-  if (templ->summary)     cmd->summary     = owl_strdup(templ->summary);
-  if (templ->usage)       cmd->usage       = owl_strdup(templ->usage);
-  if (templ->description) cmd->description = owl_strdup(templ->description);
-  if (templ->cmd_aliased_to) cmd->cmd_aliased_to = owl_strdup(templ->cmd_aliased_to);
+  cmd->name = g_strdup(templ->name);
+  if (templ->summary)     cmd->summary     = g_strdup(templ->summary);
+  if (templ->usage)       cmd->usage       = g_strdup(templ->usage);
+  if (templ->description) cmd->description = g_strdup(templ->description);
+  if (templ->cmd_aliased_to) cmd->cmd_aliased_to = g_strdup(templ->cmd_aliased_to);
   return(0);
 }
@@ -145,6 +145,6 @@
 int owl_cmd_create_alias(owl_cmd *cmd, const char *name, const char *aliased_to) {
   memset(cmd, 0, sizeof(owl_cmd));
-  cmd->name = owl_strdup(name);
-  cmd->cmd_aliased_to = owl_strdup(aliased_to);
+  cmd->name = g_strdup(name);
+  cmd->cmd_aliased_to = g_strdup(aliased_to);
   cmd->summary = owl_sprintf("%s%s", OWL_CMD_ALIAS_SUMMARY_PREFIX, aliased_to);
   return(0);
Index: commands.c
===================================================================
--- commands.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ commands.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -1274,5 +1274,5 @@
       argc-=1; argv+=1; 
     } else if (argc>=2 && !strcmp(argv[1], "--filter")) {
-      filter = owl_strdup(argv[2]);
+      filter = g_strdup(argv[2]);
       argc-=2; argv+=2; 
     } else if (argc>=2 && !strcmp(argv[1], "--smart-filter")) {
@@ -1304,5 +1304,5 @@
       argc-=1; argv+=1; 
     } else if (argc>=2 && !strcmp(argv[1], "--filter")) {
-      filter = owl_strdup(argv[2]);
+      filter = g_strdup(argv[2]);
       argc-=2; argv+=2; 
     } else if (argc>=2 && !strcmp(argv[1], "--smart-filter")) {
@@ -1675,5 +1675,5 @@
     return NULL;
   }
-  newbuff = owl_strdup(skiptokens(buff, 1));
+  newbuff = g_strdup(skiptokens(buff, 1));
   if (!strcmp(argv[0], "(")) {
     for (i=strlen(newbuff)-1; i>=0; i--) {
@@ -2501,5 +2501,5 @@
   }
   filtname = owl_view_get_filtname(owl_global_get_current_view(&g));
-  if (filtname) return owl_strdup(filtname);
+  if (filtname) return g_strdup(filtname);
   return NULL;
 }
@@ -2516,5 +2516,5 @@
     return NULL;
   }
-  return owl_strdup(tmpbuff); 
+  return g_strdup(tmpbuff); 
 }
 
@@ -2576,5 +2576,5 @@
   if (argc==2) {
     owl_editwin *e = owl_function_start_password("AIM Password: ");
-    owl_editwin_set_cbdata(e, owl_strdup(argv[1]), g_free);
+    owl_editwin_set_cbdata(e, g_strdup(argv[1]), g_free);
     owl_editwin_set_callback(e, owl_callback_aimlogin);
     return(NULL);
@@ -2604,5 +2604,5 @@
   }
   stylename = owl_view_get_style_name(owl_global_get_current_view(&g));
-  if (stylename) return owl_strdup(stylename);
+  if (stylename) return g_strdup(stylename);
   return NULL;
 }
Index: context.c
===================================================================
--- context.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ context.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -15,5 +15,5 @@
   c->data = data;
   c->cursor = cursor ? g_object_ref(cursor) : NULL;
-  c->keymap = owl_strdup(keymap);
+  c->keymap = g_strdup(keymap);
   return c;
 }
Index: dict.c
===================================================================
--- dict.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ dict.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -65,5 +65,5 @@
   if (owl_list_create(l)) return(-1);
   for (i=0; i<d->size; i++) {
-    if ((dupk = owl_strdup(d->els[i].k)) == NULL) return(-1);
+    if ((dupk = g_strdup(d->els[i].k)) == NULL) return(-1);
     owl_list_append_element(l, dupk);
   }
@@ -100,5 +100,5 @@
       if (d->els==NULL) return(-1);
     }
-    if ((dupk = owl_strdup(k)) == NULL) return(-1);
+    if ((dupk = g_strdup(k)) == NULL) return(-1);
     if (pos!=d->size) {
       /* shift forward to leave us a slot */
Index: errqueue.c
===================================================================
--- errqueue.c	(revision 5b256de39a5d9dad12a4987cedc28995066d5571)
+++ errqueue.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -8,5 +8,5 @@
 void owl_errqueue_append_err(owl_errqueue *eq, const char *msg)
 {
-  owl_list_append_element(&(eq->errlist), owl_strdup(msg));
+  owl_list_append_element(&(eq->errlist), g_strdup(msg));
 }
 
Index: filter.c
===================================================================
--- filter.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ filter.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -21,5 +21,5 @@
   f = g_new(owl_filter, 1);
 
-  f->name=owl_strdup(name);
+  f->name=g_strdup(name);
   f->fgcolor=OWL_COLOR_DEFAULT;
   f->bgcolor=OWL_COLOR_DEFAULT;
Index: filterelement.c
===================================================================
--- filterelement.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ filterelement.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -214,5 +214,5 @@
 {
   owl_filterelement_create(fe);
-  fe->field=owl_strdup(field);
+  fe->field=g_strdup(field);
   if(owl_regex_create(&(fe->re), re)) {
     g_free(fe->field);
@@ -228,5 +228,5 @@
 {
   owl_filterelement_create(fe);
-  fe->field=owl_strdup(name);
+  fe->field=g_strdup(name);
   fe->match_message = owl_filterelement_match_filter;
   fe->print_elt = owl_filterelement_print_filter;
@@ -236,5 +236,5 @@
 {
   owl_filterelement_create(fe);
-  fe->field=owl_strdup(name);
+  fe->field=g_strdup(name);
   fe->match_message = owl_filterelement_match_perl;
   fe->print_elt = owl_filterelement_print_perl;
Index: functions.c
===================================================================
--- functions.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ functions.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -358,5 +358,5 @@
   owl_function_start_edit_win(line,
                               &owl_callback_aimwrite,
-                              owl_strdup(to),
+                              g_strdup(to),
                               g_free);
   g_free(line);
@@ -436,5 +436,5 @@
     owl_zwrite_set_message(z, msg);
   }
-  old_msg = owl_strdup(owl_zwrite_get_message(z));
+  old_msg = g_strdup(owl_zwrite_get_message(z));
 
   zcrypt = owl_sprintf("%s/zcrypt", owl_get_bindir());
@@ -491,5 +491,5 @@
 
   /* make a formatted copy of the message */
-  format_msg = owl_strdup(msg);
+  format_msg = g_strdup(msg);
   if (unwrap)
     owl_text_wordunwrap(format_msg);
@@ -522,5 +522,5 @@
 
   /* make a formatted copy of the message */
-  format_msg=owl_strdup(msg);
+  format_msg=g_strdup(msg);
   owl_text_wordunwrap(format_msg);
   
@@ -2191,5 +2191,5 @@
   
   if (!strncmp(filtername, "not-", 4)) {
-    newname=owl_strdup(filtername+4);
+    newname=g_strdup(filtername+4);
   } else {
     newname=owl_sprintf("not-%s", filtername);
@@ -2297,7 +2297,7 @@
     }
   } else {
-    class = owl_strdup(c);
+    class = g_strdup(c);
     if (i) {
-      instance = owl_strdup(i);
+      instance = g_strdup(i);
     }
   }
@@ -2429,5 +2429,5 @@
   /* if it already exists then go with it.  This lets users override */
   if (owl_global_get_filter(&g, filtname)) {
-    return(owl_strdup(filtname));
+    return(g_strdup(filtname));
   }
 
@@ -3051,5 +3051,5 @@
 	timestr=owl_util_minutes_to_timestr(idle);
       } else {
-	timestr=owl_strdup("");
+	timestr=g_strdup("");
       }
       owl_fmtext_appendf_normal(&fm, "  %-20.20s %-12.12s\n", owl_buddy_get_name(b), timestr);
@@ -3286,5 +3286,5 @@
   if (!filename) {
     fail_silent = 1;
-    path = owl_strdup(owl_global_get_startupfile(&g));
+    path = g_strdup(owl_global_get_startupfile(&g));
   } else {
     path = owl_util_makepath(filename);
@@ -3389,5 +3389,5 @@
 
   now=time(NULL);
-  date=owl_strdup(ctime(&now));
+  date=g_strdup(ctime(&now));
   date[strlen(date)-1]='\0';
 
Index: global.c
===================================================================
--- global.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ global.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -26,7 +26,7 @@
   hent=gethostbyname(hostname);
   if (!hent) {
-    g->thishost=owl_strdup("localhost");
+    g->thishost=g_strdup("localhost");
   } else {
-    g->thishost=owl_strdup(hent->h_name);
+    g->thishost=g_strdup(hent->h_name);
   }
 
@@ -90,5 +90,5 @@
   if (!homedir)
     homedir = g_get_home_dir();
-  g->homedir = owl_strdup(homedir);
+  g->homedir = g_strdup(homedir);
 
   g->confdir = NULL;
@@ -380,5 +380,5 @@
 void owl_global_set_confdir(owl_global *g, const char *cd) {
   g_free(g->confdir);
-  g->confdir = owl_strdup(cd);
+  g->confdir = g_strdup(cd);
   g_free(g->startupfile);
   g->startupfile = owl_sprintf("%s/startup", cd);
@@ -701,5 +701,5 @@
   if (g->aim_screenname) g_free(g->aim_screenname);
   if (g->aim_screenname_for_filters) g_free(g->aim_screenname_for_filters);
-  g->aim_screenname=owl_strdup(screenname);
+  g->aim_screenname=g_strdup(screenname);
   sn_escaped = owl_text_quote(screenname, OWL_REGEX_QUOTECHARS, OWL_REGEX_QUOTEWITH);
   g->aim_screenname_for_filters = owl_arg_quote(sn_escaped);
@@ -973,5 +973,5 @@
 
     g_free(open_file);
-    open_file = owl_strdup(filename);
+    open_file = g_strdup(filename);
   }
   return g->debug_file;
Index: history.c
===================================================================
--- history.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ history.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -69,5 +69,5 @@
 
   /* add the new line */
-  owl_list_prepend_element(&(h->hist), owl_strdup(line));
+  owl_list_prepend_element(&(h->hist), g_strdup(line));
 }
 
Index: keybinding.c
===================================================================
--- keybinding.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ keybinding.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -27,7 +27,7 @@
   }
 
-  if (command) kb->command = owl_strdup(command);
+  if (command) kb->command = g_strdup(command);
   kb->function_fn = function_fn;
-  if (desc) kb->desc = owl_strdup(desc);
+  if (desc) kb->desc = g_strdup(desc);
   else kb->desc = NULL;
   return(0);
Index: keymap.c
===================================================================
--- keymap.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ keymap.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -9,6 +9,6 @@
 {
   if (!name || !desc) return(-1);
-  if ((km->name = owl_strdup(name)) == NULL) return(-1);
-  if ((km->desc = owl_strdup(desc)) == NULL) return(-1);
+  if ((km->name = g_strdup(name)) == NULL) return(-1);
+  if ((km->desc = g_strdup(desc)) == NULL) return(-1);
   if (0 != owl_list_create(&km->bindings)) return(-1);
   km->parent = NULL;
Index: logging.c
===================================================================
--- logging.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ logging.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -159,5 +159,5 @@
     g_free(temp);
   } else {
-    to = owl_strdup("loopback");
+    to = g_strdup("loopback");
   }
 
@@ -262,5 +262,5 @@
       from=frombuff=short_zuser(owl_message_get_sender(m));
     } else {
-      from=frombuff=owl_strdup(owl_message_get_class(m));
+      from=frombuff=g_strdup(owl_message_get_class(m));
     }
   } else if (owl_message_is_type_aim(m)) {
@@ -273,5 +273,5 @@
     g_free(temp);
   } else if (owl_message_is_type_loopback(m)) {
-    from=frombuff=owl_strdup("loopback");
+    from=frombuff=g_strdup("loopback");
   } else if (owl_message_is_type_jabber(m)) {
     if (personal) {
@@ -281,5 +281,5 @@
     }
   } else {
-    from=frombuff=owl_strdup("unknown");
+    from=frombuff=g_strdup("unknown");
   }
   
Index: message.c
===================================================================
--- message.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ message.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -47,5 +47,5 @@
   /* save the time */
   m->time=time(NULL);
-  m->timestr=owl_strdup(ctime(&(m->time)));
+  m->timestr=g_strdup(ctime(&(m->time)));
   m->timestr[strlen(m->timestr)-1]='\0';
 
@@ -131,5 +131,5 @@
       buff=owl_sprintf("  %-15.15s: %-35.35s\n", owl_pair_get_key(p), "<error>");
       if(buff == NULL)
-        buff=owl_strdup("   <error>\n");
+        buff=g_strdup("   <error>\n");
     }
     owl_fmtext_append_normal(fm, buff);
@@ -586,5 +586,5 @@
   cur+=3;
   while (*cur && *cur==' ') cur++;
-  out = owl_strdup(cur);
+  out = g_strdup(cur);
   end = strchr(out, '\n');
   if (end) end[0] = '\0';
@@ -609,5 +609,5 @@
     shortuser = short_zuser(user);
     if (strcasecmp(shortuser, recip) != 0) {
-      out = g_list_prepend(out, owl_strdup(user));
+      out = g_list_prepend(out, g_strdup(user));
     }
     g_free(shortuser);
@@ -795,5 +795,5 @@
   if (m->timestr) g_free(m->timestr);
   m->time=n->z_time.tv_sec;
-  m->timestr=owl_strdup(ctime(&(m->time)));
+  m->timestr=g_strdup(ctime(&(m->time)));
   m->timestr[strlen(m->timestr)-1]='\0';
 
Index: msgwin.c
===================================================================
--- msgwin.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ msgwin.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -24,5 +24,5 @@
 void owl_msgwin_set_text(owl_msgwin *msgwin, const char *msg)
 {
-  owl_msgwin_set_text_nocopy(msgwin, owl_strdup(msg));
+  owl_msgwin_set_text_nocopy(msgwin, g_strdup(msg));
 }
 
Index: owl.c
===================================================================
--- owl.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ owl.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -80,11 +80,11 @@
       break;
     case 'c':
-      opts->configfile = owl_strdup(optarg);
+      opts->configfile = g_strdup(optarg);
       break;
     case 's':
-      opts->confdir = owl_strdup(optarg);
+      opts->confdir = g_strdup(optarg);
       break;
     case 't':
-      opts->tty = owl_strdup(optarg);
+      opts->tty = g_strdup(optarg);
       break;
     case 'D':
Index: perlconfig.c
===================================================================
--- perlconfig.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ perlconfig.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -148,5 +148,5 @@
   type = owl_message_get_type(m);
   if(!type || !*type) type = "generic";
-  utype = owl_strdup(type);
+  utype = g_strdup(type);
   utype[0] = toupper(type[0]);
   blessas = owl_sprintf("BarnOwl::Message::%s", utype);
@@ -214,5 +214,5 @@
       owl_message_set_zwriteline(m, val);
     } else if (!strcmp(key, "time")) {
-      m->timestr = owl_strdup(val);
+      m->timestr = g_strdup(val);
       strptime(val, "%a %b %d %T %Y", &tm);
       m->time = mktime(&tm);
@@ -282,5 +282,5 @@
 
   if (srv) {
-    out = owl_strdup(SvPV_nolen(srv));
+    out = g_strdup(SvPV_nolen(srv));
   } else {
     out = NULL;
@@ -335,5 +335,5 @@
 
   if (srv) {
-    out = owl_strdup(SvPV_nolen(srv));
+    out = g_strdup(SvPV_nolen(srv));
   } else {
     out = NULL;
@@ -369,5 +369,5 @@
   ret=perl_parse(p, owl_perl_xs_init, 2, (char **)args, NULL);
   if (ret || SvTRUE(ERRSV)) {
-    err=owl_strdup(SvPV_nolen(ERRSV));
+    err=g_strdup(SvPV_nolen(ERRSV));
     sv_setsv(ERRSV, &PL_sv_undef);     /* and clear the error */
     return(err);
@@ -376,5 +376,5 @@
   ret=perl_run(p);
   if (ret || SvTRUE(ERRSV)) {
-    err=owl_strdup(SvPV_nolen(ERRSV));
+    err=g_strdup(SvPV_nolen(ERRSV));
     sv_setsv(ERRSV, &PL_sv_undef);     /* and clear the error */
     return(err);
@@ -412,5 +412,5 @@
 
   if (SvTRUE(ERRSV)) {
-    err=owl_strdup(SvPV_nolen(ERRSV));
+    err=g_strdup(SvPV_nolen(ERRSV));
     sv_setsv (ERRSV, &PL_sv_undef);     /* and clear the error */
     return(err);
@@ -450,5 +450,5 @@
   }
 
-  out = owl_strdup(SvPV(response, len));
+  out = g_strdup(SvPV(response, len));
   FREETMPS;
   LEAVE;
@@ -529,5 +529,5 @@
     rv = POPs;
     if(SvTRUE(rv)) {
-      ret = owl_strdup(SvPV_nolen(rv));
+      ret = g_strdup(SvPV_nolen(rv));
     }
   }
Index: regex.c
===================================================================
--- regex.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ regex.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -14,5 +14,5 @@
   const char *ptr;
   
-  re->string=owl_strdup(string);
+  re->string=g_strdup(string);
 
   ptr=string;
Index: select.c
===================================================================
--- select.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ select.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -23,5 +23,5 @@
   t->destroy = destroy;
   t->data = data;
-  t->name = name ? owl_strdup(name) : NULL;
+  t->name = name ? g_strdup(name) : NULL;
 
   *timers = g_list_insert_sorted(*timers, t,
Index: style.c
===================================================================
--- style.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ style.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -5,5 +5,5 @@
 void owl_style_create_perl(owl_style *s, const char *name, SV *obj)
 {
-  s->name=owl_strdup(name);
+  s->name=g_strdup(name);
   s->perlobj = obj;
 }
Index: text.c
===================================================================
--- text.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ text.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -193,5 +193,5 @@
   int cur, lastspace, len, lastnewline;
 
-  out=owl_strdup(in);
+  out=g_strdup(in);
   len=strlen(in);
   cur=0;
@@ -276,5 +276,5 @@
   int   outlen, tolen, fromlen, inpos=0, outpos=0;
 
-  if (!*from) return owl_strdup(in);
+  if (!*from) return g_strdup(in);
 
   outlen = strlen(in)+1;
Index: util.c
===================================================================
--- util.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ util.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -292,11 +292,4 @@
 }
 
-/* hooks for doing memory allocation et. al. in owl */
-
-char *owl_strdup(const char *s1)
-{
-  return(g_strdup(s1));
-}
-
 /* allocates memory and returns the string or null.
  * caller must free the string. 
@@ -363,13 +356,13 @@
 
   if (getenv("DISPLAY")) {
-    out=owl_strdup(getenv("DISPLAY"));
+    out=g_strdup(getenv("DISPLAY"));
   } else if ((tmp=ttyname(fileno(stdout)))!=NULL) {
-    out=owl_strdup(tmp);
+    out=g_strdup(tmp);
     if (!strncmp(out, "/dev/", 5)) {
       g_free(out);
-      out=owl_strdup(tmp+5);
+      out=g_strdup(tmp+5);
     }
   } else {
-    out=owl_strdup("unknown");
+    out=g_strdup("unknown");
   }
   return(out);
@@ -384,5 +377,5 @@
   char  *tmp, *ptr1, *ptr2, *out;
 
-  ptr1=tmp=owl_strdup(in);
+  ptr1=tmp=g_strdup(in);
   while (ptr1[0]=='\n') {
     ptr1++;
@@ -394,5 +387,5 @@
   }
 
-  out=owl_strdup(ptr1);
+  out=g_strdup(ptr1);
   g_free(tmp);
   return(out);
@@ -545,5 +538,5 @@
   }
 
-  start = owl_strdup(class);
+  start = g_strdup(class);
   end = start + strlen(start) - 1;
   while(end > start && *end == 'd' && *(end-1) == '.') {
@@ -601,5 +594,5 @@
   }
   else {
-    r = owl_strdup("");
+    r = g_strdup("");
   }
   return r;
@@ -630,7 +623,7 @@
   char *out;
   if (g_utf8_validate(in, -1, NULL)) {
-    out = owl_strdup(in);
+    out = g_strdup(in);
   } else {
-    out = owl_strdup("");
+    out = g_strdup("");
   }
   return out;
Index: variable.c
===================================================================
--- variable.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ variable.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -482,7 +482,7 @@
     *cur = *var;
     /* strdup all the strings so we can delete them consistently. */
-    cur->name = owl_strdup(var->name);
-    cur->summary = owl_strdup(var->summary);
-    cur->description = owl_strdup(var->description);
+    cur->name = g_strdup(var->name);
+    cur->summary = g_strdup(var->summary);
+    cur->description = g_strdup(var->description);
     switch (cur->type) {
     case OWL_VARIABLE_OTHER:
@@ -552,7 +552,7 @@
 owl_variable * owl_variable_newvar(const char *name, const char *summary, const char * description) {
   owl_variable * var = g_new0(owl_variable, 1);
-  var->name = owl_strdup(name);
-  var->summary = owl_strdup(summary);
-  var->description = owl_strdup(description);
+  var->name = g_strdup(name);
+  var->summary = g_strdup(summary);
+  var->description = g_strdup(description);
   return var;
 }
@@ -560,7 +560,7 @@
 void owl_variable_update(owl_variable *var, const char *summary, const char *desc) {
   if(var->summary) g_free(var->summary);
-  var->summary = owl_strdup(summary);
+  var->summary = g_strdup(summary);
   if(var->description) g_free(var->description);
-  var->description = owl_strdup(desc);
+  var->description = g_strdup(desc);
 }
 
@@ -570,9 +570,9 @@
     owl_variable_update(old, summ, desc);
     if(old->pval_default) g_free(old->pval_default);
-    old->pval_default = owl_strdup(initval);
+    old->pval_default = g_strdup(initval);
   } else {
     owl_variable * var = owl_variable_newvar(name, summ, desc);
     var->type = OWL_VARIABLE_STRING;
-    var->pval_default = owl_strdup(initval);
+    var->pval_default = g_strdup(initval);
     var->set_fn = owl_variable_string_set_default;
     var->set_fromstring_fn = owl_variable_string_set_fromstring_default;
@@ -1009,5 +1009,5 @@
   }
   if (v->val) g_free(v->val);
-  v->val = owl_strdup(newval);
+  v->val = g_strdup(newval);
   return(0);
 }
Index: view.c
===================================================================
--- view.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ view.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -4,5 +4,5 @@
 void owl_view_create(owl_view *v, const char *name, owl_filter *f, const owl_style *s)
 {
-  v->name=owl_strdup(name);
+  v->name=g_strdup(name);
   v->filter=f;
   v->style=s;
Index: zephyr.c
===================================================================
--- zephyr.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ zephyr.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -23,5 +23,5 @@
 {
   if (input != NULL)
-    return owl_strdup(input);
+    return g_strdup(input);
   else
     return owl_sprintf("%s/%s", owl_global_get_homedir(&g), name);
@@ -292,11 +292,11 @@
     if ((tmp = strtok(start, ",\n\r")) == NULL)
       continue;
-    subs[count].zsub_class = owl_strdup(tmp);
+    subs[count].zsub_class = g_strdup(tmp);
     if ((tmp=strtok(NULL, ",\n\r")) == NULL)
       continue;
-    subs[count].zsub_classinst = owl_strdup(tmp);
+    subs[count].zsub_classinst = g_strdup(tmp);
     if ((tmp = strtok(NULL, " \t\n\r")) == NULL)
       continue;
-    subs[count].zsub_recipient = owl_strdup(tmp);
+    subs[count].zsub_recipient = g_strdup(tmp);
 
     /* if it started with '-' then add it to the global punt list, and
@@ -337,7 +337,7 @@
   count=0;
 
-  subs[count].zsub_class=owl_strdup("message");
-  subs[count].zsub_classinst=owl_strdup("*");
-  subs[count].zsub_recipient=owl_strdup("%me%");
+  subs[count].zsub_class=g_strdup("message");
+  subs[count].zsub_classinst=g_strdup("*");
+  subs[count].zsub_recipient=g_strdup("%me%");
   count++;
 
@@ -400,6 +400,6 @@
       }
 
-      subs[count].zsub_class = owl_strdup("login");
-      subs[count].zsub_recipient = owl_strdup("*");
+      subs[count].zsub_class = g_strdup("login");
+      subs[count].zsub_recipient = g_strdup("*");
       subs[count].zsub_classinst = long_zuser(buffer);
 
@@ -483,5 +483,5 @@
   /* If there's no message here, just run along now */
   if (n->z_message_len == 0)
-    return(owl_strdup(""));
+    return(g_strdup(""));
 
   count=save=0;
@@ -491,5 +491,5 @@
       if (count==j) {
 	/* just found the end of the field we're looking for */
-	return(owl_strdup(n->z_message+save));
+	return(g_strdup(n->z_message+save));
       } else {
 	save=i+1;
@@ -502,5 +502,5 @@
   }
 
-  return(owl_strdup(""));
+  return(g_strdup(""));
 }
 
@@ -511,5 +511,5 @@
   /* If there's no message here, just run along now */
   if (n->z_message_len == 0)
-    return(owl_strdup(""));
+    return(g_strdup(""));
 
   count=save=0;
@@ -534,10 +534,10 @@
   }
 
-  return(owl_strdup(""));
+  return(g_strdup(""));
 }
 #else
 char *owl_zephyr_get_field(void *n, int j)
 {
-  return(owl_strdup(""));
+  return(g_strdup(""));
 }
 char *owl_zephyr_get_field_as_utf8(void *n, int j)
@@ -578,5 +578,5 @@
   /* don't let ping messages have a body */
   if (!strcasecmp(n->z_opcode, "ping")) {
-    return(owl_strdup(""));
+    return(g_strdup(""));
   }
 
@@ -804,16 +804,16 @@
 
       memset(&zw, 0, sizeof(zw));
-      zw.class = owl_strdup(retnotice->z_class);
-      zw.inst  = owl_strdup(retnotice->z_class_inst);
+      zw.class = g_strdup(retnotice->z_class);
+      zw.inst  = g_strdup(retnotice->z_class_inst);
       realm = strchr(retnotice->z_recipient, '@');
       if(realm) {
-        zw.realm = owl_strdup(realm + 1);
+        zw.realm = g_strdup(realm + 1);
       } else {
-        zw.realm = owl_strdup(owl_zephyr_get_realm());
+        zw.realm = g_strdup(owl_zephyr_get_realm());
       }
-      zw.opcode = owl_strdup(retnotice->z_opcode);
-      zw.zsig   = owl_strdup("");
+      zw.opcode = g_strdup(retnotice->z_opcode);
+      zw.zsig   = g_strdup("");
       owl_list_create(&(zw.recips));
-      owl_list_append_element(&(zw.recips), owl_strdup(tmp));
+      owl_list_append_element(&(zw.recips), g_strdup(tmp));
 
       owl_log_outgoing_zephyr_error(&zw, buff);
@@ -870,5 +870,5 @@
     to=owl_zephyr_smartstripped_user(owl_message_get_sender(m));
   } else {
-    to=owl_strdup(owl_message_get_sender(m));
+    to=g_strdup(owl_message_get_sender(m));
   }
 
@@ -934,5 +934,5 @@
     result = owl_sprintf("%s: Hidden or not logged in\n", myuser);
   } else {
-    result = owl_strdup("");
+    result = g_strdup("");
     for (; numlocs; numlocs--) {
       ZGetLocations(&locations, &one);
@@ -950,5 +950,5 @@
   return result;
 #else
-  return owl_strdup("");
+  return g_strdup("");
 #endif
 }
@@ -1132,7 +1132,7 @@
   ret=ZRetrieveSubscriptions(0, &num);
   if (ret==ZERR_TOOMANYSUBS) {
-    return(owl_strdup("Zephyr: too many subscriptions\n"));
+    return(g_strdup("Zephyr: too many subscriptions\n"));
   } else if (ret || (num <= 0)) {
-    return(owl_strdup("Zephyr: error retriving subscriptions\n"));
+    return(g_strdup("Zephyr: error retriving subscriptions\n"));
   }
 
@@ -1143,5 +1143,5 @@
       ZFlushSubscriptions();
       g_string_free(buf, true);
-      return owl_strdup("Error while getting subscriptions\n");
+      return g_strdup("Error while getting subscriptions\n");
     } else {
       /* g_string_append_printf would be backwards. */
@@ -1158,5 +1158,5 @@
   return g_string_free(buf, false);
 #else
-  return(owl_strdup("Zephyr not available"));
+  return(g_strdup("Zephyr not available"));
 #endif
 }
@@ -1185,5 +1185,5 @@
   char *out, *ptr;
 
-  out=owl_strdup(in);
+  out=g_strdup(in);
   ptr=strchr(out, '@');
   if (ptr) {
@@ -1201,5 +1201,5 @@
 {
   if (strchr(in, '@')) {
-    return(owl_strdup(in));
+    return(g_strdup(in));
   }
   return(owl_sprintf("%s@%s", in, owl_zephyr_get_realm()));
@@ -1215,5 +1215,5 @@
   char *slash, *dot, *realm, *out;
 
-  out = owl_strdup(in);
+  out = g_strdup(in);
 
   /* bail immeaditly if we don't have to do any work */
Index: zwrite.c
===================================================================
--- zwrite.c	(revision ddbbcffae8064f4d266a9735a16225e4feef1a3c)
+++ zwrite.c	(revision d4927a70549407fe7f56b4ae1d3949663a370205)
@@ -35,5 +35,5 @@
   z->noping=0;
   owl_list_create(&(z->recips));
-  z->zwriteline = owl_strdup(line);
+  z->zwriteline = g_strdup(line);
 
   /* parse the command line for options */
@@ -46,5 +46,5 @@
   myargc=argc;
   if (myargc && *(myargv[0])!='-') {
-    z->cmd=owl_strdup(myargv[0]);
+    z->cmd=g_strdup(myargv[0]);
     myargc--;
     myargv++;
@@ -137,8 +137,8 @@
 
   /* now deal with defaults */
-  if (z->class==NULL) z->class=owl_strdup("message");
-  if (z->inst==NULL) z->inst=owl_strdup("personal");
-  if (z->realm==NULL) z->realm=owl_strdup("");
-  if (z->opcode==NULL) z->opcode=owl_strdup("");
+  if (z->class==NULL) z->class=g_strdup("message");
+  if (z->inst==NULL) z->inst=g_strdup("personal");
+  if (z->realm==NULL) z->realm=g_strdup("");
+  if (z->opcode==NULL) z->opcode=g_strdup("");
   /* z->message is allowed to stay NULL */
 
@@ -178,5 +178,5 @@
       to = owl_sprintf("%s@%s", (const char *) owl_list_get_element(&(z->recips), i), z->realm);
     } else {
-      to = owl_strdup(owl_list_get_element(&(z->recips), i));
+      to = g_strdup(owl_list_get_element(&(z->recips), i));
     }
     send_ping(to, z->class, z->inst);
@@ -203,5 +203,5 @@
   j=owl_list_get_size(&(z->recips));
   if (j>0 && z->cc) {
-    toline = owl_strdup( "CC: ");
+    toline = g_strdup( "CC: ");
     for (i=0; i<j; i++) {
       tmp = toline;
@@ -252,5 +252,5 @@
         to = owl_sprintf("%s@%s", (const char *) owl_list_get_element(&(z->recips), i), z->realm);
       } else {
-        to = owl_strdup( owl_list_get_element(&(z->recips), i));
+        to = g_strdup( owl_list_get_element(&(z->recips), i));
       }
       ret = send_zephyr(z->opcode, z->zsig, z->class, z->inst, to, z->message);
@@ -319,5 +319,5 @@
 {
   if(z->zsig) g_free(z->zsig);
-  z->zsig = owl_strdup(zsig);
+  z->zsig = g_strdup(zsig);
 }
 
