对套接字简单的封装

最新推荐文章于 2024-06-26 23:13:50 发布
最新推荐文章于 2024-06-26 23:13:50 发布
阅读量1.6k 收藏
点赞数
文章标签： socket null struct stream tcp interface
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xiangsl/article/details/234705
版权

// SockObj.h: interface for the CSockObj class.
//
//

#if !defined(SOCKETOBJ_H)
#define SOCKETOBJ_H

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "../std.h"

const int SOCKET_SUCCESS = 0;//与SOCKET_ERROR对应的成功标志
const int _SOCKET_MAJOR_VERSION = 2;
const int _SOCKET_MINOR_VERSION = 2;
const int _LISTEN_COUNT = 200;
const DWORD _SHUTDOWN_RECV_TIMEOUT = 4*1000; // 完美关闭时延迟4秒
const DWORD _RECV_TIMEOUT = 120;// 120秒 接收超时
const DWORD _SEND_TIMEOUT = 120;// 120秒 发送超时
const DWORD _ACCEPT_TIMEOUT = 12;// 120秒 接受超时
const DWORD _BLOCKED_SNDRCV_SLEEP = 100; // 100毫秒(发生阻塞时等待[睡眠]时间)
const DWORD _RECV_BUFF_LEN = 8192;

bool GetIpBySock(SOCKET Sock, char* IP);

class CSockObj 
{
public:
 CSockObj();
 virtual ~CSockObj();

public:
 static void CleanupLibrary(void);
 static int InitLibrary(void);

protected:
 int m_nErrorNo;

public:
 //创建具有重叠IO能力的套接字
 SOCKET CreateSocket(int nAddressFamily= AF_INET,
  int nType= SOCK_STREAM,int nProtocol= 0);
 //设置套接字属性
 int SetSocketOption(SOCKET hSocket);

 //设置套接字是否为阻塞的
 int BlockSocket(SOCKET hSocket, BOOL bBlock);

 //绑定套接字
 int BindSocketEx(SOCKET hSocket,int nPort);
 //基本参数绑定套接字
 int BindSocket(SOCKET hSocket, struct sockaddr * pSocketAddress, int nAddrLen);
    //连接套接字
 int Connect(SOCKET hSocket, const char* pIP, int nPort);
 //监听套接字
 int ListenSocket(SOCKET hSocket, int nConnections=_LISTEN_COUNT);
 //阻塞ACCEPT，没有响应不返回
 SOCKET Accept_Block(SOCKET hSocket, struct sockaddr* pSocketAddress=NULL, int *nAddrLen=NULL);

 //异步ACCEPT，超时返回
 SOCKET Accept(SOCKET hSocket, struct sockaddr* pSocketAddress=NULL, int *nAddrLen=NULL,
  DWORD dwTimeout=_ACCEPT_TIMEOUT);

 //int RecvDataFrom_Block( SOCKET hSocket, struct sockaddr* pFrom,  int nAddrlen,
 // char* pszBuffer, int nBufferSize, DWORD dwTimeout=_RECV_TIMEOUT);
 //阻塞接收数据，该函数停止是在该端口被关闭(接收长度为0)，或出错误的时候
 int RecvData_Block(SOCKET hSocket, char *pszBuffer, int nBufferSize,
  DWORD dwTimeout= _RECV_TIMEOUT);

 int RecvData_Event(SOCKET hSocket, char *pszBuffer, int nBufferSize,
  DWORD dwTimeout= _RECV_TIMEOUT);
 //接收所有数据，注意在这个函数调用之前必须确认是否有接收消息到来
 int RecvData(SOCKET hSocket, char *pszBuffer, int nBufferSize);

 //发送全部缓冲区中数据，阻塞
 int SendData_Block(SOCKET hSocket,char const * pszBuffer, int nBufferSize,
  DWORD dwTimeout=_SEND_TIMEOUT);
 //发送数据，阻塞
 int Send_Block(SOCKET hSocket, char const * pszBuffer,  int nBufferSize,
  DWORD dwTimeout=_SEND_TIMEOUT);

 //发送一次缓冲区数据，不过有可能没有全部发送
 //int Send_Event(SOCKET hSocket, char const * pszBuffer, int nBufferSize,
 // DWORD dwTimeout=_SEND_TIMEOUT);
 //关闭套接字
 void CloseSocket(SOCKET hSocket, BOOL bHardClose=FALSE);

