int main(int argc, char *argv[])
{
int rc;
char *devname;
blkid_probe pr;
blkid_topology tp;
if (argc < 2) {
fprintf(stderr, "usage: %s <device> "
"-- checks based on libblkid for mkfs-like programs.\n",
program_invocation_short_name);
return EXIT_FAILURE;
}
devname = argv[1];
pr = blkid_new_probe_from_filename(devname);
if (!pr)
err(EXIT_FAILURE, "%s: faild to create a new libblkid probe",
devname);
/*
* check Filesystems / Partitions overwrite
*/
/* enable partitions probing (superblocks are enabled by default) */
blkid_probe_enable_partitions(pr, TRUE);
rc = blkid_do_fullprobe(pr);
if (rc == -1)
errx(EXIT_FAILURE, "%s: blkid_do_fullprobe() failed", devname);
else if (rc == 0) {
const char *type;
if (!blkid_probe_lookup_value(pr, "TYPE", &type, NULL))
errx(EXIT_FAILURE, "%s: appears to contain an existing "
"%s superblock", devname, type);
if (!blkid_probe_lookup_value(pr, "PTTYPE", &type, NULL))
errx(EXIT_FAILURE, "%s: appears to contain an partition "
"table (%s)", devname, type);
}
/*
* get topology details
*/
tp = blkid_probe_get_topology(pr);
if (!tp)
errx(EXIT_FAILURE, "%s: failed to read topology", devname);
/* ... your mkfs.<type> code or so ...
off = blkid_topology_get_alignment_offset(tp);
*/
blkid_free_probe(pr);
return EXIT_SUCCESS;
}
/* Print the swap partition information */
static int print_info(blkid_probe pr)
{
const char *data;
if (!blkid_probe_lookup_value(pr, "LABEL", &data, NULL))
printf("LABEL: %s\n", data);
if (!blkid_probe_lookup_value(pr, "UUID", &data, NULL))
printf("UUID: %s\n", data);
return 0;
}
static struct wipe_desc *
get_desc_for_probe(struct wipe_desc *wp, blkid_probe pr)
{
const char *off, *type, *mag, *p, *usage = NULL;
size_t len;
loff_t offset;
int rc, ispt = 0;
/* superblocks */
if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) == 0) {
rc = blkid_probe_lookup_value(pr, "SBMAGIC_OFFSET", &off, NULL);
if (!rc)
rc = blkid_probe_lookup_value(pr, "SBMAGIC", &mag, &len);
if (rc)
return wp;
/* partitions */
} else if (blkid_probe_lookup_value(pr, "PTTYPE", &type, NULL) == 0) {
rc = blkid_probe_lookup_value(pr, "PTMAGIC_OFFSET", &off, NULL);
if (!rc)
rc = blkid_probe_lookup_value(pr, "PTMAGIC", &mag, &len);
if (rc)
return wp;
usage = N_("partition table");
ispt = 1;
} else
return wp;
if (type_pattern && !match_fstype(type, type_pattern))
return wp;
offset = strtoll(off, NULL, 10);
wp = add_offset(wp, offset, 0);
if (!wp)
return NULL;
if (usage || blkid_probe_lookup_value(pr, "USAGE", &usage, NULL) == 0)
wp->usage = xstrdup(usage);
wp->type = xstrdup(type);
wp->on_disk = 1;
wp->is_parttable = ispt ? 1 : 0;
wp->magic = xmalloc(len);
memcpy(wp->magic, mag, len);
wp->len = len;
if (blkid_probe_lookup_value(pr, "LABEL", &p, NULL) == 0)
wp->label = xstrdup(p);
if (blkid_probe_lookup_value(pr, "UUID", &p, NULL) == 0)
wp->uuid = xstrdup(p);
return wp;
}
/* returns device LABEL, UUID, FSTYPE, ... by low-level
* probing interface
*/
static char *
fsprobe_get_value(const char *name, const char *devname)
{
int fd;
const char *data = NULL;
if (!devname || !name)
return NULL;
fd = open_device(devname);
if (fd < 0)
return NULL;
if (!blprobe)
blprobe = blkid_new_probe();
if (!blprobe)
goto done;
if (blkid_probe_set_device(blprobe, fd, 0, 0))
goto done;
blkid_probe_enable_superblocks(blprobe, 1);
blkid_probe_set_superblocks_flags(blprobe,
BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID | BLKID_SUBLKS_TYPE);
if (blkid_do_safeprobe(blprobe))
goto done;
if (blkid_probe_lookup_value(blprobe, name, &data, NULL))
goto done;
done:
close(fd);
return data ? strdup((char *) data) : NULL;
}
static int check_partition_table(const char *device)
{
blkid_probe pr;
const char *value;
int ret;
pr = blkid_new_probe_from_filename(device);
if (!pr)
return -1;
ret = blkid_probe_enable_partitions(pr, 1);
if (ret < 0)
goto errout;
ret = blkid_probe_enable_superblocks(pr, 0);
if (ret < 0)
goto errout;
ret = blkid_do_fullprobe(pr);
if (ret < 0)
goto errout;
ret = blkid_probe_lookup_value(pr, "PTTYPE", &value, NULL);
if (ret == 0)
fprintf(stderr, _("Found a %s partition table in %s\n"),
value, device);
else
ret = 1;
errout:
blkid_free_probe(pr);
return ret;
}
gboolean type_by_device(const gchar* device, gchar** type) {
gboolean result = false;
const char *devtype = NULL;
blkid_probe probe = NULL;
*type = NULL;
probe = blkid_new_probe_from_filename(device);
if(!probe) {
LOG(MOD "Probe from filename failed!\n");
return false;
}
if (blkid_probe_enable_partitions(probe, true) != 0) {
LOG(MOD "Enable partitions failed!\n");
goto fail;
}
if (blkid_do_fullprobe(probe) != 0) {
LOG(MOD "Fullprobe failed!\n");
goto fail;
}
if (blkid_probe_lookup_value(probe, "TYPE", &devtype, NULL) != 0) {
LOG(MOD "Lookup value failed!\n");
goto fail;
}
*type = g_strdup(devtype);
result = true;
fail:
blkid_free_probe(probe);
return result;
}
/**
* mnt_get_fstype:
* @devname: device name
* @ambi: returns TRUE if probing result is ambivalent (optional argument)
* @cache: cache for results or NULL
*
* Returns: filesystem type or NULL in case of error. The result has to be
* deallocated by free() if @cache is NULL.
*/
char *mnt_get_fstype(const char *devname, int *ambi, struct libmnt_cache *cache)
{
blkid_probe pr;
const char *data;
char *type = NULL;
int rc;
DBG(CACHE, mnt_debug_h(cache, "get %s FS type", devname));
if (cache)
return mnt_cache_find_tag_value(cache, devname, "TYPE");
if (cache_get_probe(NULL, devname, &pr))
return NULL;
blkid_probe_enable_superblocks(pr, 1);
blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_TYPE);
rc = blkid_do_safeprobe(pr);
if (!rc && !blkid_probe_lookup_value(pr, "TYPE", &data, NULL))
type = strdup(data);
if (ambi)
*ambi = rc == -2 ? TRUE : FALSE;
blkid_free_probe(pr);
return type;
}
static char* get_uuid(char *device)
{
char path[PATH_MAX];
int fd;
blkid_probe pr = NULL;
uint64_t size;
const char *uuid;
char *ret;
if(!device || !strlen(device))
return NULL;
fd = open(device, O_RDONLY);
if (fd < 0)
return NULL;
pr = blkid_new_probe();
blkid_probe_set_request (pr, BLKID_PROBREQ_UUID);
ioctl(fd, BLKGETSIZE64, &size);
blkid_probe_set_device(pr, fd, 0, size);
blkid_do_safeprobe(pr);
blkid_probe_lookup_value(pr, "UUID", &uuid, NULL);
snprintf(path, PATH_MAX, "/dev/disk/by-uuid/%s", uuid);
ret = strdup(path);
blkid_free_probe(pr);
close(fd);
return ret;
}
static int probe_and_add_mount(
const char *id,
const char *what,
const char *where,
bool rw,
const char *description,
const char *post) {
_cleanup_blkid_free_probe_ blkid_probe b = NULL;
const char *fstype;
int r;
assert(id);
assert(what);
assert(where);
assert(description);
if (path_is_mount_point(where, true) <= 0 &&
dir_is_empty(where) <= 0) {
log_debug("%s already populated, ignoring.", where);
return 0;
}
/* Let's check the partition type here, so that we know
* whether to do LUKS magic. */
errno = 0;
b = blkid_new_probe_from_filename(what);
if (!b) {
if (errno == 0)
return log_oom();
log_error_errno(errno, "Failed to allocate prober: %m");
return -errno;
}
blkid_probe_enable_superblocks(b, 1);
blkid_probe_set_superblocks_flags(b, BLKID_SUBLKS_TYPE);
errno = 0;
r = blkid_do_safeprobe(b);
if (r == -2 || r == 1) /* no result or uncertain */
return 0;
else if (r != 0) {
if (errno == 0)
errno = EIO;
log_error_errno(errno, "Failed to probe %s: %m", what);
return -errno;
}
blkid_probe_lookup_value(b, "TYPE", &fstype, NULL);
return add_mount(
id,
what,
where,
fstype,
rw,
description,
post);
}
static char* get_blkid(char *device)
{
int fd;
blkid_probe pr = NULL;
uint64_t size;
const char *label;
char *ret;
char path[PATH_MAX];
if(!device || !strlen(device))
return NULL;
snprintf(path, PATH_MAX, "/dev/%s", device);
fd = open(path, O_RDONLY);
if(fd<0)
return NULL;
pr = blkid_new_probe ();
blkid_probe_set_request (pr, BLKID_PROBREQ_LABEL);
ioctl(fd, BLKGETSIZE64, &size);
blkid_probe_set_device (pr, fd, 0, size);
blkid_do_safeprobe (pr);
blkid_probe_lookup_value(pr, "LABEL", &label, NULL);
ret = strdup(label);
blkid_free_probe (pr);
close(fd);
return ret;
}
static int probe_superblocks(blkid_probe pr)
{
struct stat st;
int rc;
if (fstat(blkid_probe_get_fd(pr), &st))
return -1;
blkid_probe_enable_partitions(pr, 1);
if (!S_ISCHR(st.st_mode) &&
blkid_probe_get_size(pr) <= 1024 * 1440 &&
blkid_probe_is_wholedisk(pr)) {
/*
* check if the small disk is partitioned, if yes then
* don't probe for filesystems.
*/
blkid_probe_enable_superblocks(pr, 0);
rc = blkid_do_fullprobe(pr);
if (rc < 0)
return rc; /* -1 = error, 1 = nothing, 0 = success */
if (blkid_probe_lookup_value(pr, "PTTYPE", NULL, NULL) == 0)
return 0; /* partition table detected */
}
blkid_probe_set_partitions_flags(pr, BLKID_PARTS_ENTRY_DETAILS);
blkid_probe_enable_superblocks(pr, 1);
return blkid_do_safeprobe(pr);
}
/*
* This function prints a warning if the device is not wiped (e.g. wipefs(8).
* Please don't call this function if there is already a PT.
*
* Returns: 0 if nothing found, < 0 on error, 1 if found a signature
*/
static int warn_wipe(struct fdisk_context *cxt)
{
#ifdef HAVE_LIBBLKID
blkid_probe pr;
#endif
int rc = 0;
assert(cxt);
if (fdisk_dev_has_disklabel(cxt) || cxt->dev_fd < 0)
return -EINVAL;
#ifdef HAVE_LIBBLKID
DBG(LABEL, dbgprint("wipe check: initialize libblkid prober"));
pr = blkid_new_probe();
if (!pr)
return -ENOMEM;
rc = blkid_probe_set_device(pr, cxt->dev_fd, 0, 0);
if (rc)
return rc;
blkid_probe_enable_superblocks(pr, 1);
blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_TYPE);
blkid_probe_enable_partitions(pr, 1);
/* we care about the first found FS/raid, so don't call blkid_do_probe()
* in loop or don't use blkid_do_fullprobe() ... */
rc = blkid_do_probe(pr);
if (rc == 0) {
const char *name = NULL;
if (blkid_probe_lookup_value(pr, "TYPE", &name, 0) == 0 ||
blkid_probe_lookup_value(pr, "PTTYPE", &name, 0) == 0) {
fdisk_warnx(cxt, _(
"%s: device contains a valid '%s' signature, it's "
"strongly recommended to wipe the device by command wipefs(8) "
"if this setup is unexpected to avoid "
"possible collisions."), cxt->dev_path, name);
rc = 1;
}
}
blkid_free_probe(pr);
#endif
return rc;
}
/*
* This function prints a warning if the device is not wiped (e.g. wipefs(8).
* Please don't call this function if there is already a PT.
*
* Returns: 0 if nothing found, < 0 on error, 1 if found a signature
*/
static int check_collisions(struct fdisk_context *cxt)
{
#ifdef HAVE_LIBBLKID
int rc = 0;
blkid_probe pr;
assert(cxt);
assert(cxt->dev_fd >= 0);
DBG(CXT, ul_debugobj(cxt, "wipe check: initialize libblkid prober"));
pr = blkid_new_probe();
if (!pr)
return -ENOMEM;
rc = blkid_probe_set_device(pr, cxt->dev_fd, 0, 0);
if (rc)
return rc;
blkid_probe_enable_superblocks(pr, 1);
blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_TYPE);
blkid_probe_enable_partitions(pr, 1);
/* we care about the first found FS/raid, so don't call blkid_do_probe()
* in loop or don't use blkid_do_fullprobe() ... */
rc = blkid_do_probe(pr);
if (rc == 0) {
const char *name = NULL;
if (blkid_probe_lookup_value(pr, "TYPE", &name, 0) == 0 ||
blkid_probe_lookup_value(pr, "PTTYPE", &name, 0) == 0) {
cxt->collision = strdup(name);
if (!cxt->collision)
rc = -ENOMEM;
}
}
blkid_free_probe(pr);
return rc;
#else
return 0;
#endif
}
/*
* Compose and print ID_FS_AMBIVALENT for udev
*/
static int print_udev_ambivalent(blkid_probe pr)
{
char *val = NULL;
size_t valsz = 0;
int count = 0, rc = -1;
while (!blkid_do_probe(pr)) {
const char *usage = NULL, *type = NULL, *version = NULL;
char enc[256];
blkid_probe_lookup_value(pr, "USAGE", &usage, NULL);
blkid_probe_lookup_value(pr, "TYPE", &type, NULL);
blkid_probe_lookup_value(pr, "VERSION", &version, NULL);
if (!usage || !type)
continue;
blkid_encode_string(usage, enc, sizeof(enc));
if (append_str(&val, &valsz, enc, ":"))
goto done;
blkid_encode_string(type, enc, sizeof(enc));
if (append_str(&val, &valsz, enc, version ? ":" : " "))
goto done;
if (version) {
blkid_encode_string(version, enc, sizeof(enc));
if (append_str(&val, &valsz, enc, " "))
goto done;
}
count++;
}
if (count > 1) {
*(val + valsz - 1) = '\0'; /* rem tailing whitespace */
printf("ID_FS_AMBIVALEN=%s\n", val);
rc = 0;
}
done:
free(val);
return rc;
}
static struct wipe_desc *
get_offset_from_probe(struct wipe_desc *wp, blkid_probe pr, int zap)
{
const char *off, *type, *usage, *mag;
size_t len;
if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) == 0 &&
blkid_probe_lookup_value(pr, "SBMAGIC_OFFSET", &off, NULL) == 0 &&
blkid_probe_lookup_value(pr, "SBMAGIC", &mag, &len) == 0 &&
blkid_probe_lookup_value(pr, "USAGE", &usage, NULL) == 0) {
loff_t offset = strtoll(off, NULL, 10);
const char *p;
wp = add_offset(wp, offset, zap);
if (!wp)
return NULL;
wp->usage = xstrdup(usage);
wp->type = xstrdup(type);
wp->magic = xmalloc(len);
memcpy(wp->magic, mag, len);
wp->len = len;
if (blkid_probe_lookup_value(pr, "LABEL", &p, NULL) == 0)
wp->label = xstrdup(p);
if (blkid_probe_lookup_value(pr, "UUID", &p, NULL) == 0)
wp->uuid = xstrdup(p);
}
return wp;
}
static char * _get_uuid_from_device( const char * device )
{
char * r = NULL ;
const char * e = NULL ;
blkid_probe blkid = blkid_new_probe_from_filename( device ) ;
if( blkid != NULL ){
blkid_do_probe( blkid ) ;
blkid_probe_lookup_value( blkid,"UUID",&e,NULL ) ;
r = StringCopy_2( e ) ;
blkid_free_probe( blkid ) ;
}
return r ;
}
string_t zuluCryptGetFileSystemFromDevice( const char * device )
{
string_t st = StringVoid ;
const char * cf = NULL ;
blkid_probe blkid = blkid_new_probe_from_filename( device ) ;
if( blkid != NULL ){
blkid_do_probe( blkid ) ;
blkid_probe_lookup_value( blkid,"TYPE",&cf,NULL ) ;
st = String( cf ) ;
blkid_free_probe( blkid ) ;
}
return st ;
}
static int probe_filesystem(const char *node, char **ret_fstype) {
#ifdef HAVE_BLKID
_cleanup_blkid_free_probe_ blkid_probe b = NULL;
const char *fstype;
int r;
b = blkid_new_probe_from_filename(node);
if (!b)
return -ENOMEM;
blkid_probe_enable_superblocks(b, 1);
blkid_probe_set_superblocks_flags(b, BLKID_SUBLKS_TYPE);
errno = 0;
r = blkid_do_safeprobe(b);
if (r == -2 || r == 1) {
log_debug("Failed to identify any partition type on partition %s", node);
goto not_found;
}
if (r != 0) {
if (errno == 0)
return -EIO;
return -errno;
}
(void) blkid_probe_lookup_value(b, "TYPE", &fstype, NULL);
if (fstype) {
char *t;
t = strdup(fstype);
if (!t)
return -ENOMEM;
*ret_fstype = t;
return 1;
}
not_found:
*ret_fstype = NULL;
return 0;
#else
return -EOPNOTSUPP;
#endif
}
/*
* This function works like mnt_resolve_tag(), but it's able to read UUiD/LABEL
* from regular swap files too (according to entries in /proc/swaps). Note that
* mnt_resolve_tag() and mnt_resolve_spec() works with system visible block
* devices only.
*/
static char *swapoff_resolve_tag(const char *name, const char *value,
struct libmnt_cache *cache)
{
char *path;
struct libmnt_table *tb;
struct libmnt_iter *itr;
struct libmnt_fs *fs;
/* this is usual case for block devices (and it's really fast as it uses
* udev /dev/disk/by-* symlinks by default */
path = mnt_resolve_tag(name, value, cache);
if (path)
return path;
/* try regular files from /proc/swaps */
tb = get_swaps();
if (!tb)
return NULL;
itr = mnt_new_iter(MNT_ITER_BACKWARD);
if (!itr)
err(EXIT_FAILURE, _("failed to initialize libmount iterator"));
while (tb && mnt_table_next_fs(tb, itr, &fs) == 0) {
blkid_probe pr = NULL;
const char *src = mnt_fs_get_source(fs);
const char *type = mnt_fs_get_swaptype(fs);
const char *data = NULL;
if (!src || !type || strcmp(type, "file") != 0)
continue;
pr = get_swap_prober(src);
if (!pr)
continue;
blkid_probe_lookup_value(pr, name, &data, NULL);
if (data && strcmp(data, value) == 0)
path = xstrdup(src);
blkid_free_probe(pr);
if (path)
break;
}
mnt_free_iter(itr);
return path;
}
static inline void probe_filesystem(struct format *target)
{
blkid_probe probe = 0;
static char *filesystems[] =
{
"ext2",
"ext3",
"ext4",
"reiserfs",
"jfs",
"xfs",
"btrfs",
"swap",
0
};
const char *filesystem = "unknown";
const char *result = 0;
if((probe = blkid_new_probe_from_filename(target->devicepath)) == 0)
goto bail;
if(blkid_probe_enable_superblocks(probe,true) == -1)
goto bail;
if(blkid_probe_filter_superblocks_type(probe,BLKID_FLTR_ONLYIN,filesystems) == -1)
goto bail;
if(blkid_probe_set_superblocks_flags(probe,BLKID_SUBLKS_TYPE) == -1)
goto bail;
if(blkid_do_probe(probe) == -1)
goto bail;
if(blkid_probe_lookup_value(probe,"TYPE",&result,0) == -1)
goto bail;
filesystem = result;
bail:
if(probe != 0)
blkid_free_probe(probe);
target->filesystem = strdup(filesystem);
}
int zuluCryptFileSystemIsFUSEbased( const char * device )
{
const char * cf = NULL ;
int st ;
blkid_probe blkid = blkid_new_probe_from_filename( device ) ;
if( blkid != NULL ){
blkid_do_probe( blkid ) ;
blkid_probe_lookup_value( blkid,"TYPE",&cf,NULL ) ;
#if 1
st = StringAtLeastOneMatch_1( cf,"ntfs","exfat",NULL ) ;
#else
st = StringAtLeastOneMatch_1( cf,"ntfs",NULL ) ;
#endif
blkid_free_probe( blkid ) ;
return st ;
}else{
return 0 ;
}
}
/*
* Returns new libblkid prober. This function call exit() on error.
*/
static blkid_probe get_swap_prober(const char *devname)
{
blkid_probe pr;
int rc;
const char *version = NULL;
char *swap_filter[] = { "swap", NULL };
pr = blkid_new_probe_from_filename(devname);
if (!pr) {
warn(_("%s: unable to probe device"), devname);
return NULL;
}
blkid_probe_enable_superblocks(pr, TRUE);
blkid_probe_set_superblocks_flags(pr,
BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID |
BLKID_SUBLKS_VERSION);
blkid_probe_filter_superblocks_type(pr, BLKID_FLTR_ONLYIN, swap_filter);
rc = blkid_do_safeprobe(pr);
if (rc == -1)
warn(_("%s: unable to probe device"), devname);
else if (rc == -2)
warnx(_("%s: ambivalent probing result, use wipefs(8)"), devname);
else if (rc == 1)
warnx(_("%s: not a valid swap partition"), devname);
if (rc == 0) {
/* supported is SWAPSPACE2 only */
if (blkid_probe_lookup_value(pr, "VERSION", &version, NULL) == 0
&& version
&& strcmp(version, "2"))
warnx(_("%s: unsupported swap version '%s'"),
devname, version);
else
return pr;
}
blkid_free_probe(pr);
return NULL;
}
/* returns zero when the device has NAME=value (LABEL/UUID) */
static int verify_tag(const char *devname, const char *name, const char *value)
{
blkid_probe pr;
int fd = -1, rc = -1;
size_t len;
const char *data;
int errsv = 0;
pr = blkid_new_probe();
if (!pr)
return -1;
blkid_probe_enable_superblocks(pr, TRUE);
blkid_probe_set_superblocks_flags(pr,
BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID);
blkid_probe_enable_partitions(pr, TRUE);
blkid_probe_set_partitions_flags(pr, BLKID_PARTS_ENTRY_DETAILS);
fd = open(devname, O_RDONLY|O_CLOEXEC);
if (fd < 0) {
errsv = errno;
goto done;
}
if (blkid_probe_set_device(pr, fd, 0, 0))
goto done;
rc = blkid_do_safeprobe(pr);
if (rc)
goto done;
rc = blkid_probe_lookup_value(pr, name, &data, &len);
if (!rc)
rc = memcmp(value, data, len);
done:
DBG(EVALUATE, ul_debug("%s: %s verification %s",
devname, name, rc == 0 ? "PASS" : "FAILED"));
if (fd >= 0)
close(fd);
blkid_free_probe(pr);
/* for non-root users we use unverified udev links */
return errsv == EACCES ? 0 : rc;
}
/**
* mnt_get_fstype:
* @devname: device name
* @ambi: returns TRUE if probing result is ambivalent (optional argument)
* @cache: cache for results or NULL
*
* Returns: filesystem type or NULL in case of error. The result has to be
* deallocated by free() if @cache is NULL.
*/
char *mnt_get_fstype(const char *devname, int *ambi, struct libmnt_cache *cache)
{
blkid_probe pr;
const char *data;
char *type = NULL;
int rc;
DBG(CACHE, ul_debugobj(cache, "get %s FS type", devname));
if (cache) {
char *val = NULL;
rc = __mnt_cache_find_tag_value(cache, devname, "TYPE", &val);
if (ambi)
*ambi = rc == -2 ? TRUE : FALSE;
return rc ? NULL : val;
}
/*
* no cache, probe directly
*/
pr = blkid_new_probe_from_filename(devname);
if (!pr)
return NULL;
blkid_probe_enable_superblocks(pr, 1);
blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_TYPE);
rc = blkid_do_safeprobe(pr);
DBG(CACHE, ul_debugobj(cache, "libblkid rc=%d", rc));
if (!rc && !blkid_probe_lookup_value(pr, "TYPE", &data, NULL))
type = strdup(data);
if (ambi)
*ambi = rc == -2 ? TRUE : FALSE;
blkid_free_probe(pr);
return type;
}
static struct wipe_desc *
read_offsets(struct wipe_desc *wp, const char *fname, int zap)
{
blkid_probe pr;
int rc;
if (!fname)
return NULL;
pr = blkid_new_probe_from_filename(fname);
if (!pr)
errx(EXIT_FAILURE, _("error: %s: probing initialization failed"), fname);
blkid_probe_enable_superblocks(pr, 0); /* enabled by default ;-( */
blkid_probe_enable_partitions(pr, 1);
rc = blkid_do_fullprobe(pr);
blkid_probe_enable_partitions(pr, 0);
if (rc == 0) {
const char *type = NULL;
blkid_probe_lookup_value(pr, "PTTYPE", &type, NULL);
warnx(_("WARNING: %s: appears to contain '%s' "
"partition table"), fname, type);
}
blkid_probe_enable_superblocks(pr, 1);
blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_MAGIC |
BLKID_SUBLKS_TYPE | BLKID_SUBLKS_USAGE |
BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID);
while (blkid_do_probe(pr) == 0) {
wp = get_offset_from_probe(wp, pr, zap);
if (!wp)
break;
}
blkid_free_probe(pr);
return wp;
}
void zuluCryptFileSystemProperties( string_t p,const char * mapper,const char * m_point )
{
const char * e ;
blkid_probe blkid ;
struct statvfs vfs ;
u_int64_t total ;
u_int64_t used ;
u_int64_t unused ;
u_int64_t block_size ;
char buff[ SIZE ] ;
char * buffer = buff ;
string_t q ;
ssize_t index ;
struct stat statstr ;
blkid = blkid_new_probe_from_filename( mapper ) ;
if( blkid == NULL ){
return ;
}
blkid_do_probe( blkid ) ;
if( blkid_probe_lookup_value( blkid,"TYPE",&e,NULL ) == 0 ){
StringMultipleAppend( p,"\n file system:\t",e,NULL ) ;
}else{
StringAppend( p,"\n file system:\tNil" ) ;
}
blkid_free_probe( blkid ) ;
if( statvfs( m_point,&vfs ) != 0 ){
return ;
}
block_size = vfs.f_frsize ;
total = block_size * vfs.f_blocks ;
unused = block_size * vfs.f_bavail ;
used = total - unused ;
zuluCryptFormatSize( total,buffer,SIZE ) ;
StringMultipleAppend( p,"\n total space:\t",buffer,NULL ) ;
zuluCryptFormatSize( used,buffer,SIZE ) ;
StringMultipleAppend( p,"\n used space:\t",buffer,NULL ) ;
zuluCryptFormatSize( unused,buffer,SIZE ) ;
StringMultipleAppend( p,"\n free space:\t",buffer,NULL ) ;
if( used == total ){
StringAppend( p,"\n used%: \t100%\n" ) ;
}else if( used == 0 ){
StringAppend( p,"\n used%: \t0%\n" ) ;
}else{
snprintf( buff,SIZE,"%.2f%%",100 * ( ( float ) used / ( float ) total ) ) ;
StringMultipleAppend( p,"\n used%: \t",buff,"\n",NULL ) ;
}
buffer = zuluCryptGetUUIDFromMapper( mapper ) ;
StringAppend( p,buffer ) ;
StringFree( buffer ) ;
StringMultipleAppend( p,"\n mount point1:\t",m_point,NULL ) ;
q = String( m_point ) ;
index = StringLastIndexOfChar( q,'/' ) ;
if( index == -1 ){
StringAppend( p,"\n mount point2:\tNil" ) ;
}else{
StringRemoveLeft( q,index ) ;
e = StringPrepend( q,"/run/media/public" ) ;
if( stat( e,&statstr ) == 0 ){
StringMultipleAppend( p,"\n mount point2:\t",e,NULL ) ;
}else{
StringAppend( p,"\n mount point2:\tNil" ) ;
}
}
StringDelete( &q ) ;
}
/**
* mnt_cache_read_tags
* @cache: pointer to struct libmnt_cache instance
* @devname: path device
*
* Reads @devname LABEL and UUID to the @cache.
*
* Returns: 0 if at least one tag was added, 1 if no tag was added or
* negative number in case of error.
*/
int mnt_cache_read_tags(struct libmnt_cache *cache, const char *devname)
{
blkid_probe pr;
size_t i, ntags = 0;
int rc;
const char *tags[] = { "LABEL", "UUID", "TYPE", "PARTUUID", "PARTLABEL" };
const char *blktags[] = { "LABEL", "UUID", "TYPE", "PART_ENTRY_UUID", "PART_ENTRY_NAME" };
if (!cache || !devname)
return -EINVAL;
DBG(CACHE, ul_debugobj(cache, "tags for %s requested", devname));
/* check if device is already cached */
for (i = 0; i < cache->nents; i++) {
struct mnt_cache_entry *e = &cache->ents[i];
if (!(e->flag & MNT_CACHE_TAGREAD))
continue;
if (strcmp(e->value, devname) == 0)
/* tags have already been read */
return 0;
}
pr = blkid_new_probe_from_filename(devname);
if (!pr)
return -1;
blkid_probe_enable_superblocks(pr, 1);
blkid_probe_set_superblocks_flags(pr,
BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID |
BLKID_SUBLKS_TYPE);
blkid_probe_enable_partitions(pr, 1);
blkid_probe_set_partitions_flags(pr, BLKID_PARTS_ENTRY_DETAILS);
rc = blkid_do_safeprobe(pr);
if (rc)
goto error;
DBG(CACHE, ul_debugobj(cache, "reading tags for: %s", devname));
for (i = 0; i < ARRAY_SIZE(tags); i++) {
const char *data;
char *dev;
if (cache_find_tag_value(cache, devname, tags[i])) {
DBG(CACHE, ul_debugobj(cache,
"\ntag %s already cached", tags[i]));
continue;
}
if (blkid_probe_lookup_value(pr, blktags[i], &data, NULL))
continue;
dev = strdup(devname);
if (!dev)
goto error;
if (cache_add_tag(cache, tags[i], data, dev,
MNT_CACHE_TAGREAD)) {
free(dev);
goto error;
}
ntags++;
}
DBG(CACHE, ul_debugobj(cache, "\tread %zd tags", ntags));
blkid_free_probe(pr);
return ntags ? 0 : 1;
error:
blkid_free_probe(pr);
return rc < 0 ? rc : -1;
}
/**
* mnt_cache_read_tags
* @cache: pointer to struct libmnt_cache instance
* @devname: path device
*
* Reads @devname LABEL and UUID to the @cache.
*
* Returns: 0 if at least one tag was added, 1 if no tag was added or
* negative number in case of error.
*/
int mnt_cache_read_tags(struct libmnt_cache *cache, const char *devname)
{
size_t i, ntags = 0;
int rc;
const char *tags[] = { "LABEL", "UUID", "TYPE" };
assert(cache);
assert(devname);
if (!cache || !devname)
return -EINVAL;
DBG(CACHE, mnt_debug_h(cache, "tags for %s requested", devname));
/* check is device is already cached */
for (i = 0; i < cache->nents; i++) {
struct mnt_cache_entry *e = &cache->ents[i];
if (!(e->flag & MNT_CACHE_TAGREAD))
continue;
if (strcmp(e->value, devname) == 0)
/* tags has been already read */
return 0;
}
rc = cache_get_probe(cache, devname, NULL);
if (rc)
return rc;
blkid_probe_enable_superblocks(cache->pr, 1);
blkid_probe_set_superblocks_flags(cache->pr,
BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID |
BLKID_SUBLKS_TYPE);
if (blkid_do_safeprobe(cache->pr))
goto error;
DBG(CACHE, mnt_debug_h(cache, "reading tags for: %s", devname));
for (i = 0; i < ARRAY_SIZE(tags); i++) {
const char *data;
char *dev;
if (cache_find_tag_value(cache, devname, tags[i])) {
DBG(CACHE, mnt_debug_h(cache,
"\ntag %s already cached", tags[i]));
continue;
}
if (blkid_probe_lookup_value(cache->pr, tags[i], &data, NULL))
continue;
dev = strdup(devname);
if (!dev)
goto error;
if (cache_add_tag(cache, tags[i], data, dev,
MNT_CACHE_TAGREAD)) {
free(dev);
goto error;
}
ntags++;
}
DBG(CACHE, mnt_debug_h(cache, "\tread %zd tags", ntags));
return ntags ? 0 : 1;
error:
return -1;
}
static virStoragePoolProbeResult
virStorageBackendFileSystemProbe(const char *device,
const char *format) {
virStoragePoolProbeResult ret = FILESYSTEM_PROBE_ERROR;
blkid_probe probe = NULL;
const char *fstype = NULL;
char *names[2], *libblkid_format = NULL;
VIR_DEBUG("Probing for existing filesystem of type %s on device %s",
format, device);
if (blkid_known_fstype(format) == 0) {
virStorageReportError(VIR_ERR_STORAGE_PROBE_FAILED,
_("Not capable of probing for "
"filesystem of type %s"),
format);
goto error;
}
probe = blkid_new_probe_from_filename(device);
if (probe == NULL) {
virStorageReportError(VIR_ERR_STORAGE_PROBE_FAILED,
_("Failed to create filesystem probe "
"for device %s"),
device);
goto error;
}
if ((libblkid_format = strdup(format)) == NULL) {
virReportOOMError();
goto error;
}
names[0] = libblkid_format;
names[1] = NULL;
blkid_probe_filter_superblocks_type(probe,
BLKID_FLTR_ONLYIN,
names);
if (blkid_do_probe(probe) != 0) {
VIR_INFO("No filesystem of type '%s' found on device '%s'",
format, device);
ret = FILESYSTEM_PROBE_NOT_FOUND;
} else if (blkid_probe_lookup_value(probe, "TYPE", &fstype, NULL) == 0) {
virStorageReportError(VIR_ERR_STORAGE_POOL_BUILT,
_("Existing filesystem of type '%s' found on "
"device '%s'"),
fstype, device);
ret = FILESYSTEM_PROBE_FOUND;
}
if (blkid_do_probe(probe) != 1) {
virStorageReportError(VIR_ERR_STORAGE_PROBE_FAILED,
_("Found additional probes to run, "
"filesystem probing may be incorrect"));
ret = FILESYSTEM_PROBE_ERROR;
}
error:
VIR_FREE(libblkid_format);
if (probe != NULL) {
blkid_free_probe(probe);
}
return ret;
}
static void
wipe_device(int fd, const char *devname, int force)
{
char *type = NULL;
int zap = 1;
#ifdef HAVE_LIBBLKID
blkid_probe pr = NULL;
#endif
if (!force) {
if (lseek(fd, 0, SEEK_SET) != 0)
errx(EXIT_FAILURE, _("unable to rewind swap-device"));
#ifdef HAVE_LIBBLKID
pr = new_prober(fd);
blkid_probe_enable_partitions(pr, 1);
blkid_probe_enable_superblocks(pr, 0);
if (blkid_do_fullprobe(pr) == 0 &&
blkid_probe_lookup_value(pr, "PTTYPE",
(const char **) &type, NULL) == 0 && type) {
type = xstrdup(type);
zap = 0;
}
#else
/* don't zap if compiled without libblkid */
zap = 0;
#endif
}
if (zap) {
/*
* Wipe boodbits
*/
char buf[1024];
const char *data = NULL;
if (lseek(fd, 0, SEEK_SET) != 0)
errx(EXIT_FAILURE, _("unable to rewind swap-device"));
memset(buf, 0, sizeof(buf));
if (write_all(fd, buf, sizeof(buf)))
errx(EXIT_FAILURE, _("unable to erase bootbits sectors"));
#ifdef HAVE_LIBBLKID
/*
* Wipe rest of the device
*/
if (!pr)
pr = new_prober(fd);
blkid_probe_enable_superblocks(pr, 1);
blkid_probe_enable_partitions(pr, 0);
blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_MAGIC|BLKID_SUBLKS_TYPE);
while (blkid_do_probe(pr) == 0) {
if (blkid_probe_lookup_value(pr, "TYPE", &data, NULL) == 0 && data)
warnx(_("%s: warning: wiping old %s signature."), devname, data);
blkid_do_wipe(pr, 0);
}
#endif
} else {
warnx(_("%s: warning: don't erase bootbits sectors"),
devname);
if (type)
fprintf(stderr, _(" (%s partition table detected). "), type);
else
fprintf(stderr, _(" (compiled without libblkid). "));
fprintf(stderr, _("Use -f to force.\n"));
}
#ifdef HAVE_LIBBLKID
blkid_free_probe(pr);
#endif
}