asprintf and snprintf support

kern/device.c

@@ -86,7 +86,7 @@ grub_device_iterate (int (*hook) (const char *name))
   struct part_ent
   {
     struct part_ent *next;
-    char name[0];
+    char *name;
   } *ents;
 
   int iterate_disk (const char *disk_name)
@@ -118,6 +118,7 @@ grub_device_iterate (int (*hook) (const char *name))
 
 	      if (!ret)
 		ret = hook (p->name);
+	      grub_free (p->name);
 	      grub_free (p);
 	      p = next;
 	    }
@@ -138,15 +139,20 @@ grub_device_iterate (int (*hook) (const char *name))
       if (! partition_name)
 	return 1;
 
-      p = grub_malloc (sizeof (p->next) + grub_strlen (disk->name) + 1 +
-		       grub_strlen (partition_name) + 1);
+      p = grub_malloc (sizeof (p->next));
       if (!p)
 	{
 	  grub_free (partition_name);
 	  return 1;
 	}
 
-      grub_sprintf (p->name, "%s,%s", disk->name, partition_name);
+      p->name = grub_asprintf ("%s,%s", disk->name, partition_name);
+      if (!p->name)
+	{
+	  grub_free (partition_name);
+	  grub_free (p);
+	  return 1;
+	}      
       grub_free (partition_name);
 
       p->next = ents;

kern/dl.c

@@ -628,12 +628,10 @@ grub_dl_load (const char *name)
     return 0;
   }
 
-  filename = (char *) grub_malloc (grub_strlen (grub_dl_dir) + 1
-				   + grub_strlen (name) + 4 + 1);
+  filename = grub_asprintf ("%s/%s.mod", grub_dl_dir, name);
   if (! filename)
     return 0;
 
-  grub_sprintf (filename, "%s/%s.mod", grub_dl_dir, name);
   mod = grub_dl_load_file (filename);
   grub_free (filename);
 

kern/efi/init.c

@@ -63,11 +63,10 @@ grub_efi_set_prefix (void)
 	  if (p)
 	    *p = '\0';
 
-	  prefix = grub_malloc (1 + grub_strlen (device) + 1
-				+ grub_strlen (file) + 1);
+	  prefix = grub_asprintf ("(%s)%s", device, file);
 	  if (prefix)
 	    {
-	      grub_sprintf (prefix, "(%s)%s", device, file);
+	      
 	      grub_env_set ("prefix", prefix);
 	      grub_free (prefix);
 	    }

kern/env.c

