struct linger windows linux,跨平台(Windows+Linux)的Socket通讯程序（一）—底层封装(转)...

于 2021-05-06 09:28:22 发布
阅读量221 收藏
点赞数
文章标签： struct linger windows linux

#include "platform.h"

#include 

#include 

#include 

#include "lightthread.h"

#include "sock_wrap.h"

#include "TimeSpan.h"

#define INVALIDSOCKHANDLE   INVALID_SOCKET

#if defined(_WIN32_PLATFROM_)

#include 

#define ISSOCKHANDLE(x)  (x!=INVALID_SOCKET)

#define BLOCKREADWRITE      0

#define NONBLOCKREADWRITE   0

#define SENDNOSIGNAL        0

#define ETRYAGAIN(x)     (x==WSAEWOULDBLOCK||x==WSAETIMEDOUT)

#define gxsprintf   sprintf_s

#endif

#if defined(_LINUX_PLATFORM_)

#include 

#include 

#include 

#include 

#include 

#include 

#define ISSOCKHANDLE(x)    (x>0)

#define BLOCKREADWRITE      MSG_WAITALL

#define NONBLOCKREADWRITE   MSG_DONTWAIT

#define SENDNOSIGNAL        MSG_NOSIGNAL

#define ETRYAGAIN(x)        (x==EAGAIN||x==EWOULDBLOCK)

#define gxsprintf           snprintf

#endif

void GetAddressFrom(sockaddr_in *addr, const char *ip, int port)

{

memset(addr, 0, sizeof(sockaddr_in));

addr->sin_family = AF_INET;            /*地址类型为AF_INET*/

if(ip)

{

addr->sin_addr.s_addr = inet_addr(ip);

}

else

{

/*网络地址为INADDR_ANY，这个宏表示本地的任意IP地址，因为服务器可能有多个网卡，每个网卡也可能绑定多个IP地址，

这样设置可以在所有的IP地址上监听，直到与某个客户端建立了连接时才确定下来到底用哪个IP地址*/

addr->sin_addr.s_addr = htonl(INADDR_ANY);

}

addr->sin_port = htons(port);   /*端口号*/

}

void GetIpAddress(char *ip, sockaddr_in *addr)

{

unsigned char *p =(unsigned char *)( &(addr->sin_addr));

gxsprintf(ip, 17, "%u.%u.%u.%u", *p,*(p+1), *(p+2), *(p+3) );

}

int GetLastSocketError()

{

#if defined(_WIN32_PLATFROM_)

return WSAGetLastError();

#endif

#if defined(_LINUX_PLATFORM_)

return errno;

#endif

}

bool IsValidSocketHandle(HSocket handle)

{

return ISSOCKHANDLE(handle);

}

void SocketClose(HSocket &handle)

{

if(ISSOCKHANDLE(handle))

{

#if defined(_WIN32_PLATFROM_)

closesocket(handle);

#endif

#if defined(_LINUX_PLATFORM_)

close(handle);

#endif

handle = INVALIDSOCKHANDLE;

}

}

HSocket SocketOpen(int tcpudp)

{

int protocol = 0;

HSocket hs;

#if defined(_WIN32_PLATFROM_)

if(tcpudp== SOCK_STREAM) protocol=IPPROTO_TCP;

else if (tcpudp== SOCK_DGRAM) protocol = IPPROTO_UDP;

#endif

hs = socket(AF_INET, tcpudp, protocol);

return hs;

}

int SocketBind(HSocket hs, sockaddr_in *paddr)

{

return bind(hs, (struct sockaddr *)paddr, sizeof(sockaddr_in));

}

int SocketListen(HSocket hs, int maxconn)

{

return listen(hs,maxconn);

}

HSocket SocketAccept(HSocket hs, sockaddr_in *paddr)

{

#if defined(_WIN32_PLATFROM_)

int cliaddr_len = sizeof(sockaddr_in);

#endif

#if defined(_LINUX_PLATFORM_)

socklen_t cliaddr_len = sizeof(sockaddr_in);

#endif

return accept(hs, (struct sockaddr *)paddr, &cliaddr_len);

}

//

// if timeout occurs, nbytes=-1, nresult=1

// if socket error, nbyte=-1, nresult=-1

// if the other side has disconnected in either block mode or nonblock mode, nbytes=0, nresult=-1

// otherwise nbytes= the count of bytes sent , nresult=0

void SocketSend(HSocket hs, const char *ptr, int nbytes, transresult_t &rt)

