Qt编程：sokit工具中ServerSkt实现

最新推荐文章于 2025-11-14 10:51:20 发布
原创 最新推荐文章于 2025-11-14 10:51:20 发布 · 1k 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#qt #sokit

serverskt 是一个基于 Qt 网络模块 的服务器核心组件，提供 TCP/UDP 双协议支持，主要功能包括：

  • 多客户端连接管理（TCP 按 Socket 管理，UDP 按地址管理）。

  • 数据收发（支持文本和二进制格式，带调试输出）。

  • 连接状态监控（自动清理超时连接）。

  • 字节统计（实时记录收发数据量）。

#ifndef __SERVERSKT_H__
#define __SERVERSKT_H__

#include <QHash>
#include <QTcpServer>
#include <QUdpSocket>
#include <QDateTime>
#include <QTimer>

class ServerSkt : public QObject
{
	typedef QHash<QString, void*> OBJMAP;

	Q_OBJECT

public:
	ServerSkt(QObject *parent=0);
	virtual ~ServerSkt();

	virtual QString name() const { return "General"; };

	bool start(const QHostAddress& ip, quint16 port);
	void kill(const QString& key);
	void stop();

	void send(const QString& key, const QString& data);

	const QHostAddress& addr() const { return m_ip; };
	quint16 port() const { return m_port; };

signals:
	void connOpen(const QString& key);
	void connClose(const QString& key);
	void message(const QString& msg);
	void dumpbin(const QString& title, const char* data, quint32 len);

	void countRecv(qint32 bytes);
	void countSend(qint32 bytes);

protected:
	void dump(const char* buf, qint32 len, bool isSend, const QString& key);
	void show(const QString& msg);

	void setError(const QString& err);

	void recordRecv(qint32 bytes);
	void recordSend(qint32 bytes);

	void getKeys(QStringList& res);
	void setCookie(const QString& k, void* v);
	void unsetCookie(const QString& k);
	void* getCookie(const QString& k);
	

	virtual bool open() =0;
	virtual bool close(void* cookie) =0;
	virtual void send(void* cookie, const QByteArray& bin) =0;
	virtual void close() =0;

private:
	bool m_started;
	QHostAddress m_ip;
	quint16 m_port;

	OBJMAP m_conns;
	QString m_error;
};

class ServerSktTcp : public ServerSkt
{
	typedef struct _Conn
	{
		QTcpSocket* client;
		QString key;
	} Conn;

	Q_OBJECT

public:
	ServerSktTcp(QObject *parent=0);
	virtual ~ServerSktTcp();

	virtual QString name() const { return "TCP"; };

protected:
	virtual bool open();
	virtual bool close(void* cookie);
	virtual void send(void* cookie, const QByteArray& bin);
	virtual void close();

private slots:
	void newConnection();
	void newData();
	void error();
	void close(QObject* obj);

private:
	QTcpServer m_server;
};

class ServerSktUdp : public ServerSkt
{
	typedef struct _Conn
	{
		QHostAddress addr;
		quint16 port;
		QDateTime stamp;
		QString key;
	} Conn;

	Q_OBJECT

public:
	ServerSktUdp(QObject *parent=0);
	virtual ~ServerSktUdp();

	virtual QString name() const { return "UDP"; };

protected:
	virtual bool open();
	virtual bool close(void* cookie);
	virtual void send(void* cookie, const QByteArray& bin);
	virtual void close();

private slots:
	void newData();
	void error();
	void check();

private:
	QUdpSocket m_server;
	QTimer m_timer;
};

#endif // __SERVERSKT_H__


#include <QTcpSocket>
#include <QStringList>
#include "toolkit.h"
#include "serverskt.h"

#define PROP_CONN  "CONN"

#define MAXBUFFER 1024*1024

ServerSkt::ServerSkt(QObject *parent)
: QObject(parent),m_port(0)
{
	m_started = false;
}

ServerSkt::~ServerSkt()
{
}

bool ServerSkt::start(const QHostAddress& ip, quint16 port)
{
	m_ip = ip;
	m_port = port;

	m_conns.clear();
	m_error.clear();

	m_started = open();

	QString msg("start %1 server %2!");
	if (!m_started)
	{
		msg = msg.arg(name(),"failed");
		if (!m_error.isEmpty())
		{	msg += " error:[";
			msg += m_error;
			msg += "].";
		}
	}
	else
	{
		msg = msg.arg(name(),"successfully");
	}

	show(msg);

	return m_started;
}

