Пример #1
0
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;
}
Пример #3
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{