{

rt.nbytes = 0;

rt.nresult = 0;

if(!ptr|| nbytes<1) return;

//Linux: flag can be MSG_DONTWAIT, MSG_WAITALL, 使用MSG_WAITALL的时候, socket 必须是处于阻塞模式下，否则WAITALL不能起作用

rt.nbytes = send(hs, ptr, nbytes, BLOCKREADWRITE|SENDNOSIGNAL);

if(rt.nbytes>0)

{

rt.nresult = (rt.nbytes == nbytes)?0:1;

}

else if(rt.nbytes==0)

{

rt.nresult=-1;

}

else

{

rt.nresult = GetLastSocketError();

rt.nresult = ETRYAGAIN(rt.nresult)? 1:-1;

}

}

// if timeout occurs, nbytes=-1, nresult=1

// if socket error, nbyte=-1, nresult=-1

// if the other side has disconnected in either block mode or nonblock mode, nbytes=0, nresult=-1

void SocketRecv(HSocket hs, char *ptr, int nbytes, transresult_t &rt)

{

rt.nbytes = 0;

rt.nresult = 0;

if(!ptr|| nbytes<1) return;

rt.nbytes = recv(hs, ptr, nbytes, BLOCKREADWRITE);

if(rt.nbytes>0)

{

return;

}

else if(rt.nbytes==0)

{

rt.nresult=-1;

}

else

{

rt.nresult = GetLastSocketError();

rt.nresult = ETRYAGAIN(rt.nresult)? 1:-1;

}

}

//  nbytes= the count of bytes sent

// if timeout occurs, nresult=1

// if socket error,  nresult=-1,

// if the other side has disconnected in either block mode or nonblock mode, nresult=-2

void SocketTrySend(HSocket hs, const char *ptr, int nbytes, int milliseconds, transresult_t &rt)

{

rt.nbytes = 0;

rt.nresult = 0;

if(!ptr|| nbytes<1) return;

int n;

CMyTimeSpan start;

while(1)

{

n = send(hs, ptr+rt.nbytes, nbytes, NONBLOCKREADWRITE|SENDNOSIGNAL);

if(n>0)

{

rt.nbytes += n;

nbytes -= n;

if(rt.nbytes >= nbytes) {    rt.nresult = 0;  break; }

}

else if( n==0)

{

rt.nresult= -2;

break;

}

else

{

n = GetLastSocketError();

if(ETRYAGAIN(n))

{

CLightThread::DiscardTimeSlice();

}

else

{

rt.nresult = -1;

break;

}

}

if(start.GetSpaninMilliseconds()>milliseconds)  { rt.nresult= 1; break;}

}

}

// if timeout occurs, nbytes=-1, nresult=1

// if socket error, nbyte=-1, nresult=-1

// if the other side has disconnected in either block mode or nonblock mode, nbytes=0, nresult=-1

void SocketTryRecv(HSocket hs, char *ptr, int nbytes, int milliseconds, transresult_t &rt)

{

rt.nbytes = 0;

rt.nresult = 0;

if(!ptr|| nbytes<1) return;

if(milliseconds>2)

{

CMyTimeSpan start;

while(1)

{

rt.nbytes = recv(hs, ptr, nbytes, NONBLOCKREADWRITE);

if(rt.nbytes>0)

{

break;

}

else if(rt.nbytes==0)

{

rt.nresult = -1;

break;

}

else

{

rt.nresult = GetLastSocketError();

if( ETRYAGAIN(rt.nresult))

{

if(start.GetSpaninMilliseconds()>milliseconds)  { rt.nresult= 1; break;}

CLightThread::DiscardTimeSlice();

}

else

{

rt.nresult = -1;

break;

}

}

}

}

else

{

SocketRecv(hs, ptr, nbytes, rt);

}

}

void SocketClearRecvBuffer(HSocket hs)

{

#if defined(_WIN32_PLATFROM_)

struct timeval tmOut;

tmOut.tv_sec = 0;

tmOut.tv_usec = 0;

fd_set    fds;

FD_ZERO(&fds);

FD_SET(hs, &fds);

int   nRet = 1;

char tmp[100];

int rt;

while(nRet>0)

{

nRet= select(FD_SETSIZE, &fds, NULL, NULL, &tmOut);

if(nRet>0)

{

nRet = recv(hs, tmp, 100,0);

}

}

#endif

#if defined(_LINUX_PLATFORM_)

char tmp[100];

while(recv(hs, tmp, 100, NONBLOCKREADWRITE)> 0);

#endif

}

int SocketBlock(HSocket hs, bool bblock)