void ServerSkt::stop()
{
	if (!m_started)
		return;

	OBJMAP::const_iterator i;
	for (i = m_conns.constBegin(); i != m_conns.constEnd(); ++i)
	{
		QString k = i.key();
		void* v = i.value();

		if (close(v))
			emit connClose(k);
	}

	m_conns.clear();

	close();

	show(QString("stop %1 server!").arg(name()));

	m_started = false;
}

void ServerSkt::setError(const QString& err)
{
	m_error = err;
}

void ServerSkt::recordRecv(qint32 bytes)
{
	emit countRecv(bytes);
}

void ServerSkt::recordSend(qint32 bytes)
{
	emit countSend(bytes);
}

void ServerSkt::getKeys(QStringList& res)
{
	res = m_conns.keys();
}

void ServerSkt::setCookie(const QString& k, void* v)
{
	void* o = m_conns.value(k);
	if (o)
	{
		if (close(o))
			emit connClose(k);
	}

	m_conns.insert(k, v);
	emit connOpen(k);
}

void ServerSkt::unsetCookie(const QString& k)
{
	m_conns.remove(k);
	emit connClose(k);
}

void* ServerSkt::getCookie(const QString& k)
{
	return m_conns.value(k);
}

void ServerSkt::kill(const QString& key)
{
	void* v = m_conns.value(key);
	if (v)
	{
		if (close(v))
			unsetCookie(key);
	}
	else
	{
		unsetCookie(key);
	}
}

void ServerSkt::send(const QString& key, const QString& data)
{
	void* v = m_conns.value(key);
	if (v)
	{
		QString err;
		QByteArray bin;

		if (!TK::ascii2bin(data, bin, err))
			show("bad data format to send: "+err);
		else
			send(v, bin);
	}
}

void ServerSkt::dump(const char* buf, qint32 len, bool isSend, const QString& key)
{
	emit dumpbin(QString("DAT %1 %2").arg(isSend?"<---":"--->",key), buf, (quint32)len);
}

void ServerSkt::show(const QString& msg)
{
	emit message(msg);
}

ServerSktTcp::ServerSktTcp(QObject *parent)
:ServerSkt(parent)
{
}

ServerSktTcp::~ServerSktTcp()
{
	m_server.disconnect(this);
	stop();
}

bool ServerSktTcp::open()
{
	if (m_server.listen(addr(), port()))
	{
		connect(&m_server, SIGNAL(newConnection()), this, SLOT(newConnection()));
		return true;
	}
	else
	{
		setError(QString("%1, %2").arg(m_server.serverError()).arg(m_server.errorString()));
	}

	return false;
}

bool ServerSktTcp::close(void* cookie)
{
	Conn* conn = (Conn*)cookie;
	
	if (conn->client)
		conn->client->disconnect(this);

	delete conn->client;
	delete conn;

	return true;
}

void ServerSktTcp::close(QObject* obj)
{
	Conn* conn = (Conn*)obj->property(PROP_CONN).value<void*>();
	if (!conn) return;

	unsetCookie(conn->key);
	delete conn;
}

void ServerSktTcp::error()
{
	QTcpSocket* s = qobject_cast<QTcpSocket*>(sender());

	show(QString("TCP socket error %1, %2").arg(s->error()).arg(s->errorString()));

	s->deleteLater();
}

void ServerSktTcp::close()
{
	m_server.close();
	m_server.disconnect(this);
}

void ServerSktTcp::newConnection()
{
	QTcpServer* server = qobject_cast<QTcpServer*>(sender());
	if (!server) return;

	QTcpSocket* client = server->nextPendingConnection();
	while (client)
	{
		Conn* conn = new Conn;
		if (!conn)
		{
			client->deleteLater();
		}
		else
		{
			client->setProperty(PROP_CONN, qVariantFromValue((void*)conn));

			conn->client = client;
			conn->key = TK::ipstr(client->peerAddress(),client->peerPort(), true);

			connect(client, SIGNAL(readyRead()), this, SLOT(newData()));
			connect(client, SIGNAL(destroyed(QObject*)), this, SLOT(close(QObject*)));
			connect(client, SIGNAL(disconnected()), client, SLOT(deleteLater()));
			connect(client, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(error()));

			setCookie(conn->key, conn);
		}
		client = server->nextPendingConnection();
	}
}

