Remove vasprintf module.

4 files changed, 36 insertions, 15 deletions

diff --git a/src/lock.c b/src/lock.c
index 1c3a657..bc8505c 100644
--- a/src/lock.c
+++ b/src/lock.c
@@ -169,32 +169,33 @@ expire_stale_lock (const char *file)
 	stale = 1;
     }
   
   close (fd);
   if (stale)
     unlink (file);
 }
 
 int
 wydawca_lock (const char *lockname)
 {
   char *tempname = NULL;
+  size_t size = 0;
   int rc;
   
   if (!enable_locking)
     return 0;
   expire_stale_lock (lockname);
 
   /* build the NFS hitching-post to the lock file */
-  asprintf (&tempname, "%s.%lu.%lu.%s",
+  grecs_asprintf (&tempname, &size, "%s.%lu.%lu.%s",
 		  lockname,
 		  (unsigned long) getpid (),
 		  (unsigned long) time (NULL), xgethostname ());
   if (!tempname)
     return LOCK_FAILURE;
   if (lock_timeout)
     {
       time_t start = time (NULL);
 
       do
 	{
 	  rc = _lock_internal (lockname, tempname);
@@ -226,26 +227,27 @@ fix_tagname (const char *tag)
   char *p;
   
   for (p = tagname; *p; p++)
     if (!c_isalnum (*p) && *p != '_' && *p != '-')
       *p = '_';
   return tagname;
 }  
 
 char *
 wydawca_lockname (const char *tag)
 {
   char *lockname = NULL;
+  size_t size = 0;
   char *tagname = fix_tagname (tag);
-  asprintf (&lockname, "%s/LCK.%s", lockdir, tagname);
+  grecs_asprintf (&lockname, &size, "%s/LCK.%s", lockdir, tagname);
   if (!lockname)
     xalloc_die ();
   free (tagname);
   return lockname;
 }
 
 void
 wydawca_lock_init ()
 {
   if (enable_locking)
     {
       if (!lockdir)
diff --git a/src/report.c b/src/report.c
index 84a9592..b09c7c7 100644
--- a/src/report.c
+++ b/src/report.c
@@ -25,28 +25,31 @@ report_init ()
 {
   if (!report_stk_inited)
     obstack_init (&report_stk);
   else
     obstack_free (&report_stk, report_string);
 }
 
 void
 report_add (const char *fmt, ...)
 {
   va_list ap;
   char *str = NULL;
+  size_t size = 0;
+  
   va_start (ap, fmt);
-  vasprintf (&str, fmt, ap);
+  grecs_vasprintf (&str, &size, fmt, ap);
   va_end (ap);
   if (str)
     {
       obstack_grow (&report_stk, str, strlen (str));
       obstack_1grow (&report_stk, '\n');
     }
+  free (str);
 }
 
 void
 report_finish ()
 {
   obstack_1grow (&report_stk, 0);
   report_string = obstack_finish (&report_stk);
 }
diff --git a/src/timer.c b/src/timer.c
index 71f63f9..1634462 100644
--- a/src/timer.c
+++ b/src/timer.c
@@ -150,69 +150,77 @@ timer_get_user (wydawca_timer_t t)
 }
 
 double
 timer_get_system (wydawca_timer_t t)
 {
   return t->self_system + t->children_system;
 }
 
 char *
 timer_format_time (double t)
 {
   char *str = NULL;
+  size_t size = 0;
   if (t < 600)
-    asprintf (&str, "%0.3f", t);
+    grecs_asprintf (&str, &size, "%0.3f", t);
   else
     {
       long int s, m, h, d;
 
       s = (long int) t;
       d = s / (3600 * 24);
       s -= d * 3600 * 24;
       h = s / 3600;
       s -= h * 3600;
       m = s / 60;
       s -= m * 60;
 
       if (d)
-	asprintf (&str, "%ld+%02ld:%02ld:%02ld", d, h, m, s);
+	grecs_asprintf (&str, &size, "%ld+%02ld:%02ld:%02ld", d, h, m, s);
       else if (h)
-	asprintf (&str, "%02ld:%02ld:%02ld", h, m, s);
+	grecs_asprintf (&str, &size, "%02ld:%02ld:%02ld", h, m, s);
       else
-	asprintf (&str, "%02ld:%02ld", m, s);
+	grecs_asprintf (&str, &size, "%02ld:%02ld", m, s);
     }
+  if (!str)
+    xalloc_die ();
   return str;
 }
 
 size_t
 timer_get_count ()
 {
   return _timer_count;
 }
 
 struct timer_data
 {
   struct metadef *def;
   size_t num;
 };
 
 int
 _fill_meta (void *sym, void *data)
 {
   struct timer_slot *slot = sym;
   struct timer_data *tp = data;
 #define CREATE_DEF(arg)							      \
   if (tp->num)								      \
     {									      \
-      asprintf (&tp->def->kw, "timer:%s:%s", slot->name, #arg);		      \
+      char *buf = NULL;							      \
+      size_t size = 0;							      \
+      grecs_asprintf (&buf, &size, "timer:%s:%s", slot->name, #arg);	      \
+      if (!buf)								      \
+	xalloc_die ();						 	      \
+      tp->def->kw = buf;						      \
       tp->def->storage = timer_format_time (__cat2__(timer_get_,arg) (slot)); \
       tp->def->value = tp->def->storage;				      \
       tp->def->expand = NULL;						      \
       tp->def++;							      \
       tp->num--;							      \
     }
   
   CREATE_DEF(system);
   CREATE_DEF(real);
   CREATE_DEF(user);
 
   return tp->num <= 0;
diff --git a/src/triplet.c b/src/triplet.c
index 6bd9e6a..9f051db 100644
--- a/src/triplet.c
+++ b/src/triplet.c
@@ -341,25 +341,26 @@ format_file_data (struct file_triplet *trp, enum file_type type, char **pret)
   char modes[11];
   struct file_info *info = trp->file + type;
   char timebuf[sizeof "YYYY-MM-DD HH:MM:SS +0000"];
   struct passwd *pw;
   struct group *grp;
   char sbuf[INT_BUFSIZE_BOUND (uintmax_t)];
   char *sptr;
   size_t slen;
   int pad;
   char *user_name;
   char *group_name;
   struct tm *tm;
-  char *buf;
+  char *buf = NULL;
+  size_t size = 0;
   
   if (!info->name)
     return 1;
 
   /* MODE OWNER GROUP SIZE MTIME FILE_NAME MD5SUM? */
 
   modes[0] = '-'; /* Only regular files are allowed */
   decode_file_mode (info->sb.st_mode, modes + 1);
 
   /* File time */
   tm = localtime (&info->sb.st_mtime);
   strftime (timebuf, sizeof timebuf, "%Y-%m-%d %H:%M:%S %z", tm);
@@ -376,28 +377,30 @@ format_file_data (struct file_triplet *trp, enum file_type type, char **pret)
   else
     group_name = grp->gr_name;
 
   /* Size */
   sptr = umaxtostr (info->sb.st_size, sbuf);
 
   /* Figure out padding and format the buffer */
   slen = strlen (sptr);
   pad = strlen (user_name) + 1 + strlen (group_name) + 1 + slen;
   if (pad > ugswidth)
     ugswidth = pad;
 
-  asprintf (&buf,
+  if (grecs_asprintf (&buf, &size,
 		      "%s %s %s %*s %s %s",
-	    modes, user_name, group_name, ugswidth - pad + slen, sptr,
-	    timebuf, info->name);
+		      modes, user_name, group_name, ugswidth - pad + slen,
+		      sptr,
+		      timebuf, info->name))
+    xalloc_die ();
   *pret = buf;
   return 0;
 }
 
 static const char *
 expand_triplet_ls_full (struct metadef *def, void *data)
 {
   struct file_triplet *trp = data;
   char *buf[FILE_TYPE_COUNT] =  { NULL, NULL, NULL };
   size_t size = 0;
 
   if (format_file_data (trp, file_dist, &buf[file_dist]) == 0)
@@ -536,26 +539,28 @@ expand_user_email (struct metadef *def, void *data)
   if (trp->uploader)
     return trp->uploader->email;
   def->value = "UNKNOWN";
   return def->value;
 }
 
 static const char *
 expand_email_user (struct metadef *def, void *data)
 {
   struct file_triplet *trp = data;
   if (trp->uploader)
     {
-      asprintf (&def->storage, "\"%s\" <%s>",
-		trp->uploader->realname, trp->uploader->email);
+      size_t size = 0;
+      if (grecs_asprintf (&def->storage, &size, "\"%s\" <%s>",
+			  trp->uploader->realname, trp->uploader->email))
+	xalloc_die ();
       def->value = def->storage;
     }
   return def->value;
 }
 
 static const char *
 expand_report (struct metadef *def, void *data)
 {
   return report_string;
 }
 
 static const char *
@@ -582,25 +587,28 @@ expand_check_result (struct metadef *def, void *data)
   char sbuf[INT_BUFSIZE_BOUND (uintmax_t)];
 
   if (status == 0)
     return def->value = "0";
   else if (WIFEXITED (status))
     {
       char *p = umaxtostr (WEXITSTATUS (status), sbuf);
       def->storage = xstrdup (p);
     }
   else if (WIFSIGNALED (status))
     {
       char *p = umaxtostr (WTERMSIG (status), sbuf);
-      asprintf (&def->storage, "SIG+%s", p);
+      size_t size = 0;
+      def->storage = NULL;
+      if (grecs_asprintf (&def->storage, &size, "SIG+%s", p))
+	xalloc_die ();
     }
   else
     def->storage = "[unrecognized return code]";
   return def->value = def->storage;
 }
 
 #define DECL_EXPAND_TIMER(what)			                        \
 static const char *					                \
 __cat2__(expand_timer_,what) (struct metadef *def, void *data)          \
 {                                                                       \
   wydawca_timer_t t = timer_stop ((char*)def->data);	                \
   def->storage = timer_format_time (__cat2__(timer_get_,what) (t));	\