{

unsigned long mode;

if( ISSOCKHANDLE(hs))

{

#if defined(_WIN32_PLATFROM_)

mode = bblock?0:1;

return ioctlsocket(hs,FIONBIO,&mode);

#endif

#if defined(_LINUX_PLATFORM_)

mode = fcntl(hs, F_GETFL, 0);                  //获取文件的flags值。

//设置成阻塞模式      非阻塞模式

return bblock?fcntl(hs,F_SETFL, mode&~O_NONBLOCK): fcntl(hs, F_SETFL, mode | O_NONBLOCK);

#endif

}

return -1;

}

int SocketTimeOut(HSocket hs, int recvtimeout, int sendtimeout, int lingertimeout)   //in milliseconds

{

int rt=-1;

if (ISSOCKHANDLE(hs) )

{

rt=0;

#if defined(_WIN32_PLATFROM_)

if(lingertimeout>-1)

{

struct linger  lin;

lin.l_onoff = lingertimeout;

lin.l_linger = lingertimeout ;

rt = setsockopt(hs,SOL_SOCKET,SO_DONTLINGER,(const char*)&lin,sizeof(linger)) == 0 ? 0:0x1;

}

if(recvtimeout>0 && rt == 0)

{

rt = rt | (setsockopt(hs,SOL_SOCKET,SO_RCVTIMEO,(char *)&recvtimeout,sizeof(int))==0?0:0x2);

}

if(sendtimeout>0 && rt == 0)

{

rt = rt | (setsockopt(hs,SOL_SOCKET, SO_SNDTIMEO, (char *)&sendtimeout,sizeof(int))==0?0:0x4);

}

#endif

#if defined(_LINUX_PLATFORM_)

struct timeval timeout;

if(lingertimeout>-1)

{

struct linger  lin;

lin.l_onoff = lingertimeout>0?1:0;

lin.l_linger = lingertimeout/1000 ;

rt = setsockopt(hs,SOL_SOCKET,SO_LINGER,(const char*)&lin,sizeof(linger)) == 0 ? 0:0x1;

}

if(recvtimeout>0 && rt == 0)

{

timeout.tv_sec = recvtimeout/1000;

timeout.tv_usec = (recvtimeout % 1000)*1000;

rt = rt | (setsockopt(hs,SOL_SOCKET,SO_RCVTIMEO,&timeout,sizeof(timeout))==0?0:0x2);

}

if(sendtimeout>0 && rt == 0)

{

timeout.tv_sec = sendtimeout/1000;

timeout.tv_usec = (sendtimeout % 1000)*1000;

rt = rt | (setsockopt(hs,SOL_SOCKET, SO_SNDTIMEO, &timeout,sizeof(timeout))==0?0:0x4);

}

#endif

}

return rt;

}

int InitializeSocketEnvironment()

{

#if defined(_WIN32_PLATFROM_)

WSADATA  Ws;

//Init Windows Socket

if ( WSAStartup(MAKEWORD(2,2), &Ws) != 0 )

{

return -1;

}

#endif

return 0;

}

void FreeSocketEnvironment()

{

#if defined(_WIN32_PLATFROM_)

WSACleanup();

#endif

}

//==============================================================================================================

//================================================================================================================

CSockWrap::CSockWrap(int tcpudp)

{

memset(&m_stAddr, 0, sizeof(sockaddr_in));

m_tcpudp = tcpudp;

m_hSocket = INVALIDSOCKHANDLE;

Reopen(false);

}

CSockWrap::~CSockWrap()

{

SocketClose(m_hSocket);

}

void CSockWrap::Reopen(bool bForceClose)

{

if (ISSOCKHANDLE(m_hSocket) && bForceClose) SocketClose(m_hSocket);

if (!ISSOCKHANDLE(m_hSocket) )

{

m_hSocket=SocketOpen(m_tcpudp);

}

}

void CSockWrap::SetAddress(const char *ip, int port)

{

GetAddressFrom(&m_stAddr, ip, port);

}

void CSockWrap::SetAddress(sockaddr_in *addr)

{

memcpy(&m_stAddr, addr, sizeof(sockaddr_in));

}

int CSockWrap::SetTimeOut(int recvtimeout, int sendtimeout, int lingertimeout)   //in milliseconds

{

return SocketTimeOut(m_hSocket, recvtimeout, sendtimeout, lingertimeout);

}

int CSockWrap::SetBufferSize(int recvbuffersize, int sendbuffersize)   //in bytes

