A c++；linux下获取usb闪存设备文件目录的程序 我一直在寻找几个例子（在这一页和其他）中，如何获得USB闪存路径文件夹（类似的/媒体/ John/B5D6 DC71]，以便使C++程序在这个设备上保存文件。我的意思是，我希望程序检测到一个新设备，并获取其文件夹路径，以便（如我所说）在其上保存文件

我用libudev库找到了一个很好的方法，我对它做了一些修改，代码做了我想要的一切，除了给出路径。它给了我很多属性和函数，我可以在这里找到：。但是我没有找到我想要的。。。也许它在那里，但我犯了一个错误，也许它不在那里

有人能帮我吗？ 以下是我使用的代码：

#include <libudev.h>
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <unistd.h>
#include <string.h>
#include <iostream>

using namespace std;

static
struct udev_device*
get_child(struct udev* udev, struct udev_device* parent, const char* subsystem) {
  struct udev_device* child = NULL;
  struct udev_enumerate *enumerate = udev_enumerate_new(udev);

  udev_enumerate_add_match_parent(enumerate, parent);
  udev_enumerate_add_match_subsystem(enumerate, subsystem);
  udev_enumerate_scan_devices(enumerate);

  struct udev_list_entry *devices = udev_enumerate_get_list_entry(enumerate);
  struct udev_list_entry *entry;

  udev_list_entry_foreach(entry, devices) {
      const char *path = udev_list_entry_get_name(entry);
      child = udev_device_new_from_syspath(udev, path);
      break;
  }

  udev_enumerate_unref(enumerate);
  return child;
}

static void enumerate_usb_mass_storage(struct udev* udev) {
  struct udev_enumerate* enumerate = udev_enumerate_new(udev);

  udev_enumerate_add_match_subsystem(enumerate, "scsi");
  udev_enumerate_add_match_property(enumerate, "DEVTYPE", "scsi_device");
  udev_enumerate_scan_devices(enumerate);

  struct udev_list_entry *devices = udev_enumerate_get_list_entry(enumerate);
  struct udev_list_entry *entry;

  udev_list_entry_foreach(entry, devices) {
      const char* path = udev_list_entry_get_name(entry);
      struct udev_device* scsi = udev_device_new_from_syspath(udev, path);

      struct udev_device* block = get_child(udev, scsi, "block");
      struct udev_device* scsi_disk = get_child(udev, scsi, "scsi_disk");

      struct udev_device* usb
          = udev_device_get_parent_with_subsystem_devtype(scsi, "usb", "usb_device");

      if (block && scsi_disk && usb) {
          printf("block = %s, usb = %s:%s, scsi = %s, name = %s, size = %s, x = %i, x = %s, x = %s\n",
                 udev_device_get_devnode(block),
                 udev_device_get_sysattr_value(usb, "idVendor"),
                 udev_device_get_sysattr_value(usb, "idProduct"),
                 udev_device_get_sysattr_value(scsi, "vendor"),
udev_device_get_sysattr_value(usb, "udev"),
udev_device_get_sysattr_value(usb, "udev_root"),
udev_device_get_sysattr_value(usb, "size"),
udev_device_get_sysattr_value(usb, "speed"),
udev_device_get_sysattr_value(usb, "bMaxPower"));

      }

      if (block) {
          udev_device_unref(block);
      }

      if (scsi_disk) {
          udev_device_unref(scsi_disk);
      }
      udev_device_unref(scsi);
  }

  udev_enumerate_unref(enumerate);
}

int main(){


    struct udev* udev = udev_new();
    enumerate_usb_mass_storage(udev);


    struct udev_device *dev;
    struct udev_monitor *mon;
    int fd;

    mon = udev_monitor_new_from_netlink(udev, "udev");
    udev_monitor_filter_add_match_subsystem_devtype(mon, "block", NULL);
    udev_monitor_enable_receiving(mon);
    fd = udev_monitor_get_fd(mon);

    while (1) {

        fd_set fds;
        struct timeval tv;
        int ret;

        FD_ZERO(&fds);
        FD_SET(fd, &fds);
        tv.tv_sec = 0;
        tv.tv_usec = 0;

        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");

            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("   Action: %s\n", udev_device_get_action(dev));
                cout << udev_get_run_path (dev) << endl;

                if( strcmp(udev_device_get_action(dev),"add")==0 ) cout << "conectat" << endl; 
                udev_device_unref(dev);
            }
            else {
                printf("No Device from receive_device(). An error occured.\n");
            }                   
        }
        usleep(250*1000);
        fflush(stdout);
    }




  udev_unref(udev);
  return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
