Fixes for various memory leaks and other issues

src/lib/blockdev.c.in

@@ -297,9 +297,7 @@ static gboolean load_plugins (BDPluginSpec **require_plugins, gboolean reload, g
     gboolean requested_loaded = TRUE;
     GError *error = NULL;
     GSequence *config_files = NULL;
-    GSList *plugins_sonames[BD_PLUGIN_UNDEF] = {NULL, NULL, NULL, NULL, NULL,
-                                                NULL, NULL, NULL, NULL, NULL,
-                                                NULL, NULL};
+    GSList *plugins_sonames[BD_PLUGIN_UNDEF] = {0};
     BDPlugin plugin_name = BD_PLUGIN_UNDEF;
     guint64 required_plugins_mask = 0;
 

src/plugins/crypto.c

@@ -381,10 +381,10 @@ gboolean bd_crypto_is_tech_avail (BDCryptoTech tech, guint64 mode, GError **erro
         case BD_CRYPTO_TECH_LUKS:
             ret = mode & (BD_CRYPTO_TECH_MODE_CREATE|BD_CRYPTO_TECH_MODE_OPEN_CLOSE|BD_CRYPTO_TECH_MODE_QUERY|
                           BD_CRYPTO_TECH_MODE_ADD_KEY|BD_CRYPTO_TECH_MODE_REMOVE_KEY|BD_CRYPTO_TECH_MODE_RESIZE|
-                          BD_CRYPTO_TECH_MODE_SUSPEND_RESUME|BD_CRYPTO_TECH_MODE_BACKUP_RESTORE);
+                          BD_CRYPTO_TECH_MODE_SUSPEND_RESUME|BD_CRYPTO_TECH_MODE_BACKUP_RESTORE|BD_CRYPTO_TECH_MODE_MODIFY);
             if (ret != mode) {
                 g_set_error_literal (error, BD_CRYPTO_ERROR, BD_CRYPTO_ERROR_TECH_UNAVAIL,
-                                     "Only 'create', 'open', 'query', 'add-key', 'remove-key', 'resize', 'suspend-resume', 'backup-restore' supported for LUKS");
+                                     "Only 'create', 'open', 'query', 'add-key', 'remove-key', 'resize', 'suspend-resume', 'backup-restore', 'modify' supported for LUKS");
                 return FALSE;
             } else
                 return TRUE;
