Попытка смонтировать раздел USB в Linux с помощью программы cpp

Я хочу обнаружить USB-соединение и смонтировать соответствующий раздел.
Я попытался использовать udev.I смог найти устройство в / dev / bus / usb / 001 или / 002. Но из-за этого я не могу найти, какой раздел он использует. Поэтому, используя udev, я искал блочные разделы и монтировал их, если раздел добавлен … например, / dev / sda1. Но это временное решение.
Что я хочу, так это обнаружить USB-соединение, используя udev или что-то в этом роде, найти какой раздел у него и смонтировать его.

Мой код:

#include <libudev.h>
#include <stdio.h>
#include "dmutil.h"#include <pthread.h>

#include <unistd.h>

/*
Thread which detects devices.
*/
void *  udev_listener(void * i)
{

struct udev *udev;
udev = udev_new();
if (!udev) {
printf("Can't create udev\n");
exit(1);
}

std::string mount_path_for_udev_listner = DEFAULT_MOUNT_PATH;
printf("\n\n **********\nUdev_listner is asked to mount usb to %s ....",mount_path_for_udev_listner.c_str());

struct udev_device *dev;
struct udev_monitor *mon;
mon = udev_monitor_new_from_netlink(udev, "udev");
assert(mon != NULL);
/*  int udev_monitor_filter_add_match_subsystem_devtype(struct udev_monitor *udev_monitor,const char *subsystem, const char *devtype);
filters to select messages that get delivered to a listener.
On Success it returns an integer greater than, or equal to, 0. On failure, a negative error code is returned.
*/
assert(udev_monitor_filter_add_match_subsystem_devtype(mon, "block", NULL) >=0);
udev_monitor_enable_receiving(mon);
/* Get the file descriptor (fd) for the monitor.
This fd will get passed to select() */

int fd = udev_monitor_get_fd(mon);
/* Begin polling for udev events. Events occur when devices attached to the system are added, removed, or change state.
udev_monitor_receive_device() will return a device object representing the device which changed and what type of change occured.

The select() system call is used to ensure that the call to udev_monitor_receive_device() will not block.

This section will run continuously, calling usleep() at the end of each pass. This is to  use  udev_monitor in a non-blocking way. */
while (1)
{
/*
int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);

select()  allows  a  program  to  monitor  multiple  file descriptors,  waiting  until one or more of the file descriptors
become "ready" for some class of I/O operation.

Set up the call to select(). In this case, select() will only operate on a single file descriptor, the one associated
with our udev_monitor. Note that the timeval object is set to 0, which will cause select() to not block. */
fd_set fds;
struct timeval tv;
int ret;

FD_ZERO(&fds); //clear fds
FD_SET(fd, &fds);// Add fd to fds
/*
The timeout argument specifies the interval that select() should block waiting for a file descriptor to become ready.
This interval will be rounded up to the system  clock  granularity, and kernel scheduling delays mean that the
blocking interval may overrun by a small amount.  If both fields of the timeval structure are zero, then select()
returns immediately. (This is useful for polling.)If timeout is NULL (no timeout), select() can block indefinitely.
*/
tv.tv_sec = 0;
tv.tv_usec = 0;
/*
nfds specifies how big the list of file descriptors is because the total number can be vast.
So, if you want to monitor file descriptors 24-31, you'd set nfds to 32.
man - nfds is the highest-numbered file descriptor in any of the three sets, plus 1.
*/
ret = select(fd+1, &fds, NULL, NULL, &tv);

/* Check if our file descriptor has received data. */
if (ret > 0 && FD_ISSET(fd, &fds)) {
printf("\nselect() says there should be data\n");

/* Make the call to receive the device.
select() ensured that this will not block. */
dev = udev_monitor_receive_device(mon);
if (dev) {
printf("Got Device\n");
printf("   Node: %s\n", udev_device_get_devnode(dev));
printf("   Subsystem: %s\n", udev_device_get_subsystem(dev));
printf("   Devtype: %s\n", udev_device_get_devtype(dev));
printf("   syspath:%s\n",udev_device_get_syspath(dev));
printf("   sysname:%s\n",udev_device_get_sysname(dev));
printf("   devpath:%s\n",udev_device_get_devpath(dev));
printf("   subsystem:%s\n",udev_device_get_subsystem(dev));
printf("   Action: %s\n", udev_device_get_action(dev));
std::string devtype=udev_device_get_devtype(dev);
std::string action=udev_device_get_action(dev);
std::string devnode=udev_device_get_devnode(dev);
if(devtype.compare("partition")==0 && action.compare("add") == 0)
{
printf("A new partition detected at %s\nTrying to mount to %s",devnode.c_str(),mount_path_for_udev_listner.c_str());
int ret = mount_disk(devnode,mount_path_for_udev_listner);
if(ret == 0)
{
printf("\nSystem returns %d, Mounting success\n",ret);
}
else{
printf("\n*****Error no %d\n",errno);
}
}
if(devtype.compare("partition")==0 && action.compare("remove") == 0)
{
printf("Partition removal detected, trying to unmount...\n");
int ret=umount_disk();
if(ret==0){
printf("\nSystem returns %d\n",ret);
printf("unmount successfull\n");
}
else{
printf("\nThe partition unmounting FAILED:\n ");
}
}
udev_device_unref(dev);
}
else {
printf("No Device from receive_device(). An error occured.\n");
}
}
usleep(250*1000);
printf(".");
fflush(stdout);
}
pthread_exit(NULL);
}