Line data    Source code

       1             : /* SPDX-License-Identifier: LGPL-2.1+ */
       2             : #pragma once
       3             : 
       4             : #include <stdbool.h>
       5             : 
       6             : #include "sd-id128.h"
       7             : 
       8             : #include "macro.h"
       9             : 
      10             : typedef struct DissectedImage DissectedImage;
      11             : typedef struct DissectedPartition DissectedPartition;
      12             : typedef struct DecryptedImage DecryptedImage;
      13             : 
      14             : struct DissectedPartition {
      15             :         bool found:1;
      16             :         bool rw:1;
      17             :         int partno;        /* -1 if there was no partition and the images contains a file system directly */
      18             :         int architecture;  /* Intended architecture: either native, secondary or unset (-1). */
      19             :         sd_id128_t uuid;   /* Partition entry UUID as reported by the GPT */
      20             :         char *fstype;
      21             :         char *node;
      22             :         char *decrypted_node;
      23             :         char *decrypted_fstype;
      24             : };
      25             : 
      26             : enum  {
      27             :         PARTITION_ROOT,
      28             :         PARTITION_ROOT_SECONDARY,  /* Secondary architecture */
      29             :         PARTITION_HOME,
      30             :         PARTITION_SRV,
      31             :         PARTITION_ESP,
      32             :         PARTITION_XBOOTLDR,
      33             :         PARTITION_SWAP,
      34             :         PARTITION_ROOT_VERITY, /* verity data for the PARTITION_ROOT partition */
      35             :         PARTITION_ROOT_SECONDARY_VERITY, /* verity data for the PARTITION_ROOT_SECONDARY partition */
      36             :         _PARTITION_DESIGNATOR_MAX,
      37             :         _PARTITION_DESIGNATOR_INVALID = -1
      38             : };
      39             : 
      40           0 : static inline int PARTITION_VERITY_OF(int p) {
      41           0 :         if (p == PARTITION_ROOT)
      42           0 :                 return PARTITION_ROOT_VERITY;
      43           0 :         if (p == PARTITION_ROOT_SECONDARY)
      44           0 :                 return PARTITION_ROOT_SECONDARY_VERITY;
      45           0 :         return _PARTITION_DESIGNATOR_INVALID;
      46             : }
      47             : 
      48             : typedef enum DissectImageFlags {
      49             :         DISSECT_IMAGE_READ_ONLY           = 1 << 0,
      50             :         DISSECT_IMAGE_DISCARD_ON_LOOP     = 1 << 1,  /* Turn on "discard" if on a loop device and file system supports it */
      51             :         DISSECT_IMAGE_DISCARD             = 1 << 2,  /* Turn on "discard" if file system supports it, on all block devices */
      52             :         DISSECT_IMAGE_DISCARD_ON_CRYPTO   = 1 << 3,  /* Turn on "discard" also on crypto devices */
      53             :         DISSECT_IMAGE_DISCARD_ANY = DISSECT_IMAGE_DISCARD_ON_LOOP |
      54             :                                     DISSECT_IMAGE_DISCARD |
      55             :                                     DISSECT_IMAGE_DISCARD_ON_CRYPTO,
      56             :         DISSECT_IMAGE_GPT_ONLY            = 1 << 4,  /* Only recognize images with GPT partition tables */
      57             :         DISSECT_IMAGE_REQUIRE_ROOT        = 1 << 5,  /* Don't accept disks without root partition */
      58             :         DISSECT_IMAGE_MOUNT_ROOT_ONLY     = 1 << 6,  /* Mount only the root partition */
      59             :         DISSECT_IMAGE_MOUNT_NON_ROOT_ONLY = 1 << 7,  /* Mount only non-root partitions */
      60             :         DISSECT_IMAGE_VALIDATE_OS         = 1 << 8,  /* Refuse mounting images that aren't identifiable as OS images */
      61             :         DISSECT_IMAGE_NO_UDEV             = 1 << 9,  /* Don't wait for udev initializing things */
      62             : } DissectImageFlags;
      63             : 
      64             : struct DissectedImage {
      65             :         bool encrypted:1;
      66             :         bool verity:1;     /* verity available and usable */
      67             :         bool can_verity:1; /* verity available, but not necessarily used */
      68             : 
      69             :         DissectedPartition partitions[_PARTITION_DESIGNATOR_MAX];
      70             : 
      71             :         char *hostname;
      72             :         sd_id128_t machine_id;
      73             :         char **machine_info;
      74             :         char **os_release;
      75             : };
      76             : 
      77             : int probe_filesystem(const char *node, char **ret_fstype);
      78             : int dissect_image(int fd, const void *root_hash, size_t root_hash_size, DissectImageFlags flags, DissectedImage **ret);
      79             : int dissect_image_and_warn(int fd, const char *name, const void *root_hash, size_t root_hash_size, DissectImageFlags flags, DissectedImage **ret);
      80             : 
      81             : DissectedImage* dissected_image_unref(DissectedImage *m);
      82           8 : DEFINE_TRIVIAL_CLEANUP_FUNC(DissectedImage*, dissected_image_unref);
      83             : 
      84             : int dissected_image_decrypt(DissectedImage *m, const char *passphrase, const void *root_hash, size_t root_hash_size, DissectImageFlags flags, DecryptedImage **ret);
      85             : int dissected_image_decrypt_interactively(DissectedImage *m, const char *passphrase, const void *root_hash, size_t root_hash_size, DissectImageFlags flags, DecryptedImage **ret);
      86             : int dissected_image_mount(DissectedImage *m, const char *dest, uid_t uid_shift, DissectImageFlags flags);
      87             : 
      88             : int dissected_image_acquire_metadata(DissectedImage *m);
      89             : 
      90             : DecryptedImage* decrypted_image_unref(DecryptedImage *p);
      91           8 : DEFINE_TRIVIAL_CLEANUP_FUNC(DecryptedImage*, decrypted_image_unref);
      92             : int decrypted_image_relinquish(DecryptedImage *d);
      93             : 
      94             : const char* partition_designator_to_string(int i) _const_;
      95             : int partition_designator_from_string(const char *name) _pure_;
      96             : 
      97             : int root_hash_load(const char *image, void **ret, size_t *ret_size);