void ServerSktTcp::newData()
{
	QTcpSocket* client = qobject_cast<QTcpSocket*>(sender());
	if (!client) return;

	Conn* conn = (Conn*)client->property(PROP_CONN).value<void*>();
	if (!conn) return;

	qint64 bufLen = client->bytesAvailable();
	char* buf = TK::createBuffer(bufLen, MAXBUFFER);
	if (!buf) return;

	qint64 readLen = 0;
	qint64 ioLen = client->read(buf, bufLen);

	while (ioLen > 0)
	{
		readLen += ioLen;
		ioLen = client->read(buf+readLen, bufLen-readLen);
	}

	if (ioLen >= 0)
	{
		recordRecv(readLen);
		dump(buf, readLen, false, conn->key);
	}

	TK::releaseBuffer(buf);
}

void ServerSktTcp::send(void* cookie, const QByteArray& bin)
{
	Conn* conn = (Conn*)cookie;

	const char *  src = bin.constData(); 
	qint64 srcLen = bin.length();

	qint64 writeLen = 0;
	qint64 ioLen = conn->client->write(src, srcLen);

	while (ioLen > 0)
	{
		writeLen += ioLen;
		ioLen = conn->client->write(src+writeLen, srcLen-writeLen);
	}

	if (writeLen != srcLen)
	{
		show(QString("failed to send data to %1:%2 [%3]")
			.arg(addr().toString()).arg(port()).arg(writeLen));
		return;
	}

	recordSend(writeLen);
	dump(src, srcLen, true, conn->key);
}

ServerSktUdp::ServerSktUdp(QObject *parent)
:ServerSkt(parent)
{
}

ServerSktUdp::~ServerSktUdp()
{
	m_server.disconnect(this);
	stop();
}

void ServerSktUdp::error()
{
	QUdpSocket* s = qobject_cast<QUdpSocket*>(sender());

	show(QString("UDP socket error %1, %2").arg(s->error()).arg(s->errorString()));
}

bool ServerSktUdp::open()
{
	if (m_server.bind(addr(), port(), QUdpSocket::ShareAddress))
	{
		connect(&m_server, SIGNAL(readyRead()), this, SLOT(newData()));
		connect(&m_server, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(error()));
		connect(&m_timer, SIGNAL(timeout()), this, SLOT(check()));

		m_timer.start(2000);
		return true;
	}
	else
	{
		setError(QString("%1, %2").arg(m_server.error()).arg(m_server.errorString()));
	}

	return false;
}

bool ServerSktUdp::close(void* cookie)
{
	delete (Conn*)cookie;
	return true;
}

void ServerSktUdp::close()
{
	m_timer.disconnect(this);
	m_timer.stop();
	m_server.close();
	m_server.disconnect(this);
}

void ServerSktUdp::newData()
{
	QUdpSocket* s = qobject_cast<QUdpSocket*>(sender());
	if (!s) return;

	qint64 bufLen = s->pendingDatagramSize();
	char* buf = TK::createBuffer(bufLen, MAXBUFFER);
	if (!buf) return;

	QHostAddress addr; quint16 port(0);

	qint64 readLen = 0;
	qint64 ioLen = s->readDatagram(buf, bufLen, &addr, &port);

	//while (ioLen > 0)
	//{
		readLen += ioLen;
	//	ioLen = s->readDatagram(buf+readLen, bufLen-readLen, &addr, &port);
	//}

	if (ioLen >= 0)
	{
		Conn* conn = (Conn*)getCookie(TK::ipstr(addr, port, false));
		if (!conn)
		{
			conn = new Conn;
			if (conn)
			{
				conn->key  = TK::ipstr(addr, port, false);
				conn->addr = addr;
				conn->port = port;
				setCookie(conn->key, conn);
			}
		}

		if (conn)
		{
			recordRecv(readLen);

			conn->stamp = QDateTime::currentDateTime();
			dump(buf, readLen, false, conn->key);
		}
	}

	TK::releaseBuffer(buf);
}

void ServerSktUdp::send(void* cookie, const QByteArray& bin)
{
	Conn* conn = (Conn*)cookie;

	const char*  src = bin.constData(); 
	qint64 srcLen = bin.length();

	qint64 writeLen = 0;
	qint64 ioLen = m_server.writeDatagram(src, srcLen, conn->addr, conn->port);

	while (ioLen > 0)
	{
		writeLen += ioLen;

		ioLen = (writeLen >= srcLen) ? 0 :
				m_server.writeDatagram(src+writeLen, srcLen-writeLen, conn->addr, conn->port);
	}

	if (writeLen != srcLen)
	{
		show(QString("failed to send data to %1:%2 [%3]")
			.arg(conn->addr.toString()).arg(conn->port).arg(writeLen));
		return;
	}

	recordSend(writeLen);
	dump(src, srcLen, true, conn->key);
}