 inline void SetLastError(int iErrorCode)//设置错误代码
 {
  InterlockedExchange((LPLONG)&m_nErrorNo, iErrorCode);  
 };

 inline int GetLastError()//获取最近一次操作的错误代码
 {
  int iErrorNo;
  InterlockedExchange((LPLONG)&iErrorNo, m_nErrorNo);
  return (iErrorNo);
 };
};

#include "SockObj.h"

bool GetIpBySock(SOCKET Sock, char* IP)
{
 struct sockaddr sa;
 int len = sizeof(sa);

 if (0 != getpeername(Sock, &sa, &len))
  return false;

 for (size_t i =0; i<6; ++i) {
  IP[i] = sa.sa_data[i + 2];
 }

 return true;
}

CSockObj::CSockObj()
{
 
}

CSockObj::~CSockObj()
{
 //CleanupLibrary();
}

void CSockObj::CleanupLibrary(void)
{
 WSACleanup();
}

int CSockObj::InitLibrary(void)
{
 WSADATA WSD;
 WORD wVersionRequired = MAKEWORD( _SOCKET_MAJOR_VERSION, _SOCKET_MINOR_VERSION );
 ZeroMemory(&WSD,sizeof(WSADATA));
 int nErrorNo = WSAStartup(wVersionRequired, &WSD);
 if ( SOCKET_SUCCESS != nErrorNo )
 {
  //SetLastError( nErrorNo );
  return ( SOCKET_ERROR );
 }
 if ( LOBYTE( WSD.wVersion ) != _SOCKET_MINOR_VERSION ||
   HIBYTE( WSD.wVersion ) != _SOCKET_MAJOR_VERSION )
 {
  WSACleanup( );
  //SetLastError( WSAVERNOTSUPPORTED );
  return (SOCKET_ERROR);
 }
 //成功初始化
 return (SOCKET_SUCCESS);
}

//设置套接字属性
//入口:套接字
//出口:如果正确那么返回0，错误返回-1
int CSockObj::SetSocketOption(SOCKET hSocket)
{
    int nActivate = 1;
 //允许地址重用
    if (setsockopt(hSocket, SOL_SOCKET, SO_REUSEADDR, (const char *) &nActivate,
  sizeof(nActivate)) == SOCKET_ERROR )
    {
        SetLastError( WSAGetLastError() );
        return (SOCKET_ERROR);//return (-1)
    }
 /*
 bool bDontLinger=true;
    if (setsockopt(hSocket, SOL_SOCKET, SO_DONTLINGER, (const char *) &bDontLinger,
  sizeof(bDontLinger)) == SOCKET_ERROR )
    {
        SetLastError( WSAGetLastError() );
        return (SOCKET_ERROR);//return (-1)
    }
  
 linger Linger={0,0};
    if (setsockopt(hSocket, SOL_SOCKET, SO_LINGER, (const char *) &Linger,
  sizeof(Linger)) == SOCKET_ERROR )
    {
        SetLastError( WSAGetLastError() );
        return (SOCKET_ERROR);//return (-1)
    }*/
 return (SOCKET_SUCCESS);
}

//设置套接字是否为阻塞的
//入口:套接字,是否需要阻塞的
//出口:如果正确那么返回0，错误返回-1
int CSockObj::BlockSocket(SOCKET hSocket, BOOL bBlock/*FALSE*/)
{
 u_long IoctlLong = (bBlock) ? 0 : 1;
 if (ioctlsocket(hSocket, FIONBIO, &IoctlLong) == SOCKET_ERROR)
 {
  SetLastError( WSAGetLastError() );
  return (SOCKET_ERROR);
    }
 return (SOCKET_SUCCESS);
}

int CSockObj::Connect(SOCKET hSocket, const char* pIP, int nPort)
{
 SOCKADDR_IN sockAddr;
 ZeroMemory(&sockAddr,sizeof(sockAddr));
 
 sockAddr.sin_family   = AF_INET;
 sockAddr.sin_addr.s_addr = inet_addr(pIP);
 sockAddr.sin_port   = htons((u_short)nPort);

 return connect(hSocket, (struct sockaddr*)&sockAddr, sizeof(SOCKADDR_IN));
}

