接收端关键代码：

//控制端更新屏幕
void showWin::updateShowLb()
{
    //用数据流的方式读取
    QDataStream in(tcpClient);
    in.setVersion(QDataStream::Qt_5_6);
    // 如果已接收到的数据小于16个字节，保存到来的文件头结构
    if (bytesReceived <= sizeof(qint64)*2)
    {
        if((tcpClient->bytesAvailable() >= sizeof(qint64)*2)&& (imageSize == 0))
        {
            // 接收数据总大小信息和文件名大小信息
            in >> totalBytes  >> imageSize;
            bytesReceived += sizeof(qint64) * 2;
            if(imageSize == 0)
                  ui->label_show->setText(tr("显示的图片为空!"));
        }
        if((tcpClient->bytesAvailable() >= imageSize)&& (imageSize != 0))
        {
            // 接收图片内容
            in >> imageContent;
            QImage imageData = getImage(imageContent);
            QPixmap resImage = QPixmap::fromImage(imageData);
            QPixmap* imgPointer = &resImage;
            imgPointer->scaled(ui->label_show->size(), Qt::IgnoreAspectRatio);//重新调整图像大小以适应窗口
            ui->label_show->setScaledContents(true);//设置label的属性,能够缩放pixmap充满整个可用的空间。
            ui->label_show->setPixmap(*imgPointer);
            bytesReceived += imageSize;
            //接收图片成功
            if(bytesReceived == totalBytes)
            {
                //发送一个确认
                tcpClient->write("1");
                totalBytes = 0;
                bytesReceived = 0;
                imageSize = 0;
            }
         }
     }
}

2.控制数据传输的线程

发送端关键代码：对于发送端来说，需要实时获取用户在屏幕上的鼠标点击以及键盘的键值输入，这个功能QT已经帮我们封装好了，只用定义同名的函数，就可以实时获取用户的操作。这个只对Windows有效，Linux并未实现这个功能，所以我这个程序下Linux只能作为被控制端。

/*键盘按下*/
void CmdThread::cmdKeyPress(QKeyEvent *e)
{
    uchar uc[16];
    uc[0] = CMD_KEY_PRESS;
    uc[1] = translateKey(e->key());
    uc[2] = Find_Key_linux(uc[1]);
    qDebug()<<uc[1]<<uc[2];
    writeAndBlock(cmdSocket, uc, 16);
    e->ignore();
}
/*键盘释放*/
void CmdThread::cmdKeyRelease(QKeyEvent *e)
{
    uchar uc[16];
    uc[0] = CMD_KEY_RELEASE;
    uc[1] = translateKey(e->key());//Windows端使用的字段
    uc[2] = Find_Key_linux(uc[1]); //Linux端使用的字段
    writeAndBlock(cmdSocket, uc, 16);
    e->ignore();
}
//鼠标移动
void CmdThread::cmdMouseMoveTo(int x, int y,int frameWidth,int frameHeight)
{
    uchar uc[16];
    uc[0] = CMD_MOUSE_MOVE_TO;
    setUchar( x,  y, frameWidth, frameHeight, uc);
    writeAndBlock(cmdSocket, uc, 16);
}
//鼠标左键按下
void CmdThread::cmdMouseLeftDown(int x, int y,int frameWidth,int frameHeight)
{
    uchar uc[16];
    uc[0] = CMD_MOUSE_LEFT_DOWN;
    setUchar( x,  y, frameWidth, frameHeight, uc);
    writeAndBlock(cmdSocket, uc, 16);
}
//鼠标左键释放
void CmdThread::cmdMouseLeftUp(int x, int y,int frameWidth,int frameHeight)
{
    uchar uc[16];
    uc[0] = CMD_MOUSE_LEFT_UP;
    setUchar( x,  y, frameWidth, frameHeight, uc);
    writeAndBlock(cmdSocket, uc, 16);
}
//鼠标右键按下
void CmdThread::cmdMouseRightDown(int x, int y,int frameWidth,int frameHeight)
{
    uchar uc[16];
    uc[0] = CMD_MOUSE_RIGHT_DOWN;
    setUchar( x,  y, frameWidth, frameHeight, uc);
    writeAndBlock(cmdSocket, uc, 16);
}
//鼠标右键释放
void CmdThread::cmdMouseRightUp(int x, int y,int frameWidth,int frameHeight)
{
    uchar uc[16];
    uc[0] = CMD_MOUSE_RIGHT_UP;
    setUchar( x,  y, frameWidth, frameHeight, uc);
    writeAndBlock(cmdSocket, uc, 16);
}
//鼠标滚轮事件
void CmdThread::cmdMouseWheel(int delta, int x, int y,int frameWidth,int frameHeight)
{
    uchar uc[16];
    uc[0] = CMD_MOUSE_WHEEL;
    setUchar( x,  y, frameWidth, frameHeight, uc);
    //滚轮的数据，先除以256，再保留余数
    uc[11] = delta / 0x100;
    uc[12] = delta % 0x100;
    //uc[13]用来判断delta的正负,负数为0，非负为1
    uc[13] = delta < 0 ? 0 : 1;
    writeAndBlock(cmdSocket, uc, 16);
}