void ServerSktUdp::check()
{
	QStringList list;
	getKeys(list);

	while (!list.isEmpty())
	{
		QString k = list.takeFirst();

		void* c = getCookie(k);

		if (c && (((Conn*)c)->stamp.addSecs(120) < QDateTime::currentDateTime()))
		{
			close(c);
			unsetCookie(k);
		}
	}
}

核心类与分工

类名职责
ServerSkt抽象基类，定义通用接口（如 start()/stop()）和连接管理逻辑。
ServerSktTcp实现 TCP 服务器逻辑，基于 QTcpServer 和 QTcpSocket。
ServerSktUdp实现 UDP 服务器逻辑，基于 QUdpSocket，支持会话超时清理。

核心功能

功能模块实现细节
TCP/UDP 服务器支持多客户端连接，管理连接生命周期（建立、通信、关闭）。
数据收发统一接口处理二进制/文本数据，支持调试输出（十六进制 + ASCII 格式）。
连接管理使用 QHash 存储活跃连接，TCP 按 Socket 管理，UDP 按客户端地址管理。
统计与监控实时统计收发字节数，定时清理无效连接（UDP）。
错误处理通过信号传递错误信息（如 error(QAbstractSocket::SocketError)）。

关键方法实现

(1) 服务器启动与停止
// 启动服务器（基类 ServerSkt）
bool ServerSkt::start(const QHostAddress& ip, quint16 port) {
    m_ip = ip;
    m_port = port;
    m_started = open(); // 调用子类实现的 open()
    emit message(m_started ? "启动成功" : "启动失败: " + m_error);
    return m_started;
}

// 停止服务器（基类 ServerSkt）
void ServerSkt::stop() {
    if (!m_started) return;
    close(); // 调用子类实现的 close()
    m_conns.clear(); // 清理所有连接
    emit message("服务器已停止");
}

  • TCP 实现 (ServerSktTcp)：

    bool ServerSktTcp::open() {
    return m_server.listen(m_ip, m_port); // 监听端口
}
void ServerSktTcp::close() {
    m_server.close(); // 停止监听
}

  • UDP 实现 (ServerSktUdp)：

    bool ServerSktUdp::open() {
    return m_server.bind(m_ip, m_port); // 绑定端口
}
void ServerSktUdp::close() {
    m_server.close(); // 解绑端口
}
(2) 连接管理

  • TCP 新连接处理：

    void ServerSktTcp::newConnection() {
    QTcpSocket* client = m_server.nextPendingConnection();
    QString key = TK::ipstr(client->peerAddress(), client->peerPort(), true);
    Conn* conn = new Conn{client, key};
    setCookie(key, conn); // 存储连接
    emit connOpen(key);   // 通知新连接
}

  • UDP 连接标识：

    void ServerSktUdp::newData() {
    QHostAddress addr; quint16 port;
    m_server.readDatagram(data, &addr, &port);
    QString key = TK::ipstr(addr, port, false);
    if (!m_conns.contains(key)) {
        Conn* conn = new Conn{addr, port, QDateTime::currentDateTime(), key};
        setCookie(key, conn); // 按地址管理会话
    }
}
(3) 数据收发

  • 发送数据（TCP/UDP 统一接口）：

    void ServerSktTcp::send(void* cookie, const QByteArray& bin) {
    Conn* conn = (Conn*)cookie;
    conn->client->write(bin); // TCP 发送
    emit countSend(bin.size());
}

void ServerSktUdp::send(void* cookie, const QByteArray& bin) {
    Conn* conn = (Conn*)cookie;
    m_server.writeDatagram(bin, conn->addr, conn->port); // UDP 发送
    emit countSend(bin.size());
}

  • 接收数据：

    void ServerSktTcp::newData() {
    QTcpSocket* client = (QTcpSocket*)sender();
    QByteArray data = client->readAll();
    emit dumpbin("RECV", data.constData(), data.size()); // 调试输出
}
(4) 超时清理（UDP）
void ServerSktUdp::check() {
    QStringList keys = m_conns.keys();
    for (const QString& key : keys) {
        Conn* conn = (Conn*)m_conns.value(key);
        if (conn->stamp.addSecs(120) < QDateTime::currentDateTime()) {
            close(conn);      // 关闭超时连接
            unsetCookie(key); // 移除记录
        }
    }
}
(5) TCP 服务器流程
// 启动监听
bool ServerSktTcp::open() {
    return m_server.listen(m_ip, m_port);
}