//关闭套接字
//入口:套接字,是否强行关闭(如果bHardClose==FALSE,那么接收剩余的数据后关闭连接)
void CSockObj::CloseSocket(SOCKET hSocket, BOOL bHardClose)
{
 //不需要捕获错误
 if (!bHardClose) //优雅关闭 Graceful close
 {
  //不再发送数据，对于TCP套接字，在所有的数据都发送完毕之后，
  //将发送一个 FIN ，通知接收方所有数据已经发送完毕。
  shutdown(hSocket, SD_SEND);

  //接收缓冲区有可能还有未接收的数据，在关闭套接字之前应该先
  //读取残留的数据。
  int  nRecvResult;
  HANDLE hSocketEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  //为残留数据提供的缓冲区
  char szBuffer[256];
  do
  {
   if (hSocketEvent != NULL)
   {
    //注册网络事件
    WSAEventSelect(hSocket,(WSAEVENT) hSocketEvent, FD_READ | FD_CLOSE);
    WSAWaitForMultipleEvents(1,&hSocketEvent, TRUE, _SHUTDOWN_RECV_TIMEOUT, TRUE);
    //清除网络事件
    WSAEventSelect(hSocket, (WSAEVENT) hSocketEvent, 0);
   }
   ZeroMemory(szBuffer,256);
   //接收残留数据
   nRecvResult = RecvData(hSocket, szBuffer, sizeof(szBuffer));
  } while (nRecvResult > 0);

  if (hSocketEvent != NULL)
   CloseHandle(hSocketEvent);
  //不再允许接收和发送
  shutdown(hSocket, SD_BOTH);
 }
 // 关闭套接字
 if (0 != hSocket)
  closesocket(hSocket);
}

// 绑定套接字
//入口:套接字,绑定的地址信息,长度
//出口:正确0，错误-1
int CSockObj::BindSocket(SOCKET hSocket, struct sockaddr * pSocketAddress,
        int nAddrLen)
{
 if (bind(hSocket, pSocketAddress, nAddrLen) == SOCKET_ERROR)
 {
  SetLastError( WSAGetLastError() );
  return (SOCKET_ERROR);
 }
 return (SOCKET_SUCCESS);
}

// 绑定套接字
//入口:套接字,端口号
//出口:正确0,错误-1
int CSockObj::BindSocketEx(SOCKET hSocket,int nPort)
{
 SOCKADDR_IN sockAddr;
 ZeroMemory(&sockAddr,sizeof(sockAddr));

 sockAddr.sin_family   = AF_INET;
 sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
 sockAddr.sin_port   = htons((u_short)nPort);

 return BindSocket(hSocket,(SOCKADDR *)&sockAddr, sizeof(sockAddr));
}

//创建具有重叠IO能力的套接字
//入口:协议，协议类型(TCP/U),协议
//出口:返回创建的重叠IO SOCKET
//注意:使用SOCKET()函数创建的套接字默认具有重叠IO能力
SOCKET CSockObj::CreateSocket(int nAddressFamily /*= AF_INET*/,
           int nType/*= SOCK_STREAM*/,
           int nProtocol/*= 0*/)
{
 SOCKET hSocket = WSASocket(nAddressFamily, nType, nProtocol,
  NULL,0,WSA_FLAG_OVERLAPPED); 
 if ( hSocket == INVALID_SOCKET )
 {
  SetLastError( WSAGetLastError() );
  return (INVALID_SOCKET);
 }

 //设置套接字选项
 if ( SOCKET_ERROR == SetSocketOption(hSocket) ) //设置属性失败
 {
  CloseSocket(hSocket, TRUE);
  return (INVALID_SOCKET);
 }
 return (hSocket);
}

//阻塞ACCEPT，没有响应不返回
//入口:套接字，主机地址，长度
//出口:正确返回端口号，否则返回INVALID_SOCKET
SOCKET CSockObj::Accept_Block(SOCKET hSocket, struct sockaddr* pSocketAddress,
         int *nAddrLen)
{
 if (INVALID_SOCKET == hSocket)
  return (INVALID_SOCKET);
 SOCKET hAccept = accept(hSocket, pSocketAddress, nAddrLen);

 //如果该端口错误
 if (INVALID_SOCKET == hAccept)
  SetLastError(WSAGetLastError());
 return hAccept;
}

