int main(int argc, char *argv[])
{
int i, nparts;
char *devname;
blkid_probe pr;
blkid_partlist ls;
blkid_parttable root_tab;
if (argc < 2) {
fprintf(stderr, "usage: %s <device|file> "
"-- prints partitions\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);
/* Binary interface */
ls = blkid_probe_get_partitions(pr);
if (!ls)
errx(EXIT_FAILURE, "%s: failed to read partitions\n", devname);
/*
* Print info about the primary (root) partition table
*/
root_tab = blkid_partlist_get_table(ls);
if (!root_tab)
errx(EXIT_FAILURE, "%s: does not contains any "
"known partition table\n", devname);
printf("size: %jd, sector size: %u, PT: %s, offset: %jd\n---\n",
blkid_probe_get_size(pr),
blkid_probe_get_sectorsize(pr),
blkid_parttable_get_type(root_tab),
blkid_parttable_get_offset(root_tab));
/*
* List partitions
*/
nparts = blkid_partlist_numof_partitions(ls);
if (!nparts)
goto done;
for (i = 0; i < nparts; i++) {
const char *p;
blkid_partition par = blkid_partlist_get_partition(ls, i);
blkid_parttable tab = blkid_partition_get_table(par);
printf("#%d: %10llu %10llu 0x%x",
blkid_partition_get_partno(par),
(unsigned long long) blkid_partition_get_start(par),
(unsigned long long) blkid_partition_get_size(par),
blkid_partition_get_type(par));
if (root_tab != tab)
/* subpartition (BSD, Minix, ...) */
printf(" (%s)", blkid_parttable_get_type(tab));
p = blkid_partition_get_name(par);
if (p)
printf(" name='%s'", p);
p = blkid_partition_get_uuid(par);
if (p)
printf(" uuid='%s'", p);
p = blkid_partition_get_type_string(par);
if (p)
printf(" type='%s'", p);
putc('\n', stdout);
}
done:
blkid_free_probe(pr);
return EXIT_SUCCESS;
}
static int find_gpt_root(struct udev_device *dev, blkid_probe pr, bool test) {
#if defined(GPT_ROOT_NATIVE) && defined(ENABLE_EFI)
_cleanup_free_ char *root_id = NULL;
bool found_esp = false;
blkid_partlist pl;
int i, nvals, r;
assert(pr);
/* Iterate through the partitions on this disk, and see if the
* EFI ESP we booted from is on it. If so, find the first root
* disk, and add a property indicating its partition UUID. */
errno = 0;
pl = blkid_probe_get_partitions(pr);
if (!pl)
return errno ? -errno : -ENOMEM;
nvals = blkid_partlist_numof_partitions(pl);
for (i = 0; i < nvals; i++) {
blkid_partition pp;
const char *stype, *sid;
sd_id128_t type;
pp = blkid_partlist_get_partition(pl, i);
if (!pp)
continue;
sid = blkid_partition_get_uuid(pp);
if (!sid)
continue;
stype = blkid_partition_get_type_string(pp);
if (!stype)
continue;
if (sd_id128_from_string(stype, &type) < 0)
continue;
if (sd_id128_equal(type, GPT_ESP)) {
sd_id128_t id, esp;
/* We found an ESP, let's see if it matches
* the ESP we booted from. */
if (sd_id128_from_string(sid, &id) < 0)
continue;
r = efi_loader_get_device_part_uuid(&esp);
if (r < 0)
return r;
if (sd_id128_equal(id, esp))
found_esp = true;
} else if (sd_id128_equal(type, GPT_ROOT_NATIVE)) {
/* We found a suitable root partition, let's
* remember the first one. */
if (!root_id) {
root_id = strdup(sid);
if (!root_id)
return -ENOMEM;
}
}
}
/* We found the ESP on this disk, and also found a root
* partition, nice! Let's export its UUID */
if (found_esp && root_id)
udev_builtin_add_property(dev, test, "ID_PART_GPT_AUTO_ROOT_UUID", root_id);
#endif
return 0;
}
int mountdevice(const char *devnode){
/*Using device's MBR information to retrieve partitions and its types
* to mount it correctly*/
blkid_probe pr; /*BLKID probe struct*/
blkid_partlist pl; /*BLKID partitions list*/
int nparts, i;
char *pname = (char*)malloc(32 * sizeof(char));
char *mountpoint = (char*)malloc(128 * sizeof(char));
pr = blkid_new_probe_from_filename(devnode); /*Starts blkid probe*/
if (!pr){
fprintf(stderr, "Error on opening device: %s - %s\n", devnode, strerror(errno));
return -1;
}
if (!pname || !mountpoint){
fprintf(stderr, "Not able to allocate memory, will not mount anything\n");
return -1;
}
pl = blkid_probe_get_partitions(pr); /*Getting partition list*/
nparts = blkid_partlist_numof_partitions(pl); /*Getting the number of partitions*/
for (i = 0; i < nparts; i++){
char *pnametmp; /*temp variable to be tokenized by udev_get_partition*/
char *ptype, *cmd;
int t_part, partno, mstatus;
struct stat st = {0};
blkid_partition part = blkid_partlist_get_partition(pl, i);
t_part = blkid_partition_get_type(part);
partno = blkid_partition_get_partno(part);
fprintf(stdout, "Partition: %d, type: 0x%x\n", partno, t_part);
sprintf(pname, "%s%d", devnode, partno);
pnametmp = (char*)malloc(strlen(pname) * sizeof(char));
if (!pnametmp){
fprintf(stderr, "Could not allocate memory, will not mount anything\n");
return -1;
}
strcpy(pnametmp, pname);
sprintf(mountpoint, "/media/USBSTICK%s", udev_get_partition(pnametmp));
/*Freeing temporary variable*/
free(pnametmp);
fprintf(stdout, "Preparing to mount: %s\n", pname);
if (stat(mountpoint, &st) == -1){
fprintf(stdout, "Creating dir: %s\n", mountpoint);
/*create a new dir*/
if(mkdir(mountpoint, 0777) == -1){
fprintf(stderr, "Unable to create: %s. Error: %s\n", mountpoint, strerror(errno));
return -1;
}else{
fprintf(stdout, "%s create successfully.\n", mountpoint);
}
}
fprintf(stdout, "Mounting %s on %s\n", pname, mountpoint);
ptype = getpartitiontype(t_part);
mstatus = mount(pname, mountpoint, ptype, MS_SYNCHRONOUS, "");
if (mstatus == -1){
cmd = (char*)malloc(SLENGHT * sizeof(char));
fprintf(stderr, "Error mounting [%s]: %s\n", pname, strerror(errno));
sprintf(cmd, "DISPLAY=:0 zenity --notification --text\"Não foi possivel montar\
%s\" --timeout=2", pname);
if(fork() == 0)
system(cmd);
else
wait(NULL);
free(cmd);
return -1;
}else{
