linux下监控usb自动挂载

挂载路径自己修改即可:

U盘挂载部分:

#include "checkudisk.h"

checkUdisk::checkUdisk(QObject *parent): QObject(parent)
{
    check = new usbCheck();
    thread = new QThread();

    connect(thread, SIGNAL(started()),check,SLOT(checking()));
    connect(thread, SIGNAL(finished()),check, SLOT(deleteLater()));
    connect(check,SIGNAL(usbName(QStringList,int)),this,SLOT(getName(QStringList,int)));
    check->moveToThread(thread);

}

void checkUdisk::started()
{
    int pos=0;
    bool fdiskU,dfU;
    QString cmd,path;
    QDir dir;
    QString checkResult;
    //fdisk -l 检查/dev下是否识别U盘/sd[a-z][0-9]{1,2}
    runCmd checkU;
    QString fidsk = "fdisk";
    QStringList fdisk_list;
    fdisk_list<<"-l";
    checkU.setCmd(fidsk,fdisk_list);
    checkResult = checkU.getString();

    fdisk_list.clear();
    QRegExp rx("sd[a-z][0-9]{1,2}");

    while( (pos = rx.indexIn(checkResult,pos)) != -1 )
    {
        fdisk_list<<rx.cap(0);
        pos += rx.matchedLength();
    }

    //检测到的 sd* 存于fdisk_list列表
    if(fdisk_list.length() == 0)
        fdiskU = false;
    else
        fdiskU = true;

    //df -h 检查对应的U盘是否挂载;
    checkResult.clear();
    runCmd chechDf;
    QString df = "df";
    QStringList df_list;
    df_list<<"-h";
    chechDf.setCmd(df,df_list);
    checkResult = chechDf.getString();


    df_list.clear();
    QRegExp rz("/dev/sd[a-z][0-9]{1,2}");
    pos = 0;
    while( (pos = rz.indexIn(checkResult,pos)) != -1 )
    {
        df_list<<rz.cap(0);
        pos += rz.matchedLength();
    }

    if(df_list.length() == 0)
        dfU = false;
    else
        dfU = true;

    if(fdiskU == true)
    {
        if(dfU == false)
        {
            for(int i=0; i<fdisk_list.length();i++)
            {
                path = QString("/mnt/%1").arg(fdisk_list.at(i));
                dir.mkdir(path);
                cmd = QString("mount /dev/%1 /mnt/%1").arg(fdisk_list.at(i));
                system(cmd.toStdString().c_str());
            }
        }
    }


    thread->start();
}

checkUdisk::~checkUdisk()
{
    disconnect(thread, SIGNAL(started()),check,SLOT(checking()));
    disconnect(thread, SIGNAL(finished()),check, SLOT(deleteLater()));
    if(thread)
    {
        if(thread->isRunning())
        {
            thread->quit();
            thread->wait();
        }
        delete thread;
        thread = NULL;
    }
    if(check)
    {
        delete check;
        check = NULL;
    }
}

void checkUdisk::getName(QStringList strList,int statue)
{
    QString cmd,path;
    QDir dir;
    if(strList.length() == 0)
        return;
    if(statue == 0)
    {
        for(int i=0; i<strList.length();i++)
        {
            path = QString("/mnt/%1").arg(strList.at(i));
            cmd = QString("umount /mnt/%1").arg(strList.at(i));
            system(cmd.toStdString().c_str());
            dir.rmdir(path);
        }
    }
    else if(statue == 1)
    {
        for(int i=0; i<strList.length();i++)
        {
            path = QString("/mnt/%1").arg(strList.at(i));
            dir.mkdir(path);
            usbPathList<<path;
            cmd = QString("mount /dev/%1 /mnt/%1").arg(strList.at(i));
            system(cmd.toStdString().c_str());
        }
    }
    else
    {
        for(int i=0; i<usbPathList.length();i++)
        {
            dir.rmdir(usbPathList.at(i));
        }
    }
    //qDebug()<<cmd;
}

#ifndef CHECKUDISK_H
#define CHECKUDISK_H

#include <QThread>
#include <QStringList>
#include <QString>
#include <QFile>
#include <QFileInfo>
#include <QDir>
#include "usbcheck.h"
#include "runCmd.h"

class usbCheck;
class runCmd;
class checkUdisk : public QObject
{
    Q_OBJECT
public:
    explicit checkUdisk(QObject *parent = 0);
    bool checking();
    void started();
    ~checkUdisk();

public slots:
    void getName(QStringList,int statue);
private:
    QThread *thread;
    usbCheck *check;
    QStringList usbPathList;
};