SOCKET CSockObj::Accept(SOCKET hSocket, struct sockaddr* pSocketAddress, int *nAddrLen,
        DWORD dwTimeout)
{ 
 if (INVALID_SOCKET == hSocket)
  return (SOCKET_ERROR);

 //dwTimeout = 1000*1000;
 SOCKET hAccept;
 bool bNodelay;
 FD_SET fd = {1, hSocket};
 TIMEVAL tv = {dwTimeout, 0};
 unsigned long flag = 1;
 int nBytesSent=0;
 //printf("进入select%d time=%d/r/n", hSocket,dwTimeout);
 int iError = select(0, &fd, NULL, NULL, &tv);
 if(iError == 0)
 {
  //printf("离开select/r/n");
  goto CLEAR;//选择发送超时
 }else if (SOCKET_ERROR == iError)
 {
  //printf("select error/r/n");
 }else
 {
  hAccept = accept(hSocket, pSocketAddress, nAddrLen);
  //如果该端口错误
  if (INVALID_SOCKET == hAccept)
   SetLastError(WSAGetLastError());  
  else
  {
   setsockopt(hAccept,IPPROTO_TCP,TCP_NODELAY,(char *)&bNodelay,sizeof(bNodelay));
   //ioctlsocket(hAccept, FIONBIO, &flag);
  }
  return hAccept;
 }
CLEAR:
 SetLastError(WSAGetLastError());//超时
 return(INVALID_SOCKET);
}

//监听套接字
//入口:套接字,接入的等待队列长度
//出口:SOCKET_ERROR/SOCKET_SUCCESS
int CSockObj::ListenSocket(SOCKET hSocket, int nConnections)
{
 if(listen(hSocket, nConnections) == SOCKET_ERROR)
 {
  SetLastError( WSAGetLastError() );
  return (SOCKET_ERROR);
 }
 return (SOCKET_SUCCESS);
}

//阻塞接收数据，该函数停止是在该端口被关闭(接收长度为0)，或出错误的时候
//入口:套接字,接收缓冲区和长度,超时数
//出口:正确返回接收长度,否则返回SOCKET_ERROR
int CSockObj::RecvData_Block(SOCKET hSocket, char *pszBuffer, int nBufferSize,
  DWORD dwTimeout)
{
 if (hSocket==INVALID_SOCKET || pszBuffer==NULL)
  return (SOCKET_ERROR);

 //dwTimeout = 1000*1000;
 FD_SET fd = {1, hSocket};
 TIMEVAL tv = {dwTimeout, 0};
 int nBytesReceived=0;
 int nSelectRet = select(0, &fd, NULL, NULL, &tv);
 //返回大于0的值时,表示与条件相符的SOCKET数
 //返回0表示超时
 //失败时返回SOCKET_ERROR
 if (0 == nSelectRet  || //超时
  SOCKET_ERROR == nSelectRet)//套接字错误
  goto CLEAR;

 if((nBytesReceived = recv(hSocket, pszBuffer, nBufferSize, 0)) == SOCKET_ERROR)
  goto CLEAR;
 //成功时返回收到的字节数.
 //如果连接被中断则返回0
 //失败时返回 SOCKET_ERROR
 return nBytesReceived;

CLEAR:
 SetLastError(WSAGetLastError());//超时
 return(SOCKET_ERROR);
}

//接收所有数据，注意在这个函数调用之前必须确认是否有接收消息到来
//入口:套接字,数据缓冲区,缓冲区大小
//出口:如果正确那么返回接收的字节数量，错误返回错误代码
int CSockObj::RecvData(SOCKET hSocket, char *pszBuffer, int nBufferSize)
{
 if (hSocket==INVALID_SOCKET || pszBuffer==NULL)
  return (SOCKET_ERROR);

 DWORD  dwRtxBytes = 0,
    dwRtxFlags = 0;
 WSABUF  WSABuff;

 //清空缓冲
 ZeroMemory(&WSABuff,sizeof(WSABUF));

 WSABuff.len = nBufferSize;
 WSABuff.buf = pszBuffer;
 //如果正确就返回本次接收的字节个数，如果错误返回错误号码(负数)
 return ((WSARecv(hSocket, &WSABuff, 1, &dwRtxBytes, &dwRtxFlags,NULL, NULL)
  == SOCKET_SUCCESS) ? (int) dwRtxBytes : -WSAGetLastError());
}