{

int rt=-1;

if (ISSOCKHANDLE(m_hSocket) )

{

#if defined(_WIN32_PLATFROM_)

if(recvbuffersize>-1)

{

rt = setsockopt( m_hSocket, SOL_SOCKET, SO_RCVBUF, ( const char* )&recvbuffersize, sizeof( int ) );

}

if(sendbuffersize>-1)

{

rt = rt | (setsockopt(m_hSocket,SOL_SOCKET,SO_SNDBUF,(char *)&sendbuffersize,sizeof(int))==0?0:0x2);

}

#endif

}

return rt;

}

int CSockWrap::SetBlock(bool bblock)

{

return SocketBlock(m_hSocket, bblock);

}

transresult_t CSockWrap::Send(void *ptr, int nbytes)

{

transresult_t rt;

SocketSend(m_hSocket, (const char *)ptr, nbytes,rt);

return rt;

}

transresult_t CSockWrap::Recv(void *ptr, int nbytes )

{

transresult_t rt;

SocketRecv(m_hSocket, (char *)ptr, nbytes,rt);

return rt;

}

transresult_t CSockWrap::TrySend(void *ptr, int nbytes, int milliseconds)

{

transresult_t rt;

SocketTrySend(m_hSocket, (const char *)ptr, nbytes,milliseconds, rt);

return rt;

}

transresult_t CSockWrap::TryRecv(void *ptr, int nbytes, int  milliseconds )

{

transresult_t rt;

SocketTryRecv(m_hSocket, (char *)ptr, nbytes,milliseconds, rt);

return rt;

}

void CSockWrap::ClearRecvBuffer()

{

SocketClearRecvBuffer(m_hSocket);

}