@@ -356,14 +356,7 @@ grub_register_variable_hook (const char *name,
 static char *
 mangle_data_slot_name (const char *name)
 {
-  char *mangled_name;
-
-  mangled_name = grub_malloc (grub_strlen (name) + 2);
-  if (! mangled_name)
-    return 0;
-
-  grub_sprintf (mangled_name, "\e%s", name);
-  return mangled_name;
+  return grub_asprintf ("\e%s", name);
 }
 
 grub_err_t

kern/err.c

@@ -44,7 +44,7 @@ grub_error (grub_err_t n, const char *fmt, ...)
   grub_errno = n;
 
   va_start (ap, fmt);
-  grub_vsprintf (grub_errmsg, fmt, ap);
+  grub_vsnprintf (grub_errmsg, sizeof (grub_errmsg), fmt, ap);
   va_end (ap);
 
   return n;

kern/i386/pc/init.c

@@ -56,22 +56,30 @@ static char *
 make_install_device (void)
 {
   /* XXX: This should be enough.  */
-  char dev[100];
+  char dev[100], *ptr = dev;
 
   if (grub_prefix[0] != '(')
     {
       /* No hardcoded root partition - make it from the boot drive and the
 	 partition number encoded at the install time.  */
-      grub_sprintf (dev, "(%cd%u", (grub_boot_drive & 0x80) ? 'h' : 'f',
+      grub_snprintf (dev, sizeof (dev),
+		    "(%cd%u", (grub_boot_drive & 0x80) ? 'h' : 'f',
 		    grub_boot_drive & 0x7f);
+      ptr += grub_strlen (ptr);
 
       if (grub_install_dos_part >= 0)
-	grub_sprintf (dev + grub_strlen (dev), ",%u", grub_install_dos_part + 1);
+	grub_snprintf (ptr, sizeof (dev) - (ptr - dev),
+		       ",%u", grub_install_dos_part + 1);
+
+      ptr += grub_strlen (ptr);
 
       if (grub_install_bsd_part >= 0)
-	grub_sprintf (dev + grub_strlen (dev), ",%c", grub_install_bsd_part + 'a');
+	grub_snprintf (ptr, sizeof (dev) - (ptr - dev), ",%c",
+		       grub_install_bsd_part + 'a');
 
-      grub_sprintf (dev + grub_strlen (dev), ")%s", grub_prefix);
+      ptr += grub_strlen (ptr);
+
+      grub_snprintf (ptr, sizeof (dev) - (ptr - dev), ")%s", grub_prefix);
       grub_strcpy (grub_prefix, dev);
     }
 

kern/ieee1275/init.c

@@ -111,11 +111,12 @@ grub_machine_set_prefix (void)
 	  *lastslash = '\0';
 	  grub_translate_ieee1275_path (filename);
 
-	  newprefix = grub_malloc (grub_strlen (prefix)
-				   + grub_strlen (filename));
-	  grub_sprintf (newprefix, "%s%s", prefix, filename);
-	  grub_free (prefix);
-	  prefix = newprefix;
+	  newprefix = grub_asprintf ("%s%s", prefix, filename);
+	  if (newprefix)
+	    {
+	      grub_free (prefix);
+	      prefix = newprefix;
+	    }
 	}
     }
 

kern/ieee1275/openfw.c

@@ -38,7 +38,7 @@ grub_children_iterate (char *devpath,
   grub_ieee1275_phandle_t dev;
   grub_ieee1275_phandle_t child;
   char *childtype, *childpath;
-  char *childname, *fullname;
+  char *childname;
   int ret = 0;
 
   if (grub_ieee1275_finddevice (devpath, &dev))
@@ -63,19 +63,12 @@ grub_children_iterate (char *devpath,
       grub_free (childtype);
       return 0;
     }
-  fullname = grub_malloc (IEEE1275_MAX_PATH_LEN);
-  if (!fullname)
-    {
-      grub_free (childname);
-      grub_free (childpath);
-      grub_free (childtype);
-      return 0;
-    }
 
   do
     {
       struct grub_ieee1275_devalias alias;
       grub_ssize_t actual;
+      char *fullname;
 
       if (grub_ieee1275_get_property (child, "device_type", childtype,
 				      IEEE1275_MAX_PROP_LEN, &actual))
@@ -89,18 +82,25 @@ grub_children_iterate (char *devpath,
 				      IEEE1275_MAX_PROP_LEN, &actual))
 	continue;
 
-      grub_sprintf (fullname, "%s/%s", devpath, childname);
+      fullname = grub_asprintf ("%s/%s", devpath, childname);
+      if (!fullname)
+	{
+	  grub_free (childname);
+	  grub_free (childpath);
+	  grub_free (childtype);
+	  return 0;
+	}
 
       alias.type = childtype;
       alias.path = childpath;
       alias.name = fullname;
       ret = hook (&alias);
+      grub_free (fullname);
       if (ret)
 	break;
     }
   while (grub_ieee1275_peer (child, &child));
 
-  grub_free (fullname);
   grub_free (childname);
   grub_free (childpath);
   grub_free (childtype);
@@ -330,12 +330,11 @@ grub_ieee1275_parse_args (const char *path, enum grub_ieee1275_parse_type ptype)
 	    {
 	      char *filepath = comma + 1;
 
-	      ret = grub_malloc (grub_strlen (filepath) + 1);
 	      /* Make sure filepath has leading backslash.  */
 	      if (filepath[0] != '\\')
-		grub_sprintf (ret, "\\%s", filepath);
+		ret = grub_asprintf ("\\%s", filepath);
 	      else
-		grub_strcpy (ret, filepath);
+		ret = grub_strdup (filepath);
 	    }
 	}
       else if (ptype == GRUB_PARSE_PARTITION)
@@ -383,15 +382,10 @@ grub_ieee1275_encode_devname (const char *path)
 	/* GRUB partition 1 is OF partition 0.  */
 	partno++;
 