// 处理新连接
void ServerSktTcp::newConnection() {
    QTcpSocket* client = m_server.nextPendingConnection();
    QString key = TK::ipstr(client->peerAddress(), client->peerPort(), true);
    Conn* conn = new Conn{client, key};
    setCookie(key, conn); // 存储连接
}

// 数据接收
void ServerSktTcp::newData() {
    QTcpSocket* client = (QTcpSocket*)sender();
    QByteArray data = client->readAll();
    emit dumpbin("RECV", data.constData(), data.size());
}
(6) UDP 服务器流程
// 绑定端口
bool ServerSktUdp::open() {
    return m_server.bind(m_ip, m_port);
}

// 接收数据并管理会话
void ServerSktUdp::newData() {
    QHostAddress addr; quint16 port;
    QByteArray data;
    data.resize(m_server.pendingDatagramSize());
    m_server.readDatagram(data.data(), data.size(), &addr, &port);
    
    QString key = TK::ipstr(addr, port, false);
    if (!m_conns.contains(key)) {
        Conn* conn = new Conn{addr, port, QDateTime::currentDateTime(), key};
        setCookie(key, conn); // 新会话
    }
}

// 定时清理超时会话
void ServerSktUdp::check() {
    for (auto it = m_conns.begin(); it != m_conns.end(); ) {
        Conn* conn = (Conn*)it.value();
        if (conn->stamp.addSecs(120) < QDateTime::currentDateTime()) {
            delete conn;
            it = m_conns.erase(it); // 移除超时连接
        } else {
            ++it;
        }
    }
}

信号与槽机制

信号触发场景典型槽函数用途
connOpen(key)新连接建立（TCP）或首次收到数据（UDP）更新 UI 连接列表
connClose(key)连接关闭清理连接资源
message(msg)状态变更/错误发生显示日志信息
dumpbin(title, data, len)数据收发时调试窗口输出十六进制数据
countRecv(bytes)收到数据更新接收字节统计

实际应用示例

启动 TCP 服务器并发送数据
ServerSktTcp tcpServer;
tcpServer.start(QHostAddress::Any, 8080);  // 监听 8080 端口

// 向指定客户端发送数据
QString clientKey = "192.168.1.2:54321";
tcpServer.send(clientKey, "Hello, Client!");
UDP 服务器处理超时
ServerSktUdp udpServer;
udpServer.start(QHostAddress::Any, 9090);

// 每 2 秒自动触发 check() 清理超时连接

关键设计亮点

  1. 抽象基类：通过纯虚函数 (open/close/send) 实现多态，统一 TCP/UDP 接口。

  2. 连接标识：TCP 使用 IP:Port，UDP 使用 IP，确保唯一性。

  3. 资源管理：

    • TCP 连接通过 QTcpSocket 自动释放（deleteLater）。

    • UDP 会话通过定时器清理，避免内存泄漏。

  4. 调试支持：dumpbin 信号提供完整的数据流监控能力。

 潜在问题与改进

  • TCP 粘包：当前实现未处理粘包，需在应用层添加协议头（如长度前缀）。

  • 线程安全：若在多线程中调用 send()，需加锁保护 m_conns。

  • 性能优化：UDP 的 check() 可改用更高效的数据结构（如时间轮）。

总结

  • 适用场景：网络调试工具、IoT 设备通信、轻量级服务端。

  • 扩展性：可轻松集成 SSL 加密或自定义协议（如 WebSocket）。

