asprintf and snprintf support

diff --git a/commands/ls.c b/commands/ls.c
index 4b1500398761d40e3ee5a31339dfbeaff8593a20..3b5fe450da27a963553fd6b99c477cf13bb75f46 100644 (file)
--- a/commands/ls.c
+++ b/commands/ls.c
@@ -86,7 +86,7 @@ grub_ls_list_files (char *dirname, int longlist, int all, int human)
   int print_files_long (const char *filename,
                        const struct grub_dirhook_info *info)
     {
-      char pathname[grub_strlen (dirname) + grub_strlen (filename) + 1];
+      char *pathname;
 
       if ((! all) && (filename[0] == '.'))
        return 0;
@@ -96,9 +96,12 @@ grub_ls_list_files (char *dirname, int longlist, int all, int human)
          grub_file_t file;
 
          if (dirname[grub_strlen (dirname) - 1] == '/')
-           grub_sprintf (pathname, "%s%s", dirname, filename);
+           pathname = grub_asprintf ("%s%s", dirname, filename);
          else
-           grub_sprintf (pathname, "%s/%s", dirname, filename);
+           pathname = grub_asprintf ("%s/%s", dirname, filename);
+
+         if (!pathname)
+           return 1;
 
          /* XXX: For ext2fs symlinks are detected as files while they
             should be reported as directories.  */
@@ -130,8 +133,9 @@ grub_ls_list_files (char *dirname, int longlist, int all, int human)
                  grub_uint32_t whole, fraction;
 
                  whole = grub_divmod64 (fsize, 100, &fraction);
-                 grub_sprintf (buf, "%u.%02u%c", whole, fraction,
-                               grub_human_sizes[units]);
+                 grub_snprintf (buf, sizeof (buf),
+                                "%u.%02u%c", whole, fraction,
+                                grub_human_sizes[units]);
                  grub_printf ("%-12s", buf);
                }
              else

diff --git a/commands/memrw.c b/commands/memrw.c
index 8e9c3db1148ff9de0256c352033dc880d0175118..2a34ce8f6916e40f58e260cf7408f8ba52c6fa3a 100644 (file)
--- a/commands/memrw.c
+++ b/commands/memrw.c
@@ -61,7 +61,7 @@ grub_cmd_read (grub_extcmd_t cmd, int argc, char **argv)
 
   if (cmd->state[0].set)
     {
-      grub_sprintf (buf, "%x", value);
+      grub_snprintf (buf, sizeof (buf), "%x", value);
       grub_env_set (cmd->state[0].arg, buf);
     }
   else