静止的
结构udev_设备*
获取子项（结构udev*udev，结构udev\u设备*父项，常量字符*子系统）{
struct udev_device*child=NULL；
结构udev_enumerate*enumerate=udev_enumerate_new（udev）；
udev\u枚举\u添加\u匹配\u父项（枚举，父项）；
udev_枚举_添加_匹配_子系统（枚举，子系统）；
udev_枚举扫描_设备（枚举）；
struct udev_list_entry*devices=udev_enumerate_get_list_entry（枚举）；
结构udev_列表_条目*条目；
udev\u列表\u条目\u foreach（条目、设备）{
const char*path=udev\u list\u entry\u get\u name（entry）；
child=udev\u device\u new\u from\u syspath（udev，path）；
打破
}
udev_enumerate_unref（enumerate）；
返回儿童；
}
静态无效枚举存储（结构udev*udev）{
结构udev_enumerate*enumerate=udev_enumerate_new（udev）；
udev_enumerate_add_match_子系统（枚举，“scsi”）；
udev_enumerate_add_match_属性（enumerate，“DEVTYPE”，“scsi_设备”）；
udev_枚举扫描_设备（枚举）；
struct udev_list_entry*devices=udev_enumerate_get_list_entry（枚举）；
结构udev_列表_条目*条目；
udev\u列表\u条目\u foreach（条目、设备）{
const char*path=udev\u list\u entry\u get\u name（entry）；
struct udev_device*scsi=udev_device_new_from_syspath（udev，path）；
struct udev_device*block=get_child（udev，scsi，“block”）；
struct udev_device*scsi_disk=get_child（udev，scsi，“scsi_disk”）；
结构udev_设备*usb
=udev_device_get_parent_与_subsystem_devtype（scsi，“usb”，“usb_device”）；
if（块和scsi磁盘和usb）{
printf（“块=%s，usb=%s:%s，scsi=%s，名称=%s，大小=%s，x=%i，x=%s，x=%s\n”，
udev_设备获取devnode（块），
udev设备获取系统属性值（usb，“idVendor”），
设备获取系统属性值（usb，“idProduct”），
udev_设备获取系统属性值（scsi，“供应商”），
udev设备获取系统属性值（usb，“udev”），
udev_设备获取系统属性值（usb，“udev_根”），
设备获取系统属性值（usb，“大小”），
设备获取系统属性值（usb，“速度”），
设备获取系统属性值（usb，“bMaxPower”）；
}
如果（块）{
udev_装置(块);；
}
如果（scsi_磁盘）{
udev_设备unref（scsi_磁盘）；
}
udev_设备unref（scsi）；
}
udev_enumerate_unref（enumerate）；
}
int main（）{
结构udev*udev=udev_new（）；
枚举usb海量存储（udev）；
结构udev_设备*dev；
结构udev_监视器*mon；
int-fd；
mon=udev_监视器_新_来自网络链接（udev，udev”）；
udev\u监视器\u过滤器\u添加\u匹配\u子系统\u开发类型（mon，“block”，NULL）；
udev_监视器_启用_接收（mon）；
fd=udev\U监视器\U get\U fd（周一）；
而(1){
fd_集fds；
结构时间值电视；
int ret；
FD_零（&fds）；
FD_集（FD和fds）；
tv.tv_sec=0；
tv.tv_usec=0；
ret=选择（fd+1和fds、NULL、NULL和tv）；
/*检查文件描述符是否接收到数据*/
如果（ret>0和FD_设置（FD和fds））
{
printf（“\n选择（）表示应该有数据\n”）；
dev=udev\u监视器\u接收设备（mon）；
如果（开发）{
printf（“获取设备\n”）；
printf（“节点：%s\n”，udev_设备_获取_devnode（dev））；
printf（“子系统：%s\n”，udev_设备_get_子系统（dev））；
printf（“Devtype:%s\n”，udev_设备_get_Devtype（dev））；
printf（“操作：%s\n”，udev\u设备获取操作（dev））；
我想你不会在libudev API中找到挂载点路径。Udev监视并提供有关设备的信息。然后是其他组件（可能是
/etc/Udev/rules.d/
中的脚本，或者
udisks
或者你的IDE）触发插入新设备并将其装载到某个目录。Udev不知道。好吧，现代发行版使用
udisks
，所以你可能希望它是D-Bus API。我想你是对的。我会按照你的建议尝试另一种方法。非常感谢！！我也了解sam的问题。我需要检测移动设备（已连接/插入/拔出）使用libudev库。但现在我仍然找不到任何解决方案。