Qt编程：sokit工具实现总结
倔强老吕的博客
07-20 1245
Sokit 是一个基于 Qt 的网络调试工具，包含 TCP/UDP 客户端和服务端功能。
Qt编程：Sokit 工具
倔强老吕的博客
07-19 982
Sokit 工具 是一款用于 TCP/UDP 网络通信测试 的轻量级调试工具，主要用于开发过程中的 Socket 通信调试 和 网络协议分析。
探索Sokit：一个高效且灵活的JavaScript库
最新发布
gitblog_00066的博客
11-14 371
是一个轻量级、高性能的JavaScript工具库，它为开发者提供了一系列实用的功能，以简化日常开发任务。无论你是Web前端开发人员，还是在构建复杂的JavaScript应用，Sokit都可能成为你的得力助手。 ## 项目简介 Sokit的核心理念是简洁和实用，它的API设计易于理解和使用。这个库包含了对DOM操作、事件处理、动画效果、网络请求等常见功能的支持，旨在提高开发效率并降低代码复杂度。
sokit-1.3-win64(亲测可用).zip
05-19
sokit-1.3 socket调式工具。可以发送字符串，十六进制的字节数据。非常强大，亲测可用。
一零六、原理篇
梅某某
02-19 443
1 vue或者react render原理（动态渲染） vue //模板 var login = { template: '<h1>这是登录组件</h1>' } // 创建 Vue 实例，得到 ViewModel var vm = new Vue({ el: '#app', data: {}...
sokit-1.3-linux64
10-19
有可视化界面的tcp收发工具在网上只找到了sokit，下载了一个linux32位版本的，发现无法运行。于是自己下载源码用Qt编译了一个64位版本的，分享一下给大家节省时间。软件依赖Qt库。
sokit-1.3.zip
07-13
1、服务器模式 用来监听本地端口，接收外部数据包，并且可以回复自定义数据 2、客户端模式 用来连接服务器，发送自定义数据包，并接收远程回复数据 3、转发器模式 用来监听本地端口，将接收到的数据包发送给指定的远程服务器，也可以在转发数据流中插入自定义数据向双发发送 4、支持发送ascii字符串数据，以及十六进制表示的原始字节，单次发送的字符数目没有限制 5、收到的数据会同时以这两种形式显示
sokit-1.3-win32
01-12
sokit是一款免费开源的TCP/UDP测试工具，支持对以太网的数据进行转发、获取传输过程中的数据，以便查看发送是否正确，可用来接收、发送、转发TCP或UDP数据包，支持新建server client；支持收发日志文件；支持快捷键操作；支持中英文用户界面；支持Windows XP/2000/2003/2008/Vista/7以及Linux等多种操作系统。
Qt编程：sokit工具中clientskt实现
倔强老吕的博客
07-20 337
ClientSkt 是一个基于 Qt 的网络通信基类，提供了 TCP 和 UDP 两种网络协议的客户端实现。
深入解析TCP测试与抓包工具：sokit与Wireshark
在这个领域中，有两个工具尤为突出：Sokit和Wireshark。本文将详细介绍这两个工具在进行TCP测试和抓包时的应用。 Sokit是一款小巧实用的网络工具，它集成了多种功能，包括端口扫描、网络连接、数据包嗅探和分析等。...
linux sokit调试工具
06-05
好用的一款linux下sokit调试工具
SSokit-qmake：用于TCP＆UDP调试的简单而强大的工具
02-02
SSokit-qmake：用于TCP＆UDP调试的简单而强大的工具
sokit-1.3 win32
07-28
sokit 1.3 win32 chs.
sokit1.3工具
11-28
sokit1.3 UDP TCP ,调试工具，用起来十分方便，希望对大家有帮助。
sokit_socket调试工具
05-17
非常好用的socket应用程序调试工具。支持TCP和UDP协议。可做服务器也可做客户端。当我们要写服务器或者客户端时，用它来调试非常方便。该工具在32位系统上测试可用，64位的不清楚。
精选资源
sokit 工具及其使用说明.rar
12-03
6. **命令行接口**：对于自动化测试和脚本编程，Sokit提供了命令行接口，可以与其他工具或脚本系统集成，实现自动化串口通信。 7. **跨平台支持**：Sokit的跨平台特性使得不论在Windows、Linux还是Mac环境下，用户...
sokit 1.3开源工具
08-13
在IT或嵌入式行业中，理解和掌握UDP和TCP协议是网络编程和系统调试的基础，所以好的开源工具能够事半功倍。 在sokit-1.3-win32-enu.rar这个压缩包中，包含了sokit1.3工具的完整版本，包括可执行文件、免安装程序。...
SSokit-qmake 开源项目安装与使用指南
gitblog_01002的博客
08-22 392
SSokit-qmake 开源项目安装与使用指南 一、项目目录结构及介绍 本开源项目 SSokit-qmake 主要围绕构建一个基于Qt的网络通信库。以下是其主要目录结构及其简介： SSokit-qmake │── CMakeLists.txt # CMake 构建脚本，尽管项目以qmake为主，但也兼容CMake │── doc # ...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值