#endif // CHECKUDISK_H

运行部分:

#include "runCmd.h"

runCmd::runCmd(QObject *parent) : QObject(parent)
{
    process = new QProcess(this);
    connect(process, SIGNAL(readyRead()),this,SLOT(readyRead()));
}

runCmd::~runCmd()
{
    delete process;
}

QString runCmd::getString()
{
   while(false == process->waitForFinished());
   return putout;
}

void runCmd::setCmd(QString str,QStringList strList)
{
   if(strList.length()==0)
   {
       process->start(str);
   }
   else
   {
       process->start(str,strList);
   }
}

void runCmd::readyRead()
{
    putout = process->readAll();
}

.h

#ifndef RUNCMD_H
#define RUNCMD_H

#include <QProcess>
#include <QDebug>

#include <QObject>

class runCmd : public QObject
{
    Q_OBJECT
public:
    explicit runCmd(QObject *parent = 0);
    ~runCmd();
    void setCmd(QString,QStringList);
    QString getString();
signals:

public slots:
    void readyRead();

private:
    QProcess *process;
    QString putout;
};

#endif // RUNCMD_H

检测usb代码:

#include "usbcheck.h"

usbCheck::usbCheck(QObject *parent) : QObject(parent)
{
    sockfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_KOBJECT_UEVENT);
    memset(&client,0,sizeof(client));
    client.nl_family = AF_NETLINK;
    client.nl_pid = getpid();
    client.nl_groups = 1;
    buffersize = 1024;
    setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF,&buffersize, sizeof(buffersize));

//    if(bind(sockfd, (struct sockaddr *)&client,sizeof(client)))
//        qDebug()<<"bind error:"<<strerror(errno);
    bind(sockfd, (struct sockaddr *)&client,sizeof(client));

}

void usbCheck::checking()
{
    for(;;)
    {
        char buf[UEVENT_BUFFER_SIZE] = {0};
        FD_ZERO(&fds);
        FD_SET(sockfd,&fds);

        tv.tv_sec = 0;
        tv.tv_usec = 100*1000;
        result = select(sockfd+1,&fds, NULL,NULL, &tv);
        if(result <0)
            continue;
        if(!(result>0 && FD_ISSET(sockfd,&fds)))
            continue;

        receiveLenth = recv(sockfd,&buf,sizeof(buf),0);

        if(receiveLenth >0)
        {
           getName(buf);
        }
    }
}

//            emit usbName(QString("sdb1"),1);//0 remove
//            emit usbName(str,1);//1 add
//ID = str.mid(str.indexOf(new QRegExp("[0-9]{1,2}")));
void usbCheck::getName(QString buf)
{
    QString statue = buf.split("@").at(0);
    QStringList resultList;
//    QRegExp rx("\/sd[a-z]{1}[0-9]{1,2}");
    QRegExp rx("sd[a-z]{1}[0-9]{1,2}");
    int pos = 0;
    while( (pos = rx.indexIn(QString(buf),pos)) != -1)
    {
        resultList<<rx.cap(0);
        pos += rx.matchedLength();
    }

    if(statue == "remove")
    {
        emit usbName(resultList,0);
    }
    else if(statue == "add")
    {
        emit usbName(resultList,1);
    }
}

#ifndef USBCHECK_H
#define USBCHECK_H

#include <QObject>

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/types.h>

//#include <QDebug>
#include <QString>
#include <QStringList>
#include <asm/types.h>
#include <sys/socket.h>
#include <linux/netlink.h>

#include "head.h"

#define UEVENT_BUFFER_SIZE 4096

class usbCheck : public QObject
{
    Q_OBJECT
public:
    explicit usbCheck(QObject *parent = 0);

signals:
    void usbName(QStringList ,int statue);
public slots:
    void checking();
private:
    void getName(QString);
private:
    int sockfd;
    struct sockaddr_nl client;
    struct timeval tv;
    struct msghdr msg;
    struct iovec iov;
    fd_set fds;
    int receiveLenth,i,result;
    int buffersize;

};

#endif // USBCHECK_H

公用头:

#ifndef HEAD_H
#define HEAD_H

#include <QObject>
#include <QString>
//#include <QDebug>
#include <QThread>
#include "usbcheck.h"
#include "checkudisk.h"
#include "runCmd.h"

#endif // HEAD_H

main:

#include <QCoreApplication>
#include "head.h"
#include "checkudisk.h"

class checkUdisk;

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    checkUdisk check;
    check.started();
    return a.exec();
}

 

代码简单久不解释了,原理用的是socket检测内核usb事件,匹配出来以后 手动挂载.

完整工程代码:umount.zip