@@ -1023,11 +1023,31 @@ gboolean _crypto_luks_format (const gchar *device,
     if (min_entropy > 0) {
         dev_random_fd = open ("/dev/random", O_RDONLY);
         if (dev_random_fd >= 0) {
-            ioctl (dev_random_fd, RNDGETENTCNT, &current_entropy);
+            if (ioctl (dev_random_fd, RNDGETENTCNT, &current_entropy) < 0) {
+                g_set_error (&l_error, BD_CRYPTO_ERROR, BD_CRYPTO_ERROR_FORMAT_FAILED,
+                             "Failed to get random data entropy level: %s",
+                             strerror_l (errno, c_locale));
+                close (dev_random_fd);
+                crypt_free (cd);
+                g_strfreev (cipher_specs);
+                bd_utils_report_finished (progress_id, l_error->message);
+                g_propagate_error (error, l_error);
+                return FALSE;
+            }
             while (current_entropy < min_entropy) {
                 bd_utils_report_progress (progress_id, 0, "Waiting for enough random data entropy");
                 sleep (1);
-                ioctl (dev_random_fd, RNDGETENTCNT, &current_entropy);
+                if (ioctl (dev_random_fd, RNDGETENTCNT, &current_entropy) < 0) {
+                    g_set_error (&l_error, BD_CRYPTO_ERROR, BD_CRYPTO_ERROR_FORMAT_FAILED,
+                                 "Failed to get random data entropy level: %s",
+                                 strerror_l (errno, c_locale));
+                    close (dev_random_fd);
+                    crypt_free (cd);
+                    g_strfreev (cipher_specs);
+                    bd_utils_report_finished (progress_id, l_error->message);
+                    g_propagate_error (error, l_error);
+                    return FALSE;
+                }
             }
             close (dev_random_fd);
         } else {
@@ -1422,6 +1442,7 @@ static gboolean _crypto_close (const gchar *device, const gchar *tech_name, GErr
     if (ret != 0) {
         g_set_error (&l_error, BD_CRYPTO_ERROR, BD_CRYPTO_ERROR_DEVICE,
                      "Failed to initialize device: %s", strerror_l (-ret, c_locale));
+        crypt_free (cd);
         bd_utils_report_finished (progress_id, l_error->message);
         g_propagate_error (error, l_error);
         return FALSE;
@@ -1828,6 +1849,7 @@ gboolean bd_crypto_luks_resize (const gchar *luks_device, guint64 size, BDCrypto
     if (ret != 0) {
         g_set_error (&l_error, BD_CRYPTO_ERROR, BD_CRYPTO_ERROR_DEVICE,
                      "Failed to initialize device: %s", strerror_l (-ret, c_locale));
+        crypt_free (cd);
         bd_utils_report_finished (progress_id, l_error->message);
         g_propagate_error (error, l_error);
         return FALSE;
@@ -1937,6 +1959,7 @@ gboolean bd_crypto_luks_suspend (const gchar *luks_device, GError **error) {
     if (ret != 0) {
         g_set_error (&l_error, BD_CRYPTO_ERROR, BD_CRYPTO_ERROR_DEVICE,
                      "Failed to initialize device: %s", strerror_l (-ret, c_locale));
+        crypt_free (cd);
         bd_utils_report_finished (progress_id, l_error->message);
         g_propagate_error (error, l_error);
         return FALSE;
@@ -1986,6 +2009,7 @@ gboolean bd_crypto_luks_resume (const gchar *luks_device, BDCryptoKeyslotContext
     if (ret != 0) {
         g_set_error (&l_error, BD_CRYPTO_ERROR, BD_CRYPTO_ERROR_DEVICE,
                      "Failed to initialize device: %s", strerror_l (-ret, c_locale));
+        crypt_free (cd);
         bd_utils_report_finished (progress_id, l_error->message);
         g_propagate_error (error, l_error);
         return FALSE;
@@ -2587,6 +2611,7 @@ BDCryptoLUKSInfo* bd_crypto_luks_info (const gchar *device, GError **error) {
     if (ret != 0) {
         g_set_error (error, BD_CRYPTO_ERROR, BD_CRYPTO_ERROR_DEVICE,
                      "Failed to initialize device: %s", strerror_l (-ret, c_locale));
+        crypt_free (cd);
         return NULL;
     }
 
@@ -2742,6 +2767,7 @@ BDCryptoIntegrityInfo* bd_crypto_integrity_info (const gchar *device, GError **e
     if (ret != 0) {
         g_set_error (error, BD_CRYPTO_ERROR, BD_CRYPTO_ERROR_DEVICE,
                      "Failed to initialize device: %s", strerror_l (-ret, c_locale));
+        crypt_free (cd);
         return NULL;
     }
 
@@ -2811,6 +2837,7 @@ BDCryptoLUKSTokenInfo** bd_crypto_luks_token_info (const gchar *device, GError *
     if (ret != 0) {
         g_set_error (error, BD_CRYPTO_ERROR, BD_CRYPTO_ERROR_DEVICE,
                      "Failed to initialize device: %s", strerror_l (-ret, c_locale));
+        crypt_free (cd);
         return NULL;
     }
 

src/plugins/dm.c

@@ -176,14 +176,16 @@ gboolean bd_dm_remove (const gchar *map_name, GError **error) {
 gchar* bd_dm_name_from_node (const gchar *dm_node, GError **error) {
     gchar *ret = NULL;
     gboolean success = FALSE;
-    g_autofree gchar *sys_path = g_strdup_printf ("/sys/class/block/%s/dm/name", dm_node);
+    g_autofree gchar *sys_path = NULL;
 
     if (!dm_node || strlen (dm_node) == 0) {
         g_set_error_literal (error, BD_DM_ERROR, BD_DM_ERROR_DEVICE_NOEXIST,
                              "No DM node specified");
         return NULL;
     }
 
+    sys_path = g_strdup_printf ("/sys/class/block/%s/dm/name", dm_node);
+
     if (access (sys_path, R_OK) != 0) {
         g_set_error_literal (error, BD_DM_ERROR, BD_DM_ERROR_SYS,
                              "Failed to access dm node's parameters under /sys");

src/plugins/fs/generic.c

@@ -820,9 +820,18 @@ static gboolean xfs_resize_device (const gchar *device, guint64 new_size, const
         return FALSE;
     }
 
+    if (xfs_info->block_size == 0) {
+        g_set_error (error, BD_FS_ERROR, BD_FS_ERROR_FAIL,
+                     "Failed to get block size for device '%s'", device);
+        bd_fs_xfs_info_free (xfs_info);
+        return FALSE;
+    }
+
     mountpoint = fs_mount (device, "xfs", FALSE, &unmount, error);
-    if (!mountpoint)
+    if (!mountpoint) {
+        bd_fs_xfs_info_free (xfs_info);
         return FALSE;
+    }
 
     new_size = (new_size + xfs_info->block_size - 1) / xfs_info->block_size;
     bd_fs_xfs_info_free (xfs_info);
@@ -857,6 +866,13 @@ static gboolean f2fs_resize_device (const gchar *device, guint64 new_size, GErro
         return FALSE;
     }
 
+    if (info->sector_size == 0) {
+        g_set_error (error, BD_FS_ERROR, BD_FS_ERROR_FAIL,
+                     "Failed to get sector size for device '%s'", device);
+        bd_fs_f2fs_info_free (info);
+        return FALSE;
+    }
+
     /* round to nearest sector_size multiple */
     new_size = (new_size + info->sector_size - 1) / info->sector_size;
 

src/plugins/fs/mount.c

@@ -510,6 +510,8 @@ static gboolean run_as_user (MountFunc func, MountArgs *args, uid_t run_as_uid,
     pid = fork ();
 
     if (pid == -1) {
+        close (pipefd[0]);
+        close (pipefd[1]);
         g_set_error_literal (error, BD_FS_ERROR, BD_FS_ERROR_FAIL,
                              "Error forking.");
         return FALSE;
@@ -694,8 +696,6 @@ gboolean bd_fs_unmount (const gchar *spec, gboolean lazy, gboolean force, const
         return ret;
     } else
         return do_unmount (&args, error);
-
-    return TRUE;
 }
 
 /**
@@ -777,8 +777,6 @@ gboolean bd_fs_mount (const gchar *device, const gchar *mountpoint, const gchar
         return ret;
     } else
        return do_mount (&args, error);
-
-    return TRUE;
 }
 
 /**