diff --git a/commands/parttool.c b/commands/parttool.c
index 62fe5ad2bbb194c7d1fac9b60ef7da58056d37dd..f2eb58927a75274505b4e0423125801f24fe92d9 100644 (file)
--- a/commands/parttool.c
+++ b/commands/parttool.c
@@ -182,12 +182,11 @@ grub_cmd_parttool (grub_command_t cmd __attribute__ ((unused)),
       {
        char *filename;
 
-       filename = grub_malloc (grub_strlen (prefix) + sizeof ("/parttool.lst"));
+       filename = grub_asprintf ("%s/parttool.lst", prefix);
        if (filename)
          {
            grub_file_t file;
 
-           grub_sprintf (filename, "%s/parttool.lst", prefix);
            file = grub_file_open (filename);
            if (file)
              {

diff --git a/commands/search.c b/commands/search.c
index 01e83739bb50f3ecb7e8066c134b5403d7638a84..78d73ba6a2ad062eba6d7999ca999bf979794e72 100644 (file)
--- a/commands/search.c
+++ b/commands/search.c
@@ -33,7 +33,6 @@ void
 FUNC_NAME (const char *key, const char *var, int no_floppy)
 {
   int count = 0;
-  char *buf = NULL;
   grub_fs_autoload_hook_t saved_autoload;
 
   auto int iterate_device (const char *name);
@@ -48,24 +47,20 @@ FUNC_NAME (const char *key, const char *var, int no_floppy)
 
 #ifdef DO_SEARCH_FILE
       {
-       grub_size_t len;
-       char *p;
+       char *buf;
        grub_file_t file;
 
-       len = grub_strlen (name) + 2 + grub_strlen (key) + 1;
-       p = grub_realloc (buf, len);
-       if (! p)
+       buf = grub_asprintf ("(%s)%s", name, key);
+       if (! buf)
          return 1;
 
-       buf = p;
-       grub_sprintf (buf, "(%s)%s", name, key);
-
        file = grub_file_open (buf);
        if (file)
          {
            found = 1;
            grub_file_close (file);
          }
+       grub_free (buf);
       }
 #else
       {
@@ -135,8 +130,6 @@ FUNC_NAME (const char *key, const char *var, int no_floppy)
   else
     grub_device_iterate (iterate_device);
 
-  grub_free (buf);
-
   if (grub_errno == GRUB_ERR_NONE && count == 0)
     grub_error (GRUB_ERR_FILE_NOT_FOUND, "no such device: %s", key);
 }

diff --git a/commands/xnu_uuid.c b/commands/xnu_uuid.c
index 31e69ad13b1e98ecb5e6fe5ae82a457ca052f769..735d999a207af632d57cfc4f8957d4fe8d043c2b 100644 (file)
--- a/commands/xnu_uuid.c
+++ b/commands/xnu_uuid.c
@@ -349,18 +349,18 @@ grub_cmd_xnu_uuid (grub_command_t cmd __attribute__ ((unused)),
   grub_memcpy (hashme.prefix, hash_prefix, sizeof (hashme.prefix));
 
   md5 ((char *) &hashme, sizeof (hashme), (char *) xnu_uuid);
-  grub_sprintf (uuid_string,
-               "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
-               (unsigned int) xnu_uuid[0], (unsigned int) xnu_uuid[1],
-               (unsigned int) xnu_uuid[2], (unsigned int) xnu_uuid[3],
-               (unsigned int) xnu_uuid[4], (unsigned int) xnu_uuid[5],
-               (unsigned int) ((xnu_uuid[6] & 0xf) | 0x30),
-               (unsigned int) xnu_uuid[7],
-               (unsigned int) ((xnu_uuid[8] & 0x3f) | 0x80),
-               (unsigned int) xnu_uuid[9],
-               (unsigned int) xnu_uuid[10], (unsigned int) xnu_uuid[11],
-               (unsigned int) xnu_uuid[12], (unsigned int) xnu_uuid[13],
-               (unsigned int) xnu_uuid[14], (unsigned int) xnu_uuid[15]);
+  grub_snprintf (uuid_string, sizeof (uuid_string),
+                "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+                (unsigned int) xnu_uuid[0], (unsigned int) xnu_uuid[1],
+                (unsigned int) xnu_uuid[2], (unsigned int) xnu_uuid[3],
+                (unsigned int) xnu_uuid[4], (unsigned int) xnu_uuid[5],
+                (unsigned int) ((xnu_uuid[6] & 0xf) | 0x30),
+                (unsigned int) xnu_uuid[7],
+                (unsigned int) ((xnu_uuid[8] & 0x3f) | 0x80),
+                (unsigned int) xnu_uuid[9],
+                (unsigned int) xnu_uuid[10], (unsigned int) xnu_uuid[11],
+                (unsigned int) xnu_uuid[12], (unsigned int) xnu_uuid[13],
+                (unsigned int) xnu_uuid[14], (unsigned int) xnu_uuid[15]);
   for (ptr = uuid_string; *ptr; ptr++)
     *ptr = grub_toupper (*ptr);
   if (argc == 1)

diff --git a/disk/ata.c b/disk/ata.c
index 864ae94880ef8de0d9a89ae314bc59d784e1e4ac..79d436222a055293573384fc5f0d594a9a51e195 100644 (file)
--- a/disk/ata.c
+++ b/disk/ata.c
@@ -648,12 +648,14 @@ grub_ata_iterate (int (*hook) (const char *name))
 
   for (dev = grub_ata_devices; dev; dev = dev->next)
     {
-      char devname[5];
-      grub_sprintf (devname, "ata%d", dev->port * 2 + dev->device);
+      char devname[10];
 
       if (dev->atapi)
        continue;
 
+      grub_snprintf (devname, sizeof (devname), 
+                    "ata%d", dev->port * 2 + dev->device);
+
       if (hook (devname))
        return 1;
     }
@@ -668,8 +670,9 @@ grub_ata_open (const char *name, grub_disk_t disk)
 
   for (dev = grub_ata_devices; dev; dev = dev->next)
     {
-      char devname[5];
-      grub_sprintf (devname, "ata%d", dev->port * 2 + dev->device);
+      char devname[10];
+      grub_snprintf (devname, sizeof (devname),
+                    "ata%d", dev->port * 2 + dev->device);
       if (grub_strcmp (name, devname) == 0)
        break;
     }
@@ -735,8 +738,9 @@ grub_atapi_iterate (int (*hook) (const char *name, int luns))
 
   for (dev = grub_ata_devices; dev; dev = dev->next)
     {
-      char devname[7];
-      grub_sprintf (devname, "ata%d", dev->port * 2 + dev->device);
+      char devname[10];
+      grub_snprintf (devname, sizeof (devname),
+                    "ata%d", dev->port * 2 + dev->device);
 
       if (! dev->atapi)
        continue;
@@ -808,8 +812,9 @@ grub_atapi_open (const char *name, struct grub_scsi *scsi)
 
   for (dev = grub_ata_devices; dev; dev = dev->next)
     {
-      char devname[7];
-      grub_sprintf (devname, "ata%d", dev->port * 2 + dev->device);
+      char devname[10];
+      grub_snprintf (devname, sizeof (devname),
+                    "ata%d", dev->port * 2 + dev->device);
 
       if (!grub_strcmp (devname, name))
        {

diff --git a/disk/efi/efidisk.c b/disk/efi/efidisk.c
index de848594a1861f400c9a0609cbb63be378b3d20d..0b5731c0f8fed2555cad90452e2da4147a8ea5f7 100644 (file)
--- a/disk/efi/efidisk.c
+++ b/disk/efi/efidisk.c
@@ -440,7 +440,7 @@ grub_efidisk_iterate (int (*hook) (const char *name))
 
   for (d = fd_devices, count = 0; d; d = d->next, count++)
     {
-      grub_sprintf (buf, "fd%d", count);
+      grub_snprintf (buf, sizeof (buf), "fd%d", count);
       grub_dprintf ("efidisk", "iterating %s\n", buf);
       if (hook (buf))
        return 1;
@@ -448,7 +448,7 @@ grub_efidisk_iterate (int (*hook) (const char *name))
 
   for (d = hd_devices, count = 0; d; d = d->next, count++)
     {
-      grub_sprintf (buf, "hd%d", count);
+      grub_snprintf (buf, sizeof (buf), "hd%d", count);
       grub_dprintf ("efidisk", "iterating %s\n", buf);
       if (hook (buf))
        return 1;
@@ -456,7 +456,7 @@ grub_efidisk_iterate (int (*hook) (const char *name))
 
   for (d = cd_devices, count = 0; d; d = d->next, count++)
     {
-      grub_sprintf (buf, "cd%d", count);
+      grub_snprintf (buf, sizeof (buf), "cd%d", count);
       grub_dprintf ("efidisk", "iterating %s\n", buf);
       if (hook (buf))
        return 1;
@@ -805,18 +805,10 @@ grub_efidisk_get_device_name (grub_efi_handle_t *handle)
          return 0;
        }
 
-      device_name = grub_malloc (grub_strlen (parent->name) + 1
-                                + grub_strlen (partition_name) + 1);
-      if (! device_name)
-       {
-         grub_free (partition_name);
-         grub_disk_close (parent);
-         return 0;
-       }
-
-      grub_sprintf (device_name, "%s,%s", parent->name, partition_name);
+      device_name = grub_asprintf ("%s,%s", parent->name, partition_name);
       grub_free (partition_name);
       grub_disk_close (parent);
+
       return device_name;
     }
   else

diff --git a/disk/i386/pc/biosdisk.c b/disk/i386/pc/biosdisk.c
index af184b1ba97eb52c4b28b545c93439fa50b91cdb..cc3da48d028ce4cc271561a23b3e3dae0fb01497 100644 (file)
--- a/disk/i386/pc/biosdisk.c
+++ b/disk/i386/pc/biosdisk.c
@@ -56,7 +56,8 @@ grub_biosdisk_call_hook (int (*hook) (const char *name), int drive)
 {
   char name[10];
 
-    grub_sprintf (name, (drive & 0x80) ? "hd%d" : "fd%d", drive & (~0x80));
+  grub_snprintf (name, sizeof (name),
+                (drive & 0x80) ? "hd%d" : "fd%d", drive & (~0x80));
   return hook (name);
 }
 

diff --git a/disk/raid.c b/disk/raid.c
index c48a41d8ddbc3b3d96072bd877618350dc5c803e..5d4456e93122e8fef2543530e62edae1e6aaafd8 100644 (file)
--- a/disk/raid.c
+++ b/disk/raid.c
@@ -556,7 +556,7 @@ insert_array (grub_disk_t disk, struct grub_raid_array *new_array,
             }
         }
 
-      array->name = grub_malloc (13);
+      array->name = grub_asprintf ("md%d", array->number);
       if (! array->name)
         {
           grub_free (array->uuid);
@@ -565,8 +565,6 @@ insert_array (grub_disk_t disk, struct grub_raid_array *new_array,
           return grub_errno;
         }
 
-      grub_sprintf (array->name, "md%d", array->number);
-
       grub_dprintf ("raid", "Found array %s (%s)\n", array->name,
                     scanner_name);
 

diff --git a/disk/scsi.c b/disk/scsi.c
index 21b888559e65d8d7db8ded82feae880cc2077665..6717bc351294e9548cfc046bc483ac8357cd5054 100644 (file)
--- a/disk/scsi.c
+++ b/disk/scsi.c
@@ -197,7 +197,6 @@ grub_scsi_iterate (int (*hook) (const char *name))
 
   int scsi_iterate (const char *name, int luns)
     {
-      char sname[40];
       int i;
 
       /* In case of a single LUN, just return `usbX'.  */
@@ -208,9 +207,13 @@ grub_scsi_iterate (int (*hook) (const char *name))
         distinguish it.  */
       for (i = 0; i < luns; i++)
        {
-         grub_sprintf (sname, "%s%c", name, 'a' + i);
+         char *sname;
+         sname = grub_asprintf ("%s%c", name, 'a' + i);
+         if (!sname)
+           return 1;
          if (hook (sname))
            return 1;
+         grub_free (sname);
        }
       return 0;
     }

diff --git a/disk/usbms.c b/disk/usbms.c
index 51e886520f726ab539f198cc3c8d64842b84b5ec..708168e8168fb1dcc387c85dd6274db8d70fc693 100644 (file)
--- a/disk/usbms.c
+++ b/disk/usbms.c
@@ -200,11 +200,15 @@ grub_usbms_iterate (int (*hook) (const char *name, int luns))
 
   for (p = grub_usbms_dev_list; p; p = p->next)
     {
-      char devname[20];
-      grub_sprintf (devname, "usb%d", cnt);
+      char *devname;
+      devname = grub_asprintf ("usb%d", cnt);
 
       if (hook (devname, p->luns))
-       return 1;
+       {
+         grub_free (devname);
+         return 1;
+       }
+      grub_free (devname);
       cnt++;
     }
 

diff --git a/efiemu/main.c b/efiemu/main.c
index a3cfdb5b50926f8c4490871597a287e06519ba6d..70a12080f97934ccf40cd3ae44897d6022a9dde0 100644 (file)
--- a/efiemu/main.c
+++ b/efiemu/main.c
@@ -255,12 +255,11 @@ grub_efiemu_autocore (void)
 
   suffix = grub_efiemu_get_default_core_name ();
 
-  filename = grub_malloc (grub_strlen (prefix) + grub_strlen (suffix) + 2);
+  filename = grub_asprintf ("%s/%s", prefix, suffix);
   if (! filename)
     return grub_error (GRUB_ERR_OUT_OF_MEMORY,
                       "couldn't allocate temporary space");
 
-  grub_sprintf (filename, "%s/%s", prefix, suffix);
 
   err = grub_efiemu_load_file (filename);
   grub_free (filename);

diff --git a/fs/ext2.c b/fs/ext2.c
index e7a20a43ba6d49e30c86b95a90918f9d616a5c70..d00b79b226898608d5904d75ea79c6e9451f17d7 100644 (file)
--- a/fs/ext2.c
+++ b/fs/ext2.c
@@ -875,12 +875,15 @@ grub_ext2_uuid (grub_device_t device, char **uuid)
   data = grub_ext2_mount (disk);
   if (data)
     {
-      *uuid = grub_malloc (40 + sizeof ('\0'));
-      grub_sprintf (*uuid, "%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
-                   grub_be_to_cpu16 (data->sblock.uuid[0]), grub_be_to_cpu16 (data->sblock.uuid[1]),
-                   grub_be_to_cpu16 (data->sblock.uuid[2]), grub_be_to_cpu16 (data->sblock.uuid[3]),
-                   grub_be_to_cpu16 (data->sblock.uuid[4]), grub_be_to_cpu16 (data->sblock.uuid[5]),
-                   grub_be_to_cpu16 (data->sblock.uuid[6]), grub_be_to_cpu16 (data->sblock.uuid[7]));
+      *uuid = grub_asprintf ("%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
+                            grub_be_to_cpu16 (data->sblock.uuid[0]),
+                            grub_be_to_cpu16 (data->sblock.uuid[1]),
+                            grub_be_to_cpu16 (data->sblock.uuid[2]),
+                            grub_be_to_cpu16 (data->sblock.uuid[3]),
+                            grub_be_to_cpu16 (data->sblock.uuid[4]),
+                            grub_be_to_cpu16 (data->sblock.uuid[5]),
+                            grub_be_to_cpu16 (data->sblock.uuid[6]),
+                            grub_be_to_cpu16 (data->sblock.uuid[7]));
     }
   else
     *uuid = NULL;

diff --git a/fs/fat.c b/fs/fat.c
index 8a0fc029248c14f3d74b7f14a944aa0c09ab6144..a0a40cfab49bb4db64195baf60709ef41c073a3f 100644 (file)
--- a/fs/fat.c
+++ b/fs/fat.c
@@ -833,9 +833,9 @@ grub_fat_uuid (grub_device_t device, char **uuid)
   data = grub_fat_mount (disk);
   if (data)
     {
-      *uuid = grub_malloc (sizeof ("xxxx-xxxx"));
-      grub_sprintf (*uuid, "%04x-%04x", (grub_uint16_t) (data->uuid >> 16),
-                   (grub_uint16_t) data->uuid);
+      *uuid = grub_asprintf ("%04x-%04x",
+                            (grub_uint16_t) (data->uuid >> 16),
+                            (grub_uint16_t) data->uuid);
     }
   else
     *uuid = NULL;

diff --git a/fs/hfs.c b/fs/hfs.c
index 4dd1e31316032764aca12be5b0780e2c6c3721ab..676d7a68066463f7eb6d6abdc3a93acffe6280b0 100644 (file)
--- a/fs/hfs.c
+++ b/fs/hfs.c
@@ -1082,10 +1082,9 @@ grub_hfs_uuid (grub_device_t device, char **uuid)
   data = grub_hfs_mount (device->disk);
   if (data && data->sblock.num_serial != 0)
     {
-      *uuid = grub_malloc (16 + sizeof ('\0'));
-      grub_sprintf (*uuid, "%016llx",
-                   (unsigned long long)
-                   grub_be_to_cpu64 (data->sblock.num_serial));
+      *uuid = grub_asprintf ("%016llx",
+                            (unsigned long long)
+                            grub_be_to_cpu64 (data->sblock.num_serial));
     }
   else
     *uuid = NULL;

diff --git a/fs/hfsplus.c b/fs/hfsplus.c
index 9310b65023d17798829519f73ecea8e3ce6b3558..6556bedaa8d212176c8a58546dffb72d5c9b3149 100644 (file)
--- a/fs/hfsplus.c
+++ b/fs/hfsplus.c
@@ -995,10 +995,9 @@ grub_hfsplus_uuid (grub_device_t device, char **uuid)
   data = grub_hfsplus_mount (disk);
   if (data)
     {
-      *uuid = grub_malloc (16 + sizeof ('\0'));
-      grub_sprintf (*uuid, "%016llx",
-                   (unsigned long long)
-                   grub_be_to_cpu64 (data->volheader.num_serial));
+      *uuid = grub_asprintf ("%016llx",
+                            (unsigned long long)
+                            grub_be_to_cpu64 (data->volheader.num_serial));
     }
   else
     *uuid = NULL;

diff --git a/fs/i386/pc/pxe.c b/fs/i386/pc/pxe.c
index 03385b3e3a94197d04cea49bdb8e9240af14bb4f..60a49fc53deea1a4c1bb52d2f487abfc1dd482fa 100644 (file)
--- a/fs/i386/pc/pxe.c
+++ b/fs/i386/pc/pxe.c
@@ -356,7 +356,8 @@ set_mac_env (grub_uint8_t *mac_addr, grub_size_t mac_len)
 
   for (i = 0; i < mac_len; i++)
     {
-      grub_sprintf (ptr, "%02x:", mac_addr[i] & 0xff);
+      grub_snprintf (ptr, sizeof (buf) - (ptr - buf),
+                    "%02x:", mac_addr[i] & 0xff);
       ptr += (sizeof ("XX:") - 1);
     }
   if (mac_len)
@@ -483,8 +484,8 @@ set_ip_env (char *varname, grub_uint32_t ip)
 {
   char buf[sizeof ("XXX.XXX.XXX.XXX")];
 
-  grub_sprintf (buf, "%d.%d.%d.%d", (ip & 0xff),
-               (ip >> 8) & 0xff, (ip >> 16) & 0xff, (ip >> 24) & 0xff);
+  grub_snprintf (buf, sizeof (buf), "%d.%d.%d.%d", (ip & 0xff),
+                (ip >> 8) & 0xff, (ip >> 16) & 0xff, (ip >> 24) & 0xff);
   grub_env_set (varname, buf);
 }
 
@@ -500,15 +501,13 @@ write_ip_env (grub_uint32_t *ip, const char *val)
     return 0;
 
   /* Normalize the IP.  */
-  buf = grub_malloc (sizeof ("XXX.XXX.XXX.XXX"));
+  buf = grub_asprintf ("%d.%d.%d.%d", (newip & 0xff), (newip >> 8) & 0xff,
+                      (newip >> 16) & 0xff, (newip >> 24) & 0xff);
   if (!buf)
     return 0;
 
   *ip = newip;
 
-  grub_sprintf (buf, "%d.%d.%d.%d", (newip & 0xff), (newip >> 8) & 0xff,
-               (newip >> 16) & 0xff, (newip >> 24) & 0xff);
-
   return buf; 
 }
 
@@ -544,11 +543,10 @@ grub_env_write_pxe_blocksize (struct grub_env_var *var __attribute__ ((unused)),
   else if (size > GRUB_PXE_MAX_BLKSIZE)
     size = GRUB_PXE_MAX_BLKSIZE;
   
-  buf = grub_malloc (sizeof ("XXXXXX XXXXXX"));
+  buf = grub_asprintf ("%d", size);
   if (!buf)
     return 0;
 
-  grub_sprintf (buf, "%d", size);
   grub_pxe_blksize = size;
   
   return buf;
@@ -562,12 +560,10 @@ GRUB_MOD_INIT(pxe)
     {
       char *buf;
 
-      buf = grub_malloc (sizeof ("XXXXXX XXXXXX"));
+      buf = grub_asprintf ("%d", grub_pxe_blksize);
       if (buf)
-       {
-         grub_sprintf (buf, "%d", grub_pxe_blksize);
-         grub_env_set ("net_pxe_blksize", buf);
-       }
+       grub_env_set ("net_pxe_blksize", buf);
+      grub_free (buf);
 
       set_ip_env ("pxe_default_server", grub_pxe_default_server_ip);
       set_ip_env ("pxe_default_gateway", grub_pxe_default_gateway_ip);

diff --git a/fs/iso9660.c b/fs/iso9660.c
index 2fb0ffb6308bfb7b43b86b3e6ec3c1d99b44f2a9..576badf639b33d1dd9df0463c9a8394e6e9ea992 100644 (file)
--- a/fs/iso9660.c
+++ b/fs/iso9660.c
@@ -837,16 +837,23 @@ grub_iso9660_uuid (grub_device_t device, char **uuid)
        }
       else
        {
-         *uuid = grub_malloc (sizeof ("YYYY-MM-DD-HH-mm-ss-hh"));
-         grub_sprintf (*uuid, "%c%c%c%c-%c%c-%c%c-%c%c-%c%c-%c%c-%c%c",
-                       data->voldesc.modified.year[0], data->voldesc.modified.year[1],
-                       data->voldesc.modified.year[2], data->voldesc.modified.year[3],
-                       data->voldesc.modified.month[0], data->voldesc.modified.month[1],
-                       data->voldesc.modified.day[0], data->voldesc.modified.day[1],
-                       data->voldesc.modified.hour[0], data->voldesc.modified.hour[1],
-                       data->voldesc.modified.minute[0], data->voldesc.modified.minute[1],
-                       data->voldesc.modified.second[0], data->voldesc.modified.second[1],
-                       data->voldesc.modified.hundredth[0], data->voldesc.modified.hundredth[1]);
+         *uuid = grub_asprintf ("%c%c%c%c-%c%c-%c%c-%c%c-%c%c-%c%c-%c%c",
+                                data->voldesc.modified.year[0],
+                                data->voldesc.modified.year[1],
+                                data->voldesc.modified.year[2],
+                                data->voldesc.modified.year[3],
+                                data->voldesc.modified.month[0],
+                                data->voldesc.modified.month[1],
+                                data->voldesc.modified.day[0],
+                                data->voldesc.modified.day[1],
+                                data->voldesc.modified.hour[0],
+                                data->voldesc.modified.hour[1],
+                                data->voldesc.modified.minute[0],
+                                data->voldesc.modified.minute[1],
+                                data->voldesc.modified.second[0],
+                                data->voldesc.modified.second[1],
+                                data->voldesc.modified.hundredth[0],
+                                data->voldesc.modified.hundredth[1]);
        }
     }
   else

diff --git a/fs/jfs.c b/fs/jfs.c
index dc5eaed67a993a99a948bf669d416ac3288b2a45..1bc3c7758e2cbb749ea5e6071c9d79757b6b418f 100644 (file)
--- a/fs/jfs.c
+++ b/fs/jfs.c
@@ -842,17 +842,16 @@ grub_jfs_uuid (grub_device_t device, char **uuid)
   data = grub_jfs_mount (disk);
   if (data)
     {
-      *uuid = grub_malloc (40 + sizeof ('\0'));
-
-      grub_sprintf (*uuid, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
-                   data->sblock.uuid[0], data->sblock.uuid[1],
-                   data->sblock.uuid[2], data->sblock.uuid[3],
-                   data->sblock.uuid[4], data->sblock.uuid[5],
-                   data->sblock.uuid[6], data->sblock.uuid[7],
-                   data->sblock.uuid[8], data->sblock.uuid[9],
-                   data->sblock.uuid[10], data->sblock.uuid[11],
-                   data->sblock.uuid[12], data->sblock.uuid[13],
-                   data->sblock.uuid[14], data->sblock.uuid[15]);
+      *uuid = grub_asprintf ("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-"
+                            "%02x%02x%02x%02x%02x%02x",
+                            data->sblock.uuid[0], data->sblock.uuid[1],
+                            data->sblock.uuid[2], data->sblock.uuid[3],
+                            data->sblock.uuid[4], data->sblock.uuid[5],
+                            data->sblock.uuid[6], data->sblock.uuid[7],
+                            data->sblock.uuid[8], data->sblock.uuid[9],
+                            data->sblock.uuid[10], data->sblock.uuid[11],
+                            data->sblock.uuid[12], data->sblock.uuid[13],
+                            data->sblock.uuid[14], data->sblock.uuid[15]);
     }
   else
     *uuid = NULL;

diff --git a/fs/ntfs.c b/fs/ntfs.c
index 87db1a5610c085e1903116d55c22da616de4d431..eadf9d6a26f5daca31bb6e4ef62eefdc820e12ea 100644 (file)
--- a/fs/ntfs.c
+++ b/fs/ntfs.c
@@ -1072,8 +1072,7 @@ grub_ntfs_uuid (grub_device_t device, char **uuid)
   data = grub_ntfs_mount (disk);
   if (data)
     {
-      *uuid = grub_malloc (16 + sizeof ('\0'));
-      grub_sprintf (*uuid, "%016llx", (unsigned long long) data->uuid);
+      *uuid = grub_asprintf ("%016llx", (unsigned long long) data->uuid);
     }
   else
     *uuid = NULL;

diff --git a/fs/reiserfs.c b/fs/reiserfs.c
index a8ba75910ad47dfe33bd7ccd725201972e555779..d5a20ee6cb71956de13f9e578e31d4f2b1dcffc6 100644 (file)
--- a/fs/reiserfs.c
+++ b/fs/reiserfs.c
@@ -1335,12 +1335,15 @@ grub_reiserfs_uuid (grub_device_t device, char **uuid)
   data = grub_reiserfs_mount (disk);
   if (data)
     {
-      *uuid = grub_malloc (sizeof ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"));
-      grub_sprintf (*uuid, "%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
-                   grub_be_to_cpu16 (data->superblock.uuid[0]), grub_be_to_cpu16 (data->superblock.uuid[1]),
-                   grub_be_to_cpu16 (data->superblock.uuid[2]), grub_be_to_cpu16 (data->superblock.uuid[3]),
-                   grub_be_to_cpu16 (data->superblock.uuid[4]), grub_be_to_cpu16 (data->superblock.uuid[5]),
-                   grub_be_to_cpu16 (data->superblock.uuid[6]), grub_be_to_cpu16 (data->superblock.uuid[7]));
+      *uuid = grub_asprintf ("%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
+                            grub_be_to_cpu16 (data->superblock.uuid[0]),
+                            grub_be_to_cpu16 (data->superblock.uuid[1]),
+                            grub_be_to_cpu16 (data->superblock.uuid[2]),
+                            grub_be_to_cpu16 (data->superblock.uuid[3]),
+                            grub_be_to_cpu16 (data->superblock.uuid[4]),
+                            grub_be_to_cpu16 (data->superblock.uuid[5]),
+                            grub_be_to_cpu16 (data->superblock.uuid[6]),
+                            grub_be_to_cpu16 (data->superblock.uuid[7]));
     }
   else
     *uuid = NULL;

diff --git a/fs/ufs.c b/fs/ufs.c
index f95a6e12e55db1878479fc0cd71626f706169ecf..575c9f449fbf413b53dc90b127ebf1639936f4af 100644 (file)
--- a/fs/ufs.c
+++ b/fs/ufs.c
@@ -732,12 +732,9 @@ grub_ufs_uuid (grub_device_t device, char **uuid)
 
   data = grub_ufs_mount (disk);
   if (data && (data->sblock.uuidhi != 0 || data->sblock.uuidlow != 0))
-    {
-      *uuid = grub_malloc (16 + sizeof ('\0'));
-      grub_sprintf (*uuid, "%08x%08x",
-                   (unsigned) grub_le_to_cpu32 (data->sblock.uuidhi),
-                   (unsigned) grub_le_to_cpu32 (data->sblock.uuidlow));
-    }
+    *uuid = grub_asprintf ("%08x%08x",
+                          (unsigned) grub_le_to_cpu32 (data->sblock.uuidhi),
+                          (unsigned) grub_le_to_cpu32 (data->sblock.uuidlow));
   else
     *uuid = NULL;
 

diff --git a/fs/xfs.c b/fs/xfs.c
index c15ec7341d94c50a2fa7503a67c0567fc2e45816..e3f58c9dee5796d414a826d66ceeada575ef4a02 100644 (file)
--- a/fs/xfs.c
+++ b/fs/xfs.c
@@ -777,12 +777,15 @@ grub_xfs_uuid (grub_device_t device, char **uuid)
   data = grub_xfs_mount (disk);
   if (data)
     {
-      *uuid = grub_malloc (sizeof ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"));
-      grub_sprintf (*uuid, "%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
-                   grub_be_to_cpu16 (data->sblock.uuid[0]), grub_be_to_cpu16 (data->sblock.uuid[1]),
-                   grub_be_to_cpu16 (data->sblock.uuid[2]), grub_be_to_cpu16 (data->sblock.uuid[3]),
-                   grub_be_to_cpu16 (data->sblock.uuid[4]), grub_be_to_cpu16 (data->sblock.uuid[5]),
-                   grub_be_to_cpu16 (data->sblock.uuid[6]), grub_be_to_cpu16 (data->sblock.uuid[7]));
+      *uuid = grub_asprintf ("%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
+                            grub_be_to_cpu16 (data->sblock.uuid[0]),
+                            grub_be_to_cpu16 (data->sblock.uuid[1]),
+                            grub_be_to_cpu16 (data->sblock.uuid[2]),
+                            grub_be_to_cpu16 (data->sblock.uuid[3]),
+                            grub_be_to_cpu16 (data->sblock.uuid[4]),
+                            grub_be_to_cpu16 (data->sblock.uuid[5]),
+                            grub_be_to_cpu16 (data->sblock.uuid[6]),
+                            grub_be_to_cpu16 (data->sblock.uuid[7]));
     }
   else
     *uuid = NULL;

diff --git a/gettext/gettext.c b/gettext/gettext.c
index 3472b2fb8073115e883a58605dec163b1307006f..f271f24ab1de646404e01ddb205075a499b402ff 100644 (file)
--- a/gettext/gettext.c
+++ b/gettext/gettext.c
@@ -275,14 +275,19 @@ grub_gettext_init_ext (const char *lang)
   /* Warning: if changing some paths in the below line, change the grub_malloc
      contents below.  */
 
-  grub_sprintf (mo_file, "%s/%s.mo", locale_dir, lang);
+  mo_file = grub_asprintf ("%s/%s.mo", locale_dir, lang);
+  if (!mo_file)
+    return;
 
   fd_mo = grub_mofile_open (mo_file);
 
   /* Will try adding .gz as well.  */
   if (fd_mo == NULL)
     {
-      grub_sprintf (mo_file, "%s.gz", mo_file);
+      grub_free (mo_file);
+      mo_file = grub_asprintf ("%s.gz", mo_file);
+      if (!mo_file)
+       return;
       fd_mo = grub_mofile_open (mo_file);
     }
 

diff --git a/hook/datehook.c b/hook/datehook.c
index b7663cc21be709e5988fa194fe61c149ff067515..4876e1198025c29912e316a6340d87aa5da02ee9 100644 (file)
--- a/hook/datehook.c
+++ b/hook/datehook.c
@@ -76,7 +76,7 @@ grub_read_hook_datetime (struct grub_env_var *var,
                 return grub_get_weekday_name (&datetime);
               }
 
-            grub_sprintf (buf, "%d", n);
+            grub_snprintf (buf, sizeof (buf), "%d", n);
             break;
           }
     }

diff --git a/include/grub/misc.h b/include/grub/misc.h
index 92fb460cfada50d30971e19f60b23d49ccba3056..f4d722081166019a91ac67258c39a1b1d1dbc2d8 100644 (file)
--- a/include/grub/misc.h
+++ b/include/grub/misc.h
@@ -179,8 +179,13 @@ void EXPORT_FUNC(grub_real_dprintf) (const char *file,
                                      const char *condition,
                                      const char *fmt, ...) __attribute__ ((format (printf, 4, 5)));
 int EXPORT_FUNC(grub_vprintf) (const char *fmt, va_list args);
-int EXPORT_FUNC(grub_sprintf) (char *str, const char *fmt, ...) __attribute__ ((format (printf, 2, 3)));
-int EXPORT_FUNC(grub_vsprintf) (char *str, const char *fmt, va_list args);
+int EXPORT_FUNC(grub_snprintf) (char *str, grub_size_t n, const char *fmt, ...)
+     __attribute__ ((format (printf, 3, 4)));
+int EXPORT_FUNC(grub_vsnprintf) (char *str, grub_size_t n, const char *fmt,
+                                va_list args);
+char *EXPORT_FUNC(grub_asprintf) (const char *fmt, ...)
+     __attribute__ ((format (printf, 1, 2)));
+char *EXPORT_FUNC(grub_avsprintf) (const char *fmt, va_list args);
 void EXPORT_FUNC(grub_exit) (void) __attribute__ ((noreturn));
 void EXPORT_FUNC(grub_abort) (void) __attribute__ ((noreturn));
 grub_ssize_t EXPORT_FUNC(grub_utf8_to_ucs4) (grub_uint32_t *dest,

diff --git a/kern/device.c b/kern/device.c
index 9f219949b26e2710b7722fbb571bfdb570d70bc2..d1692baa0971e25e9456ae9cf6587ba1efb02641 100644 (file)
--- a/kern/device.c
+++ b/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;

diff --git a/kern/dl.c b/kern/dl.c
index 20ab1c5c244aeb769635e6dfe3a95eadf5924c5a..36bbd882c6b163b7ac8c5dea9460b1b55ffd1800 100644 (file)
--- a/kern/dl.c
+++ b/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);
 

diff --git a/kern/efi/init.c b/kern/efi/init.c
index f9ba03852f6cc419f30ddf2d95fc30c125a47e2a..4436840003f976550cb3920fc80ccfa136442e17 100644 (file)
--- a/kern/efi/init.c
+++ b/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);
            }

diff --git a/kern/env.c b/kern/env.c
index 969227decfa9115c9cb325be8d1dc79a2556269d..dd167a709e5fd4b8ffc94e2e85d9648425963937 100644 (file)
--- a/kern/env.c
+++ b/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

diff --git a/kern/err.c b/kern/err.c
index 311130154a896cfaf4f88bca2ee26e01345fc099..5a63b41876ae012b1e0b50b853e8126c48865a50 100644 (file)
--- a/kern/err.c
+++ b/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;

diff --git a/kern/i386/pc/init.c b/kern/i386/pc/init.c
index ebe4bb6ea5157fece4bcca8c89dae06f82471617..029ec4c6bf963ece5826a9a2e872a9984b395e3b 100644 (file)
--- a/kern/i386/pc/init.c
+++ b/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');
+
+      ptr += grub_strlen (ptr);
 
-      grub_sprintf (dev + grub_strlen (dev), ")%s", grub_prefix);
+      grub_snprintf (ptr, sizeof (dev) - (ptr - dev), ")%s", grub_prefix);
       grub_strcpy (grub_prefix, dev);
     }
 

diff --git a/kern/ieee1275/init.c b/kern/ieee1275/init.c
index f3305d71ccb36794c8cb1e103a08121264f94217..7ef6283977701b8ab5ff91f0d62f734b28e02303 100644 (file)
--- a/kern/ieee1275/init.c
+++ b/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;
+           }
        }
     }
 

diff --git a/kern/ieee1275/openfw.c b/kern/ieee1275/openfw.c
index c38eb450f8013d920323ea6ec6de41d853490be7..50bd9557a0342c00145cbeb7b563cb8292761a2f 100644 (file)
--- a/kern/ieee1275/openfw.c
+++ b/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);

diff --git a/kern/misc.c b/kern/misc.c
index f6d189e948c139678f4c8bda6d60b3736f0378f6..087bef7fe52aaf46112a6927b9d8e1026c3b692d 100644 (file)
--- a/kern/misc.c
+++ b/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;

diff --git a/kern/sparc64/ieee1275/init.c b/kern/sparc64/ieee1275/init.c
index 699f9631b7884503e21c8be28b371dc6211b82ec..339d836a3ef0e1d4864dfc5635dae99a895cad24 100644 (file)
--- a/kern/sparc64/ieee1275/init.c
+++ b/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);
 

diff --git a/lib/hexdump.c b/lib/hexdump.c
index c69cb093b7da66829d85a5d5f02cd5052c818ae1..db16f6926f267785bcefbba7bc03d06380099c1f 100644 (file)
--- a/lib/hexdump.c
+++ b/lib/hexdump.c
@@ -31,21 +31,22 @@ hexdump (unsigned long bse, char *buf, int len)
     {
       int cnt, i;
 
-      pos = grub_sprintf (line, "%08lx  ", bse);
+      pos = grub_snprintf (line, sizeof (line), "%08lx  ", bse);
       cnt = 16;
       if (cnt > len)
        cnt = len;
 
       for (i = 0; i < cnt; i++)
        {
-         pos += grub_sprintf (&line[pos], "%02x ", (unsigned char) buf[i]);
+         pos += grub_snprintf (&line[pos], sizeof (line) - pos,
+                               "%02x ", (unsigned char) buf[i]);
          if ((i & 7) == 7)
            line[pos++] = ' ';
        }
 
       for (; i < 16; i++)
        {
-         pos += grub_sprintf (&line[pos], "   ");
+         pos += grub_snprintf (&line[pos], sizeof (line) - pos, "   ");
          if ((i & 7) == 7)
            line[pos++] = ' ';
        }

diff --git a/loader/i386/bsd.c b/loader/i386/bsd.c
index ca60b0be91a496e0eb04043fdccdccdf88028fb8..06eb5bfd9e9128a1b019c41d960e275bd4484fd6 100644 (file)
--- a/loader/i386/bsd.c
+++ b/loader/i386/bsd.c
@@ -1138,14 +1138,20 @@ grub_cmd_freebsd_loadenv (grub_command_t cmd __attribute__ ((unused)),
 
       if (*curr)
        {
-         char name[grub_strlen (curr) + sizeof("kFreeBSD.")];
+         char *name;
 
          if (*p == '"')
            p++;
 
-         grub_sprintf (name, "kFreeBSD.%s", curr);
-         if (grub_env_set (name, p))
+         name = grub_asprintf ("kFreeBSD.%s", curr);
+         if (!name)
            goto fail;
+         if (grub_env_set (name, p))
+           {
+             grub_free (name);
+             goto fail;
+           }
+         grub_free (name);
        }
     }
 

diff --git a/loader/i386/linux.c b/loader/i386/linux.c
index 8992167834ba1cd662b016db299c01372b11164d..93f3da058dbcdd4ccf424d63a1d475d6b7c0fbbc 100644 (file)
--- a/loader/i386/linux.c
+++ b/loader/i386/linux.c
@@ -517,11 +517,9 @@ grub_linux_boot (void)
      May change in future if we have modes without framebuffer.  */
   if (modevar && *modevar != 0)
     {
-      tmp = grub_malloc (grub_strlen (modevar)
-                        + sizeof (";text"));
+      tmp = grub_asprintf ("%s;text", modevar);
       if (! tmp)
        return grub_errno;
-      grub_sprintf (tmp, "%s;text", modevar);
       err = grub_video_set_mode (tmp, 0);
       grub_free (tmp);
     }
@@ -779,19 +777,18 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
                break;
              }
 
-           buf = grub_malloc (sizeof ("WWWWxHHHHxDD;WWWWxHHHH"));
-           if (! buf)
-             goto fail;
-
            linux_mode
              = &linux_vesafb_modes[vid_mode - GRUB_LINUX_VID_MODE_VESA_START];
 
-           grub_sprintf (buf, "%ux%ux%u,%ux%u",
-                         linux_vesafb_res[linux_mode->res_index].width,
-                         linux_vesafb_res[linux_mode->res_index].height,
-                         linux_mode->depth,
-                         linux_vesafb_res[linux_mode->res_index].width,
-                         linux_vesafb_res[linux_mode->res_index].height);
+           buf = grub_asprintf ("%ux%ux%u,%ux%u",
+                                linux_vesafb_res[linux_mode->res_index].width,
+                                linux_vesafb_res[linux_mode->res_index].height,
+                                linux_mode->depth,
+                                linux_vesafb_res[linux_mode->res_index].width,
+                                linux_vesafb_res[linux_mode->res_index].height);
+           if (! buf)
+             goto fail;
+
            grub_printf ("%s is deprecated. "
                         "Use set gfxpayload=%s before "
                         "linux command instead.\n",

diff --git a/loader/i386/pc/xnu.c b/loader/i386/pc/xnu.c
index ebb176bb41951ecbe20d465493903ef9bb5e00c9..07c1ee37e44704da270f4167f115bb9265b44582 100644 (file)
--- a/loader/i386/pc/xnu.c
+++ b/loader/i386/pc/xnu.c
@@ -52,12 +52,10 @@ grub_xnu_set_video (struct grub_xnu_boot_params *params)
     err = grub_video_set_mode (DEFAULT_VIDEO_MODE, video_hook);
   else
     {
-      tmp = grub_malloc (grub_strlen (modevar)
-                        + sizeof (DEFAULT_VIDEO_MODE) + 1);
+      tmp = grub_asprintf ("%s;" DEFAULT_VIDEO_MODE, modevar);
       if (! tmp)
        return grub_error (GRUB_ERR_OUT_OF_MEMORY,
                           "couldn't allocate temporary storag");
-      grub_sprintf (tmp, "%s;" DEFAULT_VIDEO_MODE, modevar);
       err = grub_video_set_mode (tmp, video_hook);
       grub_free (tmp);
     }

diff --git a/loader/i386/xnu.c b/loader/i386/xnu.c
index f71e2c306f949e4901f3bb7316ba29f6e77e768f..ef3e905381dc404fbf9a9b7fefd819b2fadf1840 100644 (file)
--- a/loader/i386/xnu.c
+++ b/loader/i386/xnu.c
@@ -748,11 +748,13 @@ grub_cpu_xnu_fill_devicetree (void)
 #endif
 
       /* The name of key for new table. */
-      grub_sprintf (guidbuf, "%08x-%04x-%04x-%02x%02x-",
-                   guid.data1, guid.data2, guid.data3, guid.data4[0],
-                   guid.data4[1]);
+      grub_snprintf (guidbuf, sizeof (guidbuf), "%08x-%04x-%04x-%02x%02x-",
+                    guid.data1, guid.data2, guid.data3, guid.data4[0],
+                    guid.data4[1]);
       for (j = 2; j < 8; j++)
-       grub_sprintf (guidbuf + grub_strlen (guidbuf), "%02x", guid.data4[j]);
+       grub_snprintf (guidbuf + grub_strlen (guidbuf),
+                      sizeof (guidbuf) - grub_strlen (guidbuf),
+                      "%02x", guid.data4[j]);
       /* For some reason GUID has to be in uppercase. */
       for (j = 0; guidbuf[j] ; j++)
        if (guidbuf[j] >= 'a' && guidbuf[j] <= 'f')

diff --git a/loader/xnu.c b/loader/xnu.c
index f3ae3888a0de29532fec49124d2e7efd972de2e7..bb1178e1746b0be86dda81545ca46ef14398be94 100644 (file)
--- a/loader/xnu.c
+++ b/loader/xnu.c
@@ -568,10 +568,9 @@ grub_xnu_register_memory (char *prefix, int *suffix,
     return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't register memory");
   if (suffix)
     {
-      driverkey->name = grub_malloc (grub_strlen (prefix) + 10);
+      driverkey->name = grub_asprintf ("%s%d", prefix, (*suffix)++);
       if (!driverkey->name)
        return grub_error (GRUB_ERR_OUT_OF_MEMORY, "can't register memory");
-      grub_sprintf (driverkey->name, "%s%d", prefix, (*suffix)++);
     }
   else
     driverkey->name = grub_strdup (prefix);

diff --git a/normal/autofs.c b/normal/autofs.c
index ce354a22c2151310f265ea7cf8b0b32ad782fcc0..d1a6d21108b4ef79f8063d1651154928fd0ddb03 100644 (file)
--- a/normal/autofs.c
+++ b/normal/autofs.c
@@ -63,12 +63,11 @@ read_fs_list (void)
     {
       char *filename;
 
-      filename = grub_malloc (grub_strlen (prefix) + sizeof ("/fs.lst"));
+      filename = grub_asprintf ("%s/fs.lst", prefix);
       if (filename)
        {
          grub_file_t file;
 
-         grub_sprintf (filename, "%s/fs.lst", prefix);
          file = grub_file_open (filename);
          if (file)
            {

diff --git a/normal/completion.c b/normal/completion.c
index d264028cc0be826801ab76173b44e76d92104ec9..81972636d86d88680e22323fa66f035bbbe95fd8 100644 (file)
--- a/normal/completion.c
+++ b/normal/completion.c
@@ -107,17 +107,12 @@ iterate_partition (grub_disk_t disk, const grub_partition_t p)
   if (! partition_name)
     return 1;
 
-  name = grub_malloc (grub_strlen (disk_name) + 1
-                     + grub_strlen (partition_name) + 1);
-  if (! name)
-    {
-      grub_free (partition_name);
-      return 1;
-    }
-
-  grub_sprintf (name, "%s,%s", disk_name, partition_name);
+  name = grub_asprintf ("%s,%s", disk_name, partition_name);
   grub_free (partition_name);
 
+  if (! name)
+    return 1;
+
   ret = add_completion (name, ")", GRUB_COMPLETION_TYPE_PARTITION);
   grub_free (name);
   return ret;
@@ -141,11 +136,15 @@ iterate_dir (const char *filename, const struct grub_dirhook_info *info)
     }
   else if (grub_strcmp (filename, ".") && grub_strcmp (filename, ".."))
     {
-      char fname[grub_strlen (filename) + 2];
+      char *fname;
 
-      grub_sprintf (fname, "%s/", filename);
+      fname = grub_asprintf ("%s/", filename);
       if (add_completion (fname, "", GRUB_COMPLETION_TYPE_FILE))
-       return 1;
+       {
+         grub_free (fname);
+         return 1;
+       }
+      grub_free (fname);
     }
 
   return 0;
@@ -360,8 +359,9 @@ complete_arguments (char *command)
       if (!option->longarg)
        continue;
 
-      longarg = grub_malloc (grub_strlen (option->longarg));
-      grub_sprintf (longarg, "--%s", option->longarg);
+      longarg = grub_asprintf ("--%s", option->longarg);
+      if (!longarg)
+       return 1;
 
       if (add_completion (longarg, " ", GRUB_COMPLETION_TYPE_ARGUMENT))
        {

diff --git a/normal/dyncmd.c b/normal/dyncmd.c
index 04f1945dc64348c99fb5ea4064333e0f37aea060..0a9bb347a70cb03c522e23db07df13a8e566d16d 100644 (file)
--- a/normal/dyncmd.c
+++ b/normal/dyncmd.c
@@ -75,12 +75,11 @@ read_command_list (void)
     {
       char *filename;
 
-      filename = grub_malloc (grub_strlen (prefix) + sizeof ("/command.lst"));
+      filename = grub_asprintf ("%s/command.lst", prefix);
       if (filename)
        {
          grub_file_t file;
 
-         grub_sprintf (filename, "%s/command.lst", prefix);
          file = grub_file_open (filename);
          if (file)
            {

diff --git a/normal/handler.c b/normal/handler.c
index b44dc7a68f11eee1041099c7a9ece25cc9bf5300..034be77d1be0c150b428330e6a0118166f291279 100644 (file)
--- a/normal/handler.c
+++ b/normal/handler.c
@@ -172,12 +172,11 @@ read_handler_list (void)
     {
       char *filename;
 
-      filename = grub_malloc (grub_strlen (prefix) + sizeof ("/handler.lst"));
+      filename = grub_asprintf ("%s/handler.lst", prefix);
       if (filename)
        {
          grub_file_t file;
 
-         grub_sprintf (filename, "%s/handler.lst", prefix);
          file = grub_file_open (filename);
          if (file)
            {

diff --git a/normal/main.c b/normal/main.c
index 23de7e2388f827d804b1b90cd0d8b435c5ed3de4..7aeba37cabba49de5e86614a04410f506a18f012 100644 (file)
--- a/normal/main.c
+++ b/normal/main.c
@@ -389,16 +389,17 @@ grub_normal_init_page (void)
   int posx;
   const char *msg = _("GNU GRUB  version %s");
 
-  char *msg_formatted = grub_malloc (grub_strlen(msg) +
-                                    grub_strlen(PACKAGE_VERSION));
- 
-  grub_cls ();
-
-  grub_sprintf (msg_formatted, msg, PACKAGE_VERSION);
+  char *msg_formatted;
 
   grub_uint32_t *unicode_msg;
   grub_uint32_t *last_position;
  
+  grub_cls ();
+
+  msg_formatted = grub_asprintf (msg, PACKAGE_VERSION);
+  if (!msg_formatted)
+    return;
+ 
   msg_len = grub_utf8_to_ucs4_alloc (msg_formatted,
                                     &unicode_msg, &last_position);
  
@@ -475,11 +476,10 @@ grub_cmd_normal (struct grub_command *cmd,
       prefix = grub_env_get ("prefix");
       if (prefix)
        {
-         config = grub_malloc (grub_strlen (prefix) + sizeof ("/grub.cfg"));
+         config = grub_asprintf ("%s/grub.cfg", prefix);
          if (! config)
            goto quit;
 
-         grub_sprintf (config, "%s/grub.cfg", prefix);
          grub_enter_normal_mode (config);
          grub_free (config);
        }
@@ -528,10 +528,11 @@ grub_normal_reader_init (void)
 
   const char *msg_esc = _("ESC at any time exits.");
 
-  char *msg_formatted = grub_malloc (sizeof (char) * (grub_strlen (msg) +
-                grub_strlen(msg_esc) + 1));
+  char *msg_formatted;
 
-  grub_sprintf (msg_formatted, msg, reader_nested ? msg_esc : "");
+  msg_formatted = grub_asprintf (msg, reader_nested ? msg_esc : "");
+  if (!msg_formatted)
+    return grub_errno;
   grub_print_message_indented (msg_formatted, 3, STANDARD_MARGIN);
   grub_puts ("\n");
 
@@ -546,9 +547,11 @@ static grub_err_t
 grub_normal_read_line (char **line, int cont)
 {
   grub_parser_t parser = grub_parser_get_current ();
-  char prompt[sizeof(">") + grub_strlen (parser->name)];
+  char *prompt;
 
-  grub_sprintf (prompt, "%s>", parser->name);
+  prompt = grub_asprintf ("%s>", parser->name);
+  if (!prompt)
+    return grub_errno;
 
   while (1)
     {

diff --git a/normal/menu.c b/normal/menu.c
index 8ee7d1c224d46ca667eff63abdc77039bde68166..99ffc67dde9db26d03a4eab297812eca15af9c10 100644 (file)
--- a/normal/menu.c
+++ b/normal/menu.c
@@ -78,7 +78,7 @@ grub_menu_set_timeout (int timeout)
     {
       char buf[16];
 
-      grub_sprintf (buf, "%d", timeout);
+      grub_snprintf (buf, sizeof (buf), "%d", timeout);
       grub_env_set ("timeout", buf);
     }
 }

diff --git a/normal/menu_text.c b/normal/menu_text.c
index bac15f32b8feea85327d7adfc5890c7cf26370e8..3bcf35a938a853d657a39ce4f7f298807dde12c3 100644 (file)
--- a/normal/menu_text.c
+++ b/normal/menu_text.c
@@ -210,13 +210,14 @@ command-line or ESC to return menu."), STANDARD_MARGIN, STANDARD_MARGIN);
     }
   else
     {
-      const char *msg = _("Use the %C and %C keys to select which \
-entry is highlighted.\n");
-      char *msg_translated =
-       grub_malloc (sizeof (char) * grub_strlen (msg) + 1);
-
-      grub_sprintf (msg_translated, msg, (grub_uint32_t) GRUB_TERM_DISP_UP,
-                   (grub_uint32_t) GRUB_TERM_DISP_DOWN);
+      const char *msg = _("Use the %C and %C keys to select which "
+                         "entry is highlighted.\n");
+      char *msg_translated;
+
+      msg_translated = grub_asprintf (msg, (grub_uint32_t) GRUB_TERM_DISP_UP,
+                                    (grub_uint32_t) GRUB_TERM_DISP_DOWN);
+      if (!msg_translated)
+       return;
       grub_putchar ('\n');
       grub_print_message_indented (msg_translated, STANDARD_MARGIN, STANDARD_MARGIN);
 
@@ -394,13 +395,13 @@ print_timeout (int timeout, int offset)
 {
   const char *msg =
     _("The highlighted entry will be booted automatically in %ds.");
+  char *msg_translated;
 
   grub_gotoxy (0, GRUB_TERM_HEIGHT - 3);
 
-  char *msg_translated =
-    grub_malloc (sizeof (char) * grub_strlen (msg) + 5);
-
-  grub_sprintf (msg_translated, msg, timeout);
+  msg_translated = grub_asprintf (msg, timeout);
+  if (!msg_translated)
+    return;
   grub_print_message_indented (msg_translated, 3, 0);
  
   int posx;

diff --git a/partmap/acorn.c b/partmap/acorn.c
index 076d998f822ea9cfbd461e55dc503cd79c887d7c..aead5ff85f7b8913021e82e020c54da1e0d4e056 100644 (file)
--- a/partmap/acorn.c
+++ b/partmap/acorn.c
@@ -175,14 +175,7 @@ fail:
 static char *
 acorn_partition_map_get_name (const grub_partition_t p)
 {
-  char *name;
-
-  name = grub_malloc (13);
-  if (! name)
-    return 0;
-
-  grub_sprintf (name, "%d", p->index + 1);
-  return name;
+  return grub_asprintf ("%d", p->index + 1);
 }
 \f
 

diff --git a/partmap/amiga.c b/partmap/amiga.c
index e8ba9181c3528158cd5eabef7371b550a44df07c..691bd4c3e9fadc21aba12da08b89d9a2cc22fa74 100644 (file)
--- a/partmap/amiga.c
+++ b/partmap/amiga.c
@@ -184,14 +184,7 @@ amiga_partition_map_probe (grub_disk_t disk, const char *str)
 static char *
 amiga_partition_map_get_name (const grub_partition_t p)
 {
-  char *name;
-
-  name = grub_malloc (13);
-  if (! name)
-    return 0;
-
-  grub_sprintf (name, "%d", p->index + 1);
-  return name;
+  return grub_asprintf ("%d", p->index + 1);
 }
 
 \f

diff --git a/partmap/apple.c b/partmap/apple.c
index 765912672f8f0a013b97c54a29eff0feb27dd0e2..a5f7fdd8a71490d16a93f5983ee744650e9d107c 100644 (file)
--- a/partmap/apple.c
+++ b/partmap/apple.c
@@ -227,14 +227,7 @@ apple_partition_map_probe (grub_disk_t disk, const char *str)
 static char *
 apple_partition_map_get_name (const grub_partition_t p)
 {
-  char *name;
-
-  name = grub_malloc (13);
-  if (! name)
-    return 0;
-
-  grub_sprintf (name, "%d", p->index + 1);
-  return name;
+  return grub_asprintf ("%d", p->index + 1);
 }
 
 \f

diff --git a/partmap/gpt.c b/partmap/gpt.c
index 4a4957437fcbe054d530e0432e6bb06906973214..ed583e0a31904e781017c3ad3d650e21a6e7e926 100644 (file)
--- a/partmap/gpt.c
+++ b/partmap/gpt.c
@@ -162,14 +162,7 @@ gpt_partition_map_probe (grub_disk_t disk, const char *str)
 static char *
 gpt_partition_map_get_name (const grub_partition_t p)
 {
-  char *name;
-
-  name = grub_malloc (13);
-  if (! name)
-    return 0;
-
-  grub_sprintf (name, "%d", p->index + 1);
-  return name;
+  return grub_asprintf ("%d", p->index + 1);
 }
 
 \f

diff --git a/partmap/msdos.c b/partmap/msdos.c
index 6ba7fb927cd47323a2a4f587ab87b12544c2f186..ea3266605758643d3c3743392ba95fe0f58a1648 100644 (file)
--- a/partmap/msdos.c
+++ b/partmap/msdos.c
@@ -300,21 +300,15 @@ pc_partition_map_probe (grub_disk_t disk, const char *str)
 static char *
 pc_partition_map_get_name (const grub_partition_t p)
 {
-  char *name;
   struct grub_msdos_partition *pcdata = p->data;
 
-  name = grub_malloc (13);
-  if (! name)
-    return 0;
-
   if (pcdata->bsd_part < 0)
-    grub_sprintf (name, "%d", pcdata->dos_part + 1);
+    return grub_asprintf ("%d", pcdata->dos_part + 1);
   else if (pcdata->dos_part < 0)
-    grub_sprintf (name, "%c", pcdata->bsd_part + 'a');
+    return grub_asprintf ("%c", pcdata->bsd_part + 'a');
   else
-    grub_sprintf (name, "%d,%c", pcdata->dos_part + 1, pcdata->bsd_part + 'a');
-
-  return name;
+    return grub_asprintf ("%d,%c", pcdata->dos_part + 1,
+                         pcdata->bsd_part + 'a');
 }
 
 \f

diff --git a/partmap/sun.c b/partmap/sun.c
index e816ec17af3931af93f961f56cdc9a8883d9f09d..89d0c5303bb029592cb2c10456dcd9cbeb5dcbd8 100644 (file)
--- a/partmap/sun.c
+++ b/partmap/sun.c
@@ -184,13 +184,7 @@ sun_partition_map_probe (grub_disk_t disk, const char *str)
 static char *
 sun_partition_map_get_name (const grub_partition_t p)
 {
-  char *name;
-
-  name = grub_malloc (13);
-  if (name)
-    grub_sprintf (name, "%d", p->index + 1);
-
-  return name;
+  return grub_asprintf ("%d", p->index + 1);
 }
 
 /* Partition map type.  */

diff --git a/script/execute.c b/script/execute.c
index 08224fc7db9c185d5efb53e6ce193099d2767508..ee7e099bce22afe7bc990b37e5907385c343842d 100644 (file)
--- a/script/execute.c
+++ b/script/execute.c
@@ -92,7 +92,7 @@ grub_script_execute_cmdline (struct grub_script_cmd *cmd)
   grub_err_t ret = 0;
   int argcount = 0;
   grub_script_function_t func = 0;
-  char errnobuf[6];
+  char errnobuf[18];
   char *cmdname;
 
   /* Lookup the command.  */
@@ -123,7 +123,7 @@ grub_script_execute_cmdline (struct grub_script_cmd *cmd)
            }
          grub_free (assign);
 
-         grub_sprintf (errnobuf, "%d", grub_errno);
+         grub_snprintf (errnobuf, sizeof (errnobuf), "%d", grub_errno);
          grub_env_set ("?", errnobuf);
 
          return 0;
@@ -156,7 +156,7 @@ grub_script_execute_cmdline (struct grub_script_cmd *cmd)
     grub_free (args[i]);
   grub_free (args);
 
-  grub_sprintf (errnobuf, "%d", ret);
+  grub_snprintf (errnobuf, sizeof (errnobuf), "%d", ret);
   grub_env_set ("?", errnobuf);
 
   return ret;

diff --git a/term/gfxterm.c b/term/gfxterm.c
index fa19a5d85e2e09182a4aa2852202a0e62dbc65ac..7c99ae053fcd5c217fe578a418bb0024426be7e1 100644 (file)
--- a/term/gfxterm.c
+++ b/term/gfxterm.c
@@ -272,9 +272,9 @@ grub_gfxterm_init (void)
     err = grub_video_set_mode (DEFAULT_VIDEO_MODE, video_hook);
   else
     {
-      tmp = grub_malloc (grub_strlen (modevar)
-                        + sizeof (DEFAULT_VIDEO_MODE) + 1);
-      grub_sprintf (tmp, "%s;" DEFAULT_VIDEO_MODE, modevar);
+      tmp = grub_asprintf ("%s;" DEFAULT_VIDEO_MODE, modevar);
+      if (!tmp)
+       return grub_errno;
       err = grub_video_set_mode (tmp, video_hook);
       grub_free (tmp);
     }

diff --git a/term/ieee1275/ofconsole.c b/term/ieee1275/ofconsole.c
index fbed9eca135b50f74078510945bc6552ac3af79c..88606a4bc2e4ef2b4992be7e8f49b97ea78c3f37 100644 (file)
--- a/term/ieee1275/ofconsole.c
+++ b/term/ieee1275/ofconsole.c
@@ -104,7 +104,7 @@ grub_ofconsole_getcharwidth (grub_uint32_t c __attribute__((unused)))
 static void
 grub_ofconsole_setcolorstate (grub_term_color_state state)
 {
-  char setcol[20];
+  char *setcol;
   int fg;
   int bg;
 
@@ -123,8 +123,10 @@ grub_ofconsole_setcolorstate (grub_term_color_state state)
       return;
     }
 
-  grub_sprintf (setcol, "\e[3%dm\e[4%dm", fg, bg);
-  grub_ofconsole_writeesc (setcol);
+  setcol = grub_asprintf ("\e[3%dm\e[4%dm", fg, bg);
+  if (setcol)
+    grub_ofconsole_writeesc (setcol);
+  grub_free (setcol);
 }
 
 static void
@@ -287,15 +289,16 @@ grub_ofconsole_getwh (void)
 static void
 grub_ofconsole_gotoxy (grub_uint8_t x, grub_uint8_t y)
 {
-  char s[11]; /* 5 + 3 + 3.  */
-
   if (! grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_NO_ANSI))
     {
+      char *s;
       grub_curr_x = x;
       grub_curr_y = y;
 
-      grub_sprintf (s, "\e[%d;%dH", y + 1, x + 1);
-      grub_ofconsole_writeesc (s);
+      s = grub_asprintf ("\e[%d;%dH", y + 1, x + 1);
+      if (s)
+       grub_ofconsole_writeesc (s);
+      grub_free (s);
     }
   else
     {

diff --git a/term/tparm.c b/term/tparm.c
index fa25bd32c4d2a40cd5fe44138a4ca2f02c29eb80..adf0b3a7c010744f5e21eeddab73662a617c38e5 100644 (file)
--- a/term/tparm.c
+++ b/term/tparm.c
@@ -167,7 +167,7 @@ save_text(const char *fmt, const char *s, int len)
 
     get_space(s_len + 1);
 
-    (void) grub_sprintf(out_buff + out_used, fmt, s);
+    (void) grub_snprintf(out_buff + out_used, s_len + 1, fmt, s);
     out_used += grub_strlen(out_buff + out_used);
 }
 
@@ -179,7 +179,7 @@ save_number(const char *fmt, int number, int len)
 
     get_space((unsigned) len + 1);
 
-    (void) grub_sprintf(out_buff + out_used, fmt, number);
+    (void) grub_snprintf(out_buff + out_used, len + 1, fmt, number);
     out_used += grub_strlen(out_buff + out_used);
 }
 

diff --git a/util/grub-fstest.c b/util/grub-fstest.c
index fa54fe41492bd58e7c58fe2ef747f5d6af4758fb..d33ecb7642bbb29d0c7d7db1d7a13b229a6ac9de 100644 (file)
--- a/util/grub-fstest.c
+++ b/util/grub-fstest.c
@@ -278,18 +278,26 @@ cmd_crc (char *pathname)
 static void
 fstest (char **images, int num_disks, int cmd, int n, char **args)
 {
-  char host_file[128];
-  char loop_name[8];
-  char *argv[3] = { "-p", loop_name, host_file};
+  char *host_file;
+  char *loop_name;
+  char *argv[3] = { "-p" };
   int i;
 
   for (i = 0; i < num_disks; i++)
     {
-      if (grub_strlen (images[i]) + 7 > sizeof (host_file))
-        grub_util_error ("Pathname %s too long.", images[i]);
+      loop_name = grub_asprintf ("loop%d", i);
+      host_file = grub_asprintf ("(host)%s", images[i]);
 
-      grub_sprintf (loop_name, "loop%d", i);
-      grub_sprintf (host_file, "(host)%s", images[i]);
+      if (!loop_name || !host_file)
+       {
+         grub_free (loop_name);
+         grub_free (host_file);
+         grub_util_error (grub_errmsg);
+         return;
+       }
+
+      argv[1] = loop_name;
+      argv[2] = host_file;
 
       if (execute_command ("loopback", 3, argv))
         grub_util_error ("loopback command fails.");
@@ -328,9 +336,19 @@ fstest (char **images, int num_disks, int cmd, int n, char **args)
 
   for (i = 0; i < num_disks; i++)
     {
-      grub_sprintf (loop_name, "loop%d", i);
+      grub_free (loop_name);
+      loop_name = grub_asprintf ("loop%d", i);
+      if (!loop_name)
+       {
+         grub_free (host_file);
+         grub_util_error (grub_errmsg);
+         return;
+       }
       execute_command ("loopback", 2, argv);
     }
+
+  grub_free (loop_name);
+  grub_free (host_file);
 }
 
 static struct option options[] = {