-      /* Assume partno will require less than five bytes to encode.  */
-      encoding = grub_malloc (grub_strlen (device) + 3 + 5);
-      grub_sprintf (encoding, "(%s,%d)", device, partno);
+      encoding = grub_asprintf ("(%s,%d)", device, partno);
     }
   else
-    {
-      encoding = grub_malloc (grub_strlen (device) + 2);
-      grub_sprintf (encoding, "(%s)", device);
-    }
+    encoding = grub_asprintf ("(%s)", device);
 
   grub_free (partition);
   grub_free (device);

kern/misc.c

@@ -25,6 +25,9 @@
 #include <grub/env.h>
 #include <grub/i18n.h>
 
+static int
+grub_vsnprintf_real (char *str, grub_size_t n, const char *fmt, va_list args);
+
 static int
 grub_iswordseparator (int c)
 {
@@ -202,7 +205,7 @@ grub_vprintf (const char *fmt, va_list args)
 {
   int ret;
 
-  ret = grub_vsprintf (0, fmt, args);
+  ret = grub_vsnprintf_real (0, 0, fmt, args);
   grub_refresh ();
   return ret;
 }
@@ -626,11 +629,11 @@ grub_lltoa (char *str, int c, unsigned long long n)
   return p;
 }
 
-int
-grub_vsprintf (char *str, const char *fmt, va_list args)
+static int
+grub_vsnprintf_real (char *str, grub_size_t n, const char *fmt, va_list args)
 {
   char c;
-  int count = 0;
+  grub_size_t count = 0;
   auto void write_char (unsigned char ch);
   auto void write_str (const char *s);
   auto void write_fill (const char ch, int n);
@@ -638,7 +641,10 @@ grub_vsprintf (char *str, const char *fmt, va_list args)
   void write_char (unsigned char ch)
     {
       if (str)
-	*str++ = ch;
+	{
+	  if (count < n)
+	    *str++ = ch;
+	}
       else
 	grub_putchar (ch);
 
@@ -867,13 +873,64 @@ grub_vsprintf (char *str, const char *fmt, va_list args)
 }
 
 int
-grub_sprintf (char *str, const char *fmt, ...)
+grub_vsnprintf (char *str, grub_size_t n, const char *fmt, va_list ap)
+{
+  grub_size_t ret;
+
+  if (!n)
+    return 0;
+
+  n--;
+
+  ret = grub_vsnprintf_real (str, n, fmt, ap);
+
+  return ret < n ? ret : n;
+}
+
+int
+grub_snprintf (char *str, grub_size_t n, const char *fmt, ...)
 {
   va_list ap;
   int ret;
 
   va_start (ap, fmt);
-  ret = grub_vsprintf (str, fmt, ap);
+  ret = grub_vsnprintf (str, n, fmt, ap);
+  va_end (ap);
+
+  return ret;
+}
+
+#define PREALLOC_SIZE 255
+
+char *
+grub_avsprintf (const char *fmt, va_list ap)
+{
+  grub_size_t s, as = PREALLOC_SIZE;
+  char *ret;
+
+  while (1)
+    {
+      ret = grub_malloc (as + 1);
+      if (!ret)
+	return NULL;
+
+      s = grub_vsnprintf (ret, as, fmt, ap);
+      if (s <= as)
+	return ret;
+
+      grub_free (ret);
+      as = s;
+    }
+}
+
+char *
+grub_asprintf (const char *fmt, ...)
+{
+  va_list ap;
+  char *ret;
+
+  va_start (ap, fmt);
+  ret = grub_avsprintf (fmt, ap);
   va_end (ap);
 
   return ret;

kern/sparc64/ieee1275/init.c

@@ -90,10 +90,7 @@ grub_machine_set_prefix (void)
 	}
       prefix = grub_ieee1275_encode_devname (bootpath);
 
-      path = grub_malloc (grub_strlen (grub_prefix)
-			  + grub_strlen (prefix)
-			  + 2);
-      grub_sprintf(path, "%s%s", prefix, grub_prefix);
+      path = grub_asprintf("%s%s", prefix, grub_prefix);
 
       grub_strcpy (grub_prefix, path);