接收端关键代码：对于被控端来说，接收到控制数据之后就需要在当前系统上响应，这个对于Windows和Linux两种系统是不同的处理。

Windows系统：使用mouse_event()和keybd_event()函数可以直接进行响应。

/*被控端 只接收 控制端 的数据，不发送控制数据*/
Pos_CmdThread::Pos_CmdThread(QTcpSocket* socket, QObject *parent) :
    QThread(parent)
{
    cmdSocket = socket;
    cmd_buf_fill = 0;
    connect(cmdSocket, SIGNAL(readyRead()), this, SLOT(newData()));
}
void Pos_CmdThread::run()
{
    QThread::run();
}

//当tcp socket有新数据到达时运行此函数
void Pos_CmdThread::newData()
{
    while(true)
    {
        int r = cmdSocket->read((char*)(cmd_buf + cmd_buf_fill), 16 - cmd_buf_fill);
        if(r <= 0)
        {
            qWarning()<<"被控端：控制功能-控制数据读取发生错误！";
            return;
        }
        cmd_buf_fill += r;
        //每16个字节为一个完整命令数据
        if(cmd_buf_fill == 16)
        {
            newCommand();
            cmd_buf_fill = 0;
        }
    }

}

void Pos_CmdThread::newCommand()
{
    qDebug()<<"被控端：被控线程-接收到新的控制信息-"<<cmd_buf[0];
    int cmd = cmd_buf[0];
    switch(cmd)
    {
        case CMD_MOUSE_MOVE_TO:
            cmdMouseMoveTo();
            break;
        case CMD_MOUSE_LEFT_DOWN:
            cmdMouseLeftDown();
            break;
        case CMD_MOUSE_LEFT_UP:
            cmdMouseLeftUp();
            break;
        case CMD_MOUSE_RIGHT_DOWN:
            cmdMouseRightDown();
            break;
        case CMD_MOUSE_RIGHT_UP:
            cmdMouseRightUp();
            break;
        case CMD_MOUSE_WHEEL:
            cmdMouseWheel();
            break;
        case CMD_KEY_PRESS:
            cmdKeyPressed();
            break;
        case CMD_KEY_RELEASE:
            cmdKeyReleased();
            break;
        default:
            qWarning()<<"被控端：被控线程-控制命令类型出错!";
            break;
    }
}
//鼠标移动
void Pos_CmdThread::cmdMouseMoveTo()
{
    QPoint p = transformCoordinate();
    mouse_event(MOUSEEVENTF_ABSOLUTE|MOUSEEVENTF_MOVE, p.x(), p.y(), 0, 0);
}
//获取鼠标转换后所在的位置
QPoint Pos_CmdThread::transformCoordinate()
{
    //获取比例;
    long double x = cmd_buf[1]*0.01+cmd_buf[3]*0.0001+cmd_buf[5]*0.000001+cmd_buf[7]*0.00000001+cmd_buf[9]*0.0000000001;
    long double y = cmd_buf[2]*0.01+cmd_buf[4]*0.0001+cmd_buf[6]*0.000001+cmd_buf[8]*0.00000001+cmd_buf[10]*0.0000000001;
    //计算鼠标位置，将鼠标映射到65535*65535的矩阵上
    int point_x = x*65535;
    int point_y = y*65535;
    return QPoint(point_x, point_y);
}
//鼠标左键按下
void Pos_CmdThread::cmdMouseLeftDown()
{
    //执行点击事件
    QPoint p = transformCoordinate();
    mouse_event(MOUSEEVENTF_ABSOLUTE|MOUSEEVENTF_LEFTDOWN, p.x(), p.y(), 0, 0);
}
//鼠标左键释放
void Pos_CmdThread::cmdMouseLeftUp()
{
    QPoint p = transformCoordinate();
    mouse_event(MOUSEEVENTF_ABSOLUTE|MOUSEEVENTF_LEFTUP, p.x(), p.y(), 0, 0);
}
//鼠标右键按下
void Pos_CmdThread::cmdMouseRightDown()
{
    //执行点击事件
    QPoint p = transformCoordinate();
    mouse_event(MOUSEEVENTF_ABSOLUTE|MOUSEEVENTF_RIGHTDOWN, p.x(), p.y(), 0, 0);
}
//鼠标右键释放
void Pos_CmdThread::cmdMouseRightUp()
{
    //执行点击事件
    QPoint p = transformCoordinate();
    mouse_event(MOUSEEVENTF_ABSOLUTE|MOUSEEVENTF_RIGHTUP, p.x(), p.y(), 0, 0);
}
//鼠标滚轮事件
void Pos_CmdThread::cmdMouseWheel()
{
    int delta = cmd_buf[11];
    //乘以256加余数得到原值
    delta = delta << 8;
    delta += cmd_buf[12];
    //判断正负
    delta = cmd_buf[13]==0 ? delta*(-1) :delta;
    QPoint p = transformCoordinate();
    qDebug()<<p.x()<<p.y()<<delta;
    mouse_event(MOUSEEVENTF_ABSOLUTE|MOUSEEVENTF_WHEEL, p.x(), p.y(), delta, 0);
}
//键盘按键按下
void Pos_CmdThread::cmdKeyPressed()
{
    uchar key = cmd_buf[1];//Windows端，所以用【1】字段
    keybd_event(key, 0x45, KEYEVENTF_EXTENDEDKEY, 0);
}
//键盘按键释放
void Pos_CmdThread::cmdKeyReleased()
{
    uchar key = cmd_buf[1];//Windows端，所以用【1】字段
    keybd_event(key, 0x45, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
}

Linux系统:采用写入事件文件的方式来处理控制响应。

#include "pos_cmdthread.h"

/*被控端 只接收 控制端 的数据，不发送控制数据*/
Pos_CmdThread::Pos_CmdThread(QTcpSocket* socket, QObject *parent) :
    QThread(parent)
{
    cmdSocket = socket;
    cmd_buf_fill = 0;
    connect(cmdSocket, SIGNAL(readyRead()), this, SLOT(newData()));
}
void Pos_CmdThread::run()
{
    QThread::run();
}

//当tcp socket有新数据到达时运行此函数
void Pos_CmdThread::newData()
{
//    qDebug("被控端：获取到操作事件！");1

    while(true)
    {
        int r = cmdSocket->read((char*)(cmd_buf + cmd_buf_fill), 16 - cmd_buf_fill);
        if(r <= 0)
        {
            qWarning()<<"被控端：控制功能-控制数据读取发生错误！";
            return;
        }
        cmd_buf_fill += r;
        //每16个字节为一个完整命令数据
        if(cmd_buf_fill == 16)
        {
            newCommand();
            cmd_buf_fill = 0;
        }
    }

}

void Pos_CmdThread::newCommand()
{
    qDebug()<<"被控端：被控线程-接收到新的控制信息-"<<cmd_buf[0]<<cmd_buf[1]<<cmd_buf[2];
    int cmd = cmd_buf[0];
    switch(cmd)
    {
        case CMD_MOUSE_MOVE_TO:
            cmdMouseMoveTo();
            break;
        case CMD_MOUSE_LEFT_DOWN:
            cmdMouseLeftDown();
            break;
        case CMD_MOUSE_LEFT_UP:
            cmdMouseLeftUp();
            break;
        case CMD_MOUSE_RIGHT_DOWN:
            cmdMouseRightDown();
            break;
        case CMD_MOUSE_RIGHT_UP:
            cmdMouseRightUp();
            break;
        case CMD_MOUSE_WHEEL:
            cmdMouseWheel();
            break;
        case CMD_KEY_PRESS:
            cmdKeyPressed();
            break;
        case CMD_KEY_RELEASE:
            cmdKeyReleased();
            break;
        default:
            qWarning()<<"被控端：被控线程-控制命令类型出错!";
            break;
    }
}
//鼠标移动
void Pos_CmdThread::cmdMouseMoveTo()
{
    QPoint p = transformCoordinate();
    int fd_kbd = open("/dev/input/event2",O_RDWR);
    if(fd_kbd<=0)
    {
        qWarning("Can not open mouse input file\n");
        return ;
    }
    simulate_mouse(fd_kbd,p.x(),p.y());
    close(fd_kbd);
}
//获取鼠标转换后所在的位置
QPoint Pos_CmdThread::transformCoordinate()
{
    //获取比例;
    long double x = cmd_buf[1]*0.01+cmd_buf[3]*0.0001+cmd_buf[5]*0.000001+cmd_buf[7]*0.00000001+cmd_buf[9]*0.0000000001;
    long double y = cmd_buf[2]*0.01+cmd_buf[4]*0.0001+cmd_buf[6]*0.000001+cmd_buf[8]*0.00000001+cmd_buf[10]*0.0000000001;
    //计算鼠标位置，将鼠标映射到65535*65535的矩阵上
    int point_x = x*65535;
    int point_y = y*65535;
    return QPoint(point_x, point_y);
}
//鼠标左键按下
void Pos_CmdThread::cmdMouseLeftDown()
{
    int fd_mouse = open("/dev/input/event2",O_RDWR);
    if(fd_mouse<=0)
    {
        qWarning("Can not open mouse input file\n");
        return ;
    }
    simulate_key_pressed(fd_mouse,BTN_LEFT);
    close(fd_mouse);
}
//鼠标左键释放
void Pos_CmdThread::cmdMouseLeftUp()
{
    int fd_mouse = open("/dev/input/event2",O_RDWR);
    if(fd_mouse<=0)
    {
        qWarning("Can not open mouse input file\n");
        return ;
    }
    simulate_key_released(fd_mouse,BTN_LEFT);
    close(fd_mouse);
}
//鼠标右键按下
void Pos_CmdThread::cmdMouseRightDown()
{
    int fd_mouse = open("/dev/input/event2",O_RDWR);
    if(fd_mouse<=0)
    {
        qWarning("Can not open mouse input file\n");
        return ;
    }
    simulate_key_pressed(fd_mouse,BTN_RIGHT);
    close(fd_mouse);
}
//鼠标右键释放
void Pos_CmdThread::cmdMouseRightUp()
{
    int fd_mouse = open("/dev/input/event2",O_RDWR);
    if(fd_mouse<=0)
    {
        qWarning("Can not open mouse input file\n");
        return ;
    }
    simulate_key_released(fd_mouse,BTN_RIGHT);
    close(fd_mouse);
}
//鼠标滚轮事件
void Pos_CmdThread::cmdMouseWheel()
{
    int delta = cmd_buf[11];
    //乘以256加余数得到原值
    delta = delta << 8;
    delta += cmd_buf[12];
    //判断正负
    delta = cmd_buf[13]==0 ? delta*(-1) :delta;
    QPoint p = transformCoordinate();
    qDebug()<<p.x()<<p.y()<<delta;
//    mouse_event(MOUSEEVENTF_ABSOLUTE|MOUSEEVENTF_WHEEL, p.x(), p.y(), delta, 0);
}

//键盘按键按下
void Pos_CmdThread::cmdKeyPressed()
{
    uchar key = cmd_buf[2];//Linux端，所以用【2】字段
    int fd_kbd = open("/dev/input/event1",O_RDWR);
    if(fd_kbd<=0)
    {
        qWarning("Can not open keyboard input file\n");
        return ;
    }
    simulate_key_pressed(fd_kbd,key);
//    simulate_key(fd_kbd,key);
    close(fd_kbd);
}
//键盘按键释放
void Pos_CmdThread::cmdKeyReleased()
{
    uchar key = cmd_buf[2];//Linux端，所以用【2】字段
    int fd_kbd = open("/dev/input/event1",O_RDWR);
    if(fd_kbd<=0)
    {
        qWarning("Can not open keyboard input file\n");
        return ;
    }
    simulate_key_released(fd_kbd,key);
    close(fd_kbd);
}

//按键模拟，按键包含按下和松开两个环节
void Pos_CmdThread::simulate_key(int fd, int kval)
{
    qDebug("Pos_CmdThread::simulate_key-按键模拟");
    struct input_event event;
    gettimeofday(&event.time, 0);

    //按下kval键
    event.type = EV_KEY;
    event.value = 1;
    event.code = kval;
    write(fd, &event, sizeof(event));

    //同步，也就是把它报告给系统
    event.type = EV_SYN;
    event.value = 1;
    event.code = SYN_REPORT;
    write(fd, &event, sizeof(event));

    memset(&event, 0, sizeof(event));
    gettimeofday(&event.time, 0);

    //松开kval键
    event.type = EV_KEY;
    event.value = 0;
    event.code = kval;
    write(fd, &event, sizeof(event));


    //同步，也就是把它报告给系统
    event.type = EV_SYN;
    event.value = 0;
    event.code = SYN_REPORT;
    write(fd, &event, sizeof(event));
}

//按键按下
void Pos_CmdThread::simulate_key_pressed(int fd, int kval)
{
    qDebug("Pos_CmdThread::simulate_key_pressed——按下按键模拟");
    struct input_event event;
    gettimeofday(&event.time, 0);

    //按下kval键
    event.type = EV_KEY;
    event.value = 1;
    event.code = kval;
    write(fd, &event, sizeof(event));

    //同步，也就是把它报告给系统
    event.type = EV_SYN;
    event.value = 1;
    event.code = SYN_REPORT;
    write(fd, &event, sizeof(event));

    memset(&event, 0, sizeof(event));
}

//按键释放
void Pos_CmdThread::simulate_key_released(int fd, int kval)
{
    qDebug("Pos_CmdThread::simulate_key_released——释放按键模拟");
    struct input_event event;
    gettimeofday(&event.time, 0);

    //按下kval键
    event.type = EV_KEY;
    event.value = 0;
    event.code = kval;
    write(fd, &event, sizeof(event));

    //同步，也就是把它报告给系统
    event.type = EV_SYN;
    event.value = 0;
    event.code = SYN_REPORT;
    write(fd, &event, sizeof(event));

    memset(&event, 0, sizeof(event));
}
//鼠标移动模拟
void Pos_CmdThread::simulate_mouse(int fd, int rel_x, int rel_y)
{
    qDebug("鼠标移动模拟");
    struct input_event event;
    gettimeofday(&event.time, 0);

    //x轴坐标的相对位移
    event.type = EV_ABS;
    event.value = rel_x;
    event.code = ABS_X;
    write(fd, &event, sizeof(event));

    //y轴坐标的相对位移
    event.type = EV_ABS;
    event.value = rel_y;
    event.code = ABS_Y;
    write(fd, &event, sizeof(event));

    //同步
    event.type = EV_SYN;
    event.value = 0;
    event.code = SYN_REPORT;
    write(fd, &event, sizeof(event));

}

3.文件传输的线程

发送端关键代码：很常规的文件传输，没什么可说的。

//发送文件数据
void TransFile::startTransfer()
{
    QDataStream sendOut(&outBlock,QIODevice::WriteOnly);
    sendOut.setVersion(QDataStream::Qt_5_7);

    localFile=new QFile(fileName);
    if(!localFile->open(QFile::ReadOnly))
    {
        qWarning()<<"控制端："<<"打开文件出错！";
        return;
    }
    //文件大小
    totalBytes=localFile->size();
    //传输总大小，文件总大小、文件名大小、文件名
    sendOut<<qint64(0)<<qint64(0)<<qint64(0)<<currentFileName;
    //传输总大小
    totalBytes+=outBlock.size();
    sendOut.device()->seek(0);
    //填充 传输总大小，文件总大小、文件名大小, 发送大小等头部信息
    sendOut<<totalBytes<<localFile->size()<<qint64(outBlock.size()-sizeof(qint64)*3);
    tcpClient->write(outBlock);
    //发送真实数据
    int sendSize = 0 , len = 0;
    do
    {
        //每次发送数据的大小
        char buf[1024] = {0};
        len=0;
        //往文件里读数据
        len = localFile->read(buf,sizeof(buf));
        if(len<=0)
        {
            qWarning()<<"发送端：文件传输-读取文件数据失败!";
            return;
        }
        //发送数据，读多少，发多少
        len = tcpClient->write(buf,len);
        if(len<=0)
        {
            qWarning()<<"发送端：文件传输-发送数据失败!";
            return;
        }
        sendSize+=len;
    }while(len>0);
    ui->label_Filestate->setText(tr("传送文件 %1 成功,对方已断开！").arg(currentFileName));
    ui->pBt_Trans->setText("已发送");
    ui->pBt_Trans->setEnabled(false);
    outBlock.resize(0);
    totalBytes = 0;
    qDebug()<<"控制端:"<<"发送文件"<<currentFileName<<"成功!";
}

接收端关键代码：

//当tcp socket有新数据到达时运行此函数
void Pos_TransThread::newData()
{
    qDebug()<<"接收端:"<<"开始接收文件!";
    //使用数据流读取
    QDataStream in(transSocket);
    in.setVersion(QDataStream::Qt_5_7);
    // 如果接收到的数据小于24个字节，保存到来的文件头结构
    if (m_bytesReceived<=sizeof(qint64)*3)
    {
        if((transSocket->bytesAvailable()>=sizeof(qint64)*3)&&(m_fileNameSize==0))
        {
            // 接收数据总大小信息,文件大小 和文件名大小信息
            in>>m_totalBytes>>m_fileSize>>m_fileNameSize;
            m_bytesReceived +=sizeof(qint64)*3;
        }
        if((transSocket->bytesAvailable()>=m_fileNameSize)&&(m_fileNameSize!=0))
        {
            // 接收文件名，并建立文件
            in>>m_fileName;
            m_bytesReceived+=m_fileNameSize;
            m_localFile = new QFile(m_fileName);
            //打开文件
            if (!m_localFile->open(QFile::WriteOnly|QIODevice::Append)){
                qWarning() << "接收端：文件打开失败!"<<m_fileName;
                return;
            }
        }
        else return;
    }
    // 如果接收的数据小于总数据，那么写入文件
    if(m_bytesReceived<m_totalBytes) {
        m_bytesReceived+=transSocket->bytesAvailable();
        m_inBlock = transSocket->readAll();
        quint64 len = m_localFile->write(m_inBlock);
        if(len<=0)
        {
            qWarning()<<"文件传输接收端出现错误，写入文件失败！";
            return;
        }
        m_inBlock.resize(0);
    }
    // 接收数据完成时
    if (m_bytesReceived==m_totalBytes)
    {
        qDebug()<<"接收端：接收文件成功"<<m_fileName<<"自动断开连接！";
        //弹窗提醒接收成功
        QMessageBox::about(NULL,"","接收文件成功！");
        transSocket->close();
        m_localFile->close();
    }
}

转发地址：
链接：https://pan.baidu.com/s/1q4UyaVszfsW_aKy5YF6fNQ 
提取码：wcnk