weixin_39934063
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Windows Socket介绍
马大叔的工作日记
08-24 3116
在windows平台上，创建网络应用程序通常会借助于Windows Sockets ，Sockets译为套接字，一个套接字是通信的一端，客户与服务器之间即可通过套接字彼此通信。Windows Sockets是Windows下网络编程的规范，简称Winsock，虽然不同的应用服务和所使用的应用协议均有所不同，但所有的网络程序都能简化为一个简单的Winsock网络编程模型。 要想使用Winsock创
C++socket编程（四）：4.1 跨平台封装XTcp类接口
weixin_43907175的博客
01-05 826
首先我们需要定义一个XTcp类，在这个类的头文件中将创建socket，绑定socket,监听socket和accept通信接口封装起来，分别封装成一个接口。 XTcp.h如下代码： #pragma once #include <string> class XTcp { public: int CreateSocket(); bool Bind(unsigned short port); XTcp Accept(); //注意这个返回类型不是指针类型，我们需要在后面重新调用一个close
linux网络编程二十：socket选项：SO_RCVTIMEO和SO_SNDTIMEO
qinrenzhi的博客
07-10 1265
Linux网络编程 | Socket编程（一）：Socket的介绍、UDPSocket的封装、UDP服务器/客户端的实现
凌桓丶的博客
07-16 1213
目录套接字编程Sockaddr结构字节序地址转换常用套接字接口UDP的通信流程UDPSocket的封装UDP服务器UDP客户端 套接字编程 所谓套接字(Socket)，就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。 Sockaddr结构 在linux下，根据所使用的不同协议，又分为以下三种结构，在使用时，我们可以选择自己所需要的结构，通信时再将我们所使用的结构强转为sockaddr，这样就能保证数据格式的一致
跨平台socket封装
chuqingq的专栏
10-15 205
socket封装 ========== SocketWrapper.h ================ C语言的socket跨平台包装 https://github.com/maxiaojun/SocketWrapper/blob/master/SocketWrapper.h odsocket.[h,cpp] ================ C++封装 http://...
i.MX6ULL实现SOCKET网络通信【Linux C驱动】.zip
02-21
在本文中，我们将深入探讨如何在基于i.MX6ULL微处理器的系统上实现SOCKET网络通信，使用Linux C驱动程序。i.MX6ULL是NXP半导体公司生产的一款低功耗、高性能的ARM Cortex-A7单核处理器，广泛应用于嵌入式系统和...
Linux或Windows下判断socket连接状态
最新发布
03-01
在IT领域，网络编程是不可或缺的一部分，而Socket接口是实现跨平台网络通信的主要工具。无论是Linux还是Windows操作系统，开发者都需要了解如何判断一个Socket连接的状态，以便于处理异常情况，保证程序的稳定性和...
TCP_socket.zip_c linux socket_client.c_linux tcp client_socket_s
09-21
总之，"TCP_socket.zip_c linux socket_client.c_linux tcp client_socket_s"这个压缩包中的代码和头文件展示了如何在Linux环境下使用C语言编写TCP客户端和服务端程序。通过理解这些基本概念和技术，开发者可以构建...
1.Windows Socket+TCP服务器客户端1
08-08
在Windows平台上进行网络编程，Windows Socket（简称Winsock）提供了标准接口，允许应用程序与网络进行交互。本篇文章将深入探讨Windows Socket结合TCP协议构建服务器客户端的相关知识点。 首先，理解Winsock的基本...
linux设备驱动程序源码code.rar
06-08
Linux设备驱动程序是操作系统与硬件之间的重要桥梁，它允许Linux系统与硬件设备进行通信，从而实现对硬件资源的有效管理和高效利用。"linux设备驱动程序源码code.rar"这个压缩包很可能是包含了一些示例或者实际操作...
EasySocket:将Windows和Linux的socket库的使用封装成跨平台的类库，轻松使用socket创建连接
05-16
EasySocket 将Windows和Linux的socket库的使用封装成跨平台的类库，轻松使用socket。 组成 使用basicsocket 使用基础套接字库库，非常易用！ 使用： #include"EasySocket.h" 调用： using namespace SocketLib; ListeningSocket lsock; DataSocket dsock; lsock.Listen(5000);//在5000端口开始jiant dsock = lsock.Accept();//等待流入连接 只有5行代码就完成了Socket API的几十行代码的工作， 封装了socket为人诟病的历史接口等， 代码执行后dsock将包含一个套接字（如果有客户机与我们相连了的话），我们可以向客户机发送数据，并接受客户机的数据： char buffer[128] = "Hello clent
跨平台的socket库，windows-linux-socket
06-10
跨平台的socket库，windows-linux-socket
C++ socket 基本功能跨平台封装（好用）
12-06
真正可以使用的平台无关性的 C++ socket wrapper，没有做任何多余的事情，仅仅对 socket 的基本功能进行了平台无关性的封装，简洁原生。封装了：setoption, connect, close, send, recv, sendto, recvfrom， accept，bind 等基本方法。C++11 标准，macos/linux/windows 均进行了完全测试。
linux c++ tcp，udp封装
12-04
c++ tcp,udp监听、接收（select，类似ace的reactor）简单封装源码，及测试文件。。适用轻便，可扩展。。若没有安装qt可自己编写makefile自行编译 。。
Linux下将Socket封装为C++类
05-12
详细介绍了Linux系统下的Socket原理，并将Socket封装成了C++库，可以直接调用Socket类进行编程
LoadRunner WinSocket协议的扩展关联函数
探索软件测试之道
10-12 6212
本文节选自《LoadRunner虚拟用户开发指南》的第3章  深入Windows Sockets虚拟用户。本书信息：http://www.china-pub.com/195440 lrs_save_param_ex是lrs_save_param的扩展函数，包含了lrs_save_param的基本功能。其函数语法结构如下：int lrs_save_param_ex
Windows socket基础
ithzhang
12-28 2万+
Windows socket 基础        Windows socket是一套在Windows操作系统下的网络编程接口。它不是一种网络协议，而是一个开放的、支持多个协议的Windows下的网络编程接口 。      Windows socket是以Unix socket为基础，因此Windows socket中的许多函数名与Unix都是一样的。除此之外它还允许开发人员充分利用Wind
跨平台(Windows+Linux)的Socket通讯程序（一）—底层封装
热门推荐
guxch的专栏
03-30 3万+
【摘要】编写Socket通讯程序是一个老话题。本文重点介绍Windows平台和Linux平台Socket通讯的不同，采用C++，编制了一个简单的跨平台的Socket通讯库。 一、Socket通讯的基础知识 Socket通讯是两个计算机之间最基本的通讯方法，有TCP和UDP两种协议。关于这两种协议的区别，不少文章已有详述，这里，稍微总结一下： 1.TCP是面向连接的，是“流”式的，意即通讯两端
学会在Linux上编译调试C++项目
01-11
本课程主要针对没有或者很少写过linux上C++程序的同学， 本课程会教你如何从0基础开始，安装配置ubuntu虚拟机、使用GCC编译普通程序、动态库、静态库，编写复杂项目配置文件makefile，使用GDB工具调试C++程序。
Linux List.h深度解析：双向链表与数据结构实现
在Linux内核源码中，List.h文件是双向循环链表操作的核心部分，它位于`include/linux`目录下，用于构建复杂的数据结构，如队列和堆栈。双向循环链表相较于单链表，每个节点包含前后两个指针，提供了更灵活的插入和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值