//接收数据(阻塞直至收到数据为止)
//入口:套接字,数据缓冲区,缓冲区大小,超时数
//出口:如果正确那么返回接收的字节数量，错误返回错误代码
int CSockObj::RecvData_Event(SOCKET hSocket, char *pszBuffer,
          int nBufferSize, DWORD dwTimeout)
{
 if (hSocket==INVALID_SOCKET || pszBuffer==NULL)
  return (SOCKET_ERROR);

 HANDLE hReadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 if (hReadEvent == NULL)
 {
  SetLastError( (int)GetLastError() );
  return ( SOCKET_ERROR );
 }

 int  nRecvBytes = 0;
 DWORD dwWaitResult ;
 for (;;)
 {
  // 注册FD_READ | FD_CLOSE 事件
  // (因为可能在等待FD_READ事件中，对方关闭套接字，所以要关注FD_CLOSE)
  if( WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, FD_READ | FD_CLOSE)
   == SOCKET_ERROR)
  {
   CloseHandle(hReadEvent);
   SetLastError( WSAGetLastError() );
   return (SOCKET_ERROR);
  }
 
  // 等等FD_READ | FD_CLOSE事件的发生
  dwWaitResult = WSAWaitForMultipleEvents(1, &hReadEvent, TRUE,dwTimeout, TRUE);

  if (dwWaitResult != WSA_WAIT_EVENT_0)
  {
   // 清除事件
   WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
   CloseHandle(hReadEvent);
   SetLastError( WSAGetLastError() );
   return (SOCKET_ERROR);
  }
  
  //
  /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该
  ///   进一步检查网络是否发生错误
  ///
  WSANETWORKEVENTS NetEvent;
  if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hReadEvent,&NetEvent) == SOCKET_ERROR)
  {
   // 清除事件
   WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
   CloseHandle(hReadEvent);
   SetLastError( WSAGetLastError() );
   return (SOCKET_ERROR);
  }
  //判断发生了什么事件 FD_READ 或 FD_CLOSE 
  if( ( NetEvent.lNetworkEvents == FD_CLOSE ) ||
    ( NetEvent.lNetworkEvents == FD_READ &&
      NetEvent.iErrorCode[FD_READ_BIT] !=0 ) ) // 发生错误
  {   
   // 清除事件
   WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
   CloseHandle(hReadEvent);
   SetLastError(WSAGetLastError() );
   return (SOCKET_ERROR);
  }
  
  // 清除事件
  WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
 
  // 接收数据
  printf("socket[%d] into RecvData/r/n", hSocket);
  if ((nRecvBytes = RecvData(hSocket, pszBuffer, nBufferSize)) >= 0)
   break; // 跳出循环
  printf("socket[%d] into RecvData, nRecvBytes=%d /r/n", hSocket, nRecvBytes);
  //Recv返回的是错误代码的负数，所以需要调转过来
  int nErrorCode = -nRecvBytes;

  if ( nErrorCode != WSAEWOULDBLOCK ) //太多的未完成重叠操作
  {
   CloseHandle(hReadEvent);
   SetLastError( nErrorCode );
   return (SOCKET_ERROR);
  }
  //阻塞住了
  Sleep(_BLOCKED_SNDRCV_SLEEP);
    }
    CloseHandle(hReadEvent);
 printf("socket[%d] out RecvData/r/n", hSocket);
    return (nRecvBytes);
}

//发送数据，阻塞
//入口:套接字，发送的字串,字串长度，超时值
int CSockObj::Send_Block(SOCKET hSocket,char const * pszBuffer,
  int nBufferSize, DWORD dwTimeout)
{
 if (hSocket==INVALID_SOCKET || pszBuffer==NULL)
  return (SOCKET_ERROR);

 FD_SET fd = {1, hSocket};
 TIMEVAL tv = {dwTimeout, 0};
 int nBytesSent=0;
 if(select(0, NULL, &fd, NULL, &tv) == 0)
  goto CLEAR;//选择发送超时
 if((nBytesSent = send(hSocket, pszBuffer, nBufferSize, 0)) == SOCKET_ERROR)
  goto CLEAR;//发送出错误
 return nBytesSent;

CLEAR:
 SetLastError(WSAGetLastError());//超时
 return(SOCKET_ERROR);
}

//发送全部缓冲区中数据，阻塞
//入口:套接字，发送的字串,字串长度，超时值
//出口:正确返回发送的字节数量，错误返回SOCKET_ERROR
int CSockObj::SendData_Block(SOCKET hSocket,char const * pszBuffer,
  int nBufferSize, DWORD dwTimeout)

{
 if (hSocket==INVALID_SOCKET || pszBuffer==NULL)
  return (SOCKET_ERROR);

 int nBytesSent = 0;
 int nBytesThisTime;
 const char* pszTemp = pszBuffer;
 do {
  nBytesThisTime = Send_Block(hSocket,pszTemp, nBufferSize-nBytesSent, dwTimeout);
  if(nBytesThisTime<0)
   return(SOCKET_ERROR);
  //如果一次没有发送成功
  nBytesSent += nBytesThisTime;
  //改变当前字符指针
  pszTemp += nBytesThisTime;
 } while(nBytesSent < nBufferSize);
 return nBytesSent;
}

xiangsl
关注
易语言取封包套接字IP端口模块
08-09
易语言，作为中国本土的编程语言，提供了一种简单易用的方式来处理网络通信问题，其中包括取封包套接字IP端口的操作。本文将详细讲解易语言中的套接字模块，以及如何通过套接字获取封包的IP和端口信息。 首先，我们...
Python socket 套接字实现通信详解
12-31
因为操作系统的接口远比我们想象的要丑陋复杂,使用操作系统交换数据,非诚繁琐,,开发者们只能想办法让一个中间人和他们打交道,来简单的实现数据交换,那么就是socket套接字.它的作用就是:与操作系统之间数据交换将这些...
网络通信socket套接字函数封装
XITMan的博客
09-07 441
写网络通信的时候发现这个流程是差不多的不管是udp还是tcp通信都有很多地方是相同的，那么能不能把这些流程封装一下，下次再写的时候就可以节约很多的时间。所以代码如下： network.h #ifndef NETWORK_H #define NETWORK_H #include <stdio.h> #include <stdbool.h> #include <netinet/in.h> // 网络通信结构 typedef struct NetWork { int so
封装的一个套接字----服务端
weixin_33754913的博客
07-17 140
using System;using System.Collections.Generic;using System.Text;using System.Net.Sockets;using System.Threading;namespace EarlyServer{    public class ConnectClient : IDisposable    {        Member#re...
Linux socket编程（一） 对套接字操作的封装
09-04 145
以前写的，现在回顾一下： 下面是对socket操作的封装，因为在Linux下写中文到了windows里面会乱码，所以注释用英文来写，有空再查下解决方法吧 socket.h #ifndef SOCKET_H #define SOCKET_H #include <sys/socket.h> #include <sys/types.h> #incl...
自己封装的一个 TCP 套接字基类
firebird321的专栏
04-27 1553
TcpSocket.h   #ifndef __CTCPSOCKET_H__ #define __CTCPSOCKET_H__   #include enum OVER_TYPE { RECV_OVERLAPPED, SEND_OVERLAPPED, BOTH_OVERLAPPED }; enum OPER_TYPE { RECV_POSTED, SEND_POSTED }; e
套接字通信类的封装
最新发布
qq_55882840的博客
06-26 1105
/ 创建监套接字return -1;printf("套接字创建成功, fd=%d\n", fd);return fd;// 绑定本地的IP和端口return -1;printf("套接字绑定成功, ip: %s, port: %d\n",return ret;// 设置监听return -1;printf("设置监听成功...\n");return ret;// 阻塞并等待客户端的连接elsereturn -1;
socket套接字封装
04-06
### Socket套接字封装知识点详解 #### 一、概述 在计算机网络编程中，套接字（Socket）是网络通信的基础。本篇文章介绍了一个用C++语言编写的Socket封装库，该库旨在简化网络编程的过程，使开发人员能够更加轻松地...
C/C++ 套接字通信类的封装
编程与实战的博客
12-08 1404
在掌握了基于 TCP 的套接字通信流程之后，为了方便使用，提高编码效率，可以对通信操作进行封装，本着有浅入深的原则，先基于 C 语言进行面向过程的函数封装，然后再基于 C++ 进行面向对象...
MFC套接字编程
05-26
1. 套接字概念：套接字是网络上的两个进程之间进行通信的一种机制，类似于通信管道。在网络层，它们是IP地址和端口号的组合，而在传输层，套接字可以是TCP（传输控制协议）或UDP（用户数据报协议）。 2. MFC中的套...
Linux网络套接字类封装
shanzhizi的专栏
11-22 1906
相信大家已经阅读过上篇关于本地套接字的有关内容，网络套接字与其基本类似，所以这里我不想再重复的写些东西了，需要这些东西的朋友们，请去看我的上一篇帖子。这里主要给大家介绍下网络套接字与本地套接字在意义和使用上的区别，再给出几个网络套接字用于进程通信的 C++ 类，供大家学习使用。 网络套接字可以通过网络，实现在不同主机上的进程通信。当然，如果你愿意，也完全可以实现同一台主机上的进程通信（将目的
网络编程socket套接字函数的封装
weihuanzhen_yeah_net的专栏
01-05 225
背景 socke相关的函数简单到几乎没有什么错误处理，我们知道，系统调用不能保证每次都成功，必须进行出错处理，这样一方面可以保证程序逻辑正常，另一方面可以迅速得到故障信息。 为使错误处理的代码不影响主程序的可读性，我们把与socket相关的一些系统函数加上错误处理代码包装成新的函数，做成一个模块 base_socket_wrap.h 文件 #ifndef __SOCKET_WRAP_H_ #define __SOCKET_WRAP_H_ void perr_exit(const char *s)
windows下套接字编程，socket的简单封装
weixin_45712666的博客
06-20 325
socket的简单封装 计网编程实验的一部分。 因为一直用C++，感觉原生的socket很麻烦，就简单封装了一下。2021年6月20日 Visual Studio 2019 C++ 使用范例 server #include <iostream> #include "socket.h" using namespace win_socket; int main() { load_socket_dll dll; ipv4::socket_t s_socket("127.0.0.1",
使用原始套接字完成网络数据包的封装和发送
icquu的博客
12-18 295
使用此程序主要用于网络调试目的和实验项目， 请勿非法使用。程序可用来封装特定的arp回应包。
套接字编程
笔记|思路|总结
06-18 3244
socke本身有“插座”的意思，在环境下，用于表示进程间网络通信的特殊文件类型。本质为内核借助缓冲区形成的伪文件。既然是文件，那么我们就可以使用文件描述符来引用套接字。与管道类似，系统将套接字封装成文件的目的是为了统一接口，使得读写套接字和读写文件的操作一致。管道与套接字的区别是：在TCP/IP协议中，“IP地址+TCP或UDP端口号”唯一标识网络通讯中的一个进程。“IP地址+端口号”就对应一个。欲建立连接的两个进程各自有一个来标识，那么这两个组成的就唯一标识一个连接。因此可以用来描述网络连接的一对一关系。
linux socket：套接字操作的封装
weixin_45452206的博客
02-11 189
套接字操作起来流程比较复杂，刚开始接触不久的话如果要实现多线程等操作会很混乱，参考了一位博主的代码进行了套接字的封装：https://www.cnblogs.com/-Lei/archive/2012/09/04/2670942.html mySocket.h #include <iostream> #include <unistd.h> #include <arpa...
winsock2套接字封装使用
qq_18604483的博客
10-10 455
class CSoCket { protected:  SOCKET m_hSocket; public:  CSoCket();  virtual ~CSoCket();  BOOL Listen(int n = 5);  BOOL Accept(CSoCket& rConnectedSocket,LPSTR szIP = NULL,UINT* nPort = NULL);
套接字通信类的封装(包括错误处理，读写处理 ，通信处理,tcp粘包问题)
这是一个c++热爱者的博客哟
10-31 163
C// 创建监套接字return -1;printf("套接字创建成功, fd=%d\n", fd);return fd;// 绑定本地的IP和端口return -1;printf("套接字绑定成功, ip: %s, port: %d\n",return ret;// 设置监听return -1;printf("设置监听成功...\n");return ret;// 阻塞并等待客户端的连接elsereturn -1;
C++ Socket 简单封装
weixin_30455365的博客
05-14 429
以下代码一部分来自于《网络多人游戏架构与编程》， 其它的都是我瞎写的。 备忘。 一个简单的Socket封装，没有做什么高级的操作（比如IO完成端口等等）。 1 #pragma once 2 3 #include <iostream> 4 #include <memory> 5 #include <string> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值