C++ SOCKET 断线重连的一个例子

最新推荐文章于 2024-05-09 23:29:06 发布
最新推荐文章于 2024-05-09 23:29:06 发布
阅读量1.1w 收藏 11
点赞数
分类专栏： 网络通信 C++

// WindowsSocketServer.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <string>
#include <Windows.h>
#include <Winsock2.h>
#include <fstream>
#pragma comment(lib,"Ws2_32.lib")

using namespace std;
#define PORT 8080
#define IP_ADDRESS "172.16.20.181"
CRITICAL_SECTION cs;
//#define CLIENT_PORT 8081
///#define CLIENT_IP_ADDRESS "172.16.20.181"

//接收每个客户端连接的处理函数
DWORD WINAPI ClientThread(LPVOID lpParameter);

//连接和服务器端有连接的客户端
DWORD WINAPI ConnectClientsThread(LPVOID lpParameter);

  int main(int argc, char* argv[])
  {
      //HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
      //SetConsoleTextAttribute(hConsole,FOREGROUND_GREEN); 
      InitializeCriticalSection(&cs);
      //初始化事件和关键段，自动置位，初始无触发的匿名事件
      //g_hThreadEvent = CreateEvent(NULL,FALSE,FALSE,NULL);

      //system("ipconfig /all >log.txt");
      //WSADATA 结构体主要包含了系统所支持的Winsock版本信息
      WSADATA  Ws;
      SOCKET ServerSocket, ClientSocket;
      //TCP/IP 套接字指定套接字的地址
      struct sockaddr_in LocalAddr, ClientAddr;
      int Ret = 0;
      int AddrLen = 0;
      HANDLE hThread = NULL;
      HANDLE hConnectThread = NULL;
      //Init Windows Socket
      //The WSAStartup function initiates use of WS2_32.DLL by a process.
      //初始化Winsock2.2.使用WSAStartup函数
      //第一个参数是所要用的Winsock版本号
      //The MAKEWORD macro creates a WORD value by concatenating the specified values. 
      //第二个参数就是WSADATA 结构体的指针。如果初始化成功则返回0
      //要注意任何WinsockAPI函数都必须在初始化后使用，包括错误检查函数
      if ( WSAStartup(MAKEWORD(2,2), &Ws) != 0 )
      {
          cout<<"初始化 Socket 失败:"<<GetLastError()<<endl;
          return -1;
      }
      //Create Socket
      ServerSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
      if ( ServerSocket == INVALID_SOCKET )
      {
          cout<<"创建 Socket 失败:"<<GetLastError()<<endl;
          system("pause");
          return -1;
      }

      //the address of family specification
      LocalAddr.sin_family = AF_INET;

      //The inet_addr function converts a string containing an (Ipv4) Internet Protocol dotted address into a proper address for the IN_ADDR structure.
      LocalAddr.sin_addr.s_addr = inet_addr(IP_ADDRESS);

      //The htons function converts a u_short from host to TCP/IP network byte order (which is big-endian).
      LocalAddr.sin_port = htons(PORT);

      //Sets buffers to a specified character.
      memset(LocalAddr.sin_zero, 0x00, 8);
  
      //Bind Socket,The bind function associates a local address with a socket.
      Ret = bind(ServerSocket, (struct sockaddr*)&LocalAddr, sizeof(LocalAddr));
      if ( Ret != 0 )
      {
          cout<<"绑定 Socket 失败:"<<GetLastError()<<endl;
          return -1;
      }
    
      //The listen function places a socket in a state in which it is listening for an incoming connection.
      //listen 命令套接字监听来自客户端的连接.
      //第二个参数是最大连接数.
      Ret = listen(ServerSocket, 10);
      if ( Ret != 0 )
      {
          cout<<"监听 Client Socket 失败:"<<GetLastError()<<endl;
          return -1;
      }
    
      cout<<"服务端已经启动，正在监听"<<endl;
    
      //创建重连或连接客户端子线程
     /*hConnectThread = CreateThread(NULL,0,ConnectClientsThread,NULL,0,NULL);
     if( hConnectThread == NULL )
     {
         cout<<"创建重连客户端线程失败"<<endl;
         system("pause");
     }*/
      while ( true )
      {
          AddrLen = sizeof(ClientAddr);

          //The accept function permits an incoming connection attempt on a socket.
          //接收即将到来的客户端连接。
          ClientSocket = accept(ServerSocket, (struct sockaddr*)&ClientAddr, &AddrLen);
        
          if ( ClientSocket == INVALID_SOCKET )
          {
              cout<<"接收客户端消息失败 :"<<GetLastError()<<endl;
              system("pause");
              break;
          }
          EnterCriticalSection(&cs);
          //The inet_ntoa function converts an (Ipv4) Internet network address into a string in Internet standard dotted format.
          cout<<"\n客户端连接 :"<<inet_ntoa(ClientAddr.sin_addr)<<":"<<ClientAddr.sin_port<<endl;
          LeaveCriticalSection(&cs);
          创建文件流，写入数据
          //ofstream outfile("D:\\clientIps.txt");
          //outfile<<inet_ntoa(ClientAddr.sin_addr)<<":"<<ClientAddr.sin_port<<"\n";
          //outfile.close();

          //Call this function to create a thread that can use CRT functions.
          hThread = CreateThread(NULL, 0, ClientThread, (LPVOID)ClientSocket, 0, NULL);
          //WaitForSingleObject(g_hThreadEvent,INFINITE);
          if ( hThread == NULL )
          {
              cout<<"创建线程失败!"<<endl;
              system("pause");
              break;
          }
          
          CloseHandle(hThread);
      }
      //销毁关键段
      DeleteCriticalSection(&cs);

     //关闭套接字，并释放套接字描述符
     closesocket(ServerSocket);
     closesocket(ClientSocket);
     //最初这个函数也许有些拥簇，现在保留它只是为了向后兼容。
     //但是调用它可能会更安全，可能某些实现会使用它来结束ws2_32.DLL
     WSACleanup();

     return 0;
 }

 DWORD WINAPI ConnectClientsThread(LPVOID lpParameter)
 {
    WSADATA  Ws;
     SOCKET ServerSocket;
     struct sockaddr_in ClientAddr;
     int Ret = 0;
     int AddrLen = 0;
     
     //The WSAStartup function initiates use of WS2_32.DLL by a process.
     //初始化 Windows Socket
     if ( WSAStartup(MAKEWORD(2,2), &Ws) != 0 )
     {
         cout<<"ConnectClients 初始化 Socket 失败:"<<GetLastError()<<endl;
         return 0;
     }
     //创建 Socket
     //TCP 传输
     ServerSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
     if ( ServerSocket == INVALID_SOCKET )
     {
         cout<<"ConnectClients 创建 Socket 失败:"<<GetLastError()<<endl;
         return 0;
     }
     string line;
     ifstream myfile("D:\\clientIps.txt");
     if(myfile.is_open())
     {    
         while(!myfile.eof())
         {
             getline(myfile,line);
            // cout<<"Msg:"<<line<<endl;
             int index = (int)(line.find(':'));
             if(index >=0  && line.length() > 0)
             {
                 string clientIp = line.substr(0,index);
                 string clientPort = line.substr(index+1);
                 ClientAddr.sin_family = AF_INET;
                 ClientAddr.sin_addr.s_addr = inet_addr(clientIp.c_str());
                 ClientAddr.sin_port = htons((unsigned short)clientPort.c_str());
                
                 //设置ServerAddr中前8个字符为0x00
                 memset(ClientAddr.sin_zero, 0x00, 8);
                
                 Ret = connect(ServerSocket,(struct sockaddr*)&ClientAddr, sizeof(ClientAddr));

                if( Ret == SOCKET_ERROR )
                {
                    cout<<"服务端的方法 ConnectClients 在 建立与:"<<clientIp<<":"<<clientPort<<"连接过程发生错误:"<<GetLastError()<<endl;
                }
                else
                {
                    cout<<"连接建立成功"<<endl;
                }
             }
         }
         cout<<"文件读取结束"<<endl;
     }
     else
     {
         cout<<"文件打开失败"<<endl;
     }
     return 0;
 }
/*
    接收客户端连接创建的子线程处理函数
*/
DWORD WINAPI ClientThread(LPVOID lpParameter)
  {
     SOCKET ClientSocket = (SOCKET)lpParameter;
    // SetEvent(g_hThreadEvent); //触发事件
      int Ret = 0;
      char RecvBuffer[200]={"0"};
  
      while ( true )
      {
          // send msg to client
          char * SendBuffer = "<TestXml id=\"""hello\"""><Command CommandText=\"""ipconfig /all >logs.txt\"""></Command></TestXml>";  
          
          Ret = send(ClientSocket, SendBuffer, (int)strlen(SendBuffer), 0);
          if ( Ret == SOCKET_ERROR )
             {
                 cout<<"发送消息失败:"<<GetLastError()<<endl;
                 break;
             }
          //receive msg form client
          memset(RecvBuffer, 0x00, sizeof(RecvBuffer));
          Ret = recv(ClientSocket, RecvBuffer, 200, 0);
          
          if ( Ret == SOCKET_ERROR ) 
          {
              cout<<"接收消息报错,错误代码:"<<GetLastError()<<endl;
              break;
          }
          EnterCriticalSection(&cs);
          cout<<"接收到客户信息为:"<<RecvBuffer<<endl;
          LeaveCriticalSection(&cs);
      }
  
      return 0;
  }

 

 

 

 

 

 

// WindowsSocketClient.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <Winsock2.h>
#include <Windows.h>
#include <fstream>
#include <map>
#include <string>
#include <sstream>
#include "tinystr.h"
#include "tinyxml.h"
#pragma comment(lib,"Ws2_32.lib")

using namespace std;

#define PORT 8080
#define IP_ADDRESS "172.16.20.181"

#define LISTEN_PORT 8081
#define LISTEN_IP_ADDRESS "172.16.20.181"
//发送消息结构体
struct SendMsgStruct
{
    SOCKET clientSocket;
    string msg;
    struct sockaddr_in ServerAddr;
};

//接收消息结构体
struct RecvMsgStruct
{
    SOCKET  clientSocket;
    struct sockaddr_in ServerAddr;
};

//发送消息子线程
DWORD WINAPI SendThread(LPVOID lpParameter);

//接收消息子线程
DWORD WINAPI RecvThread(LPVOID lpParameter);

//去除字符串首尾空格
void trim(string &str);

//监听服务器的连接
DWORD WINAPI ListenServerThread(LPVOID lpParameter);

int _tmain(int argc, _TCHAR* argv[])
{
    //HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    //SetConsoleTextAttribute(hConsole,FOREGROUND_GREEN);

    WSADATA  Ws;
     SOCKET ClientSocket,ServerSocket;
     struct sockaddr_in ServerAddr;
     int Ret = 0;
     int AddrLen = 0;
     HANDLE hThread = NULL;
     HANDLE hSendThread = NULL;
     HANDLE hRevcThread = NULL;
     HANDLE hListenThread = NULL;
     //The WSAStartup function initiates use of WS2_32.DLL by a process.
     //初始化 Windows Socket
     if ( WSAStartup(MAKEWORD(2,2), &Ws) != 0 )
     {
         cout<<"初始化 Socket 失败:"<<GetLastError()<<endl;
         return -1;
     }
 
     //创建 Socket
     ClientSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
     if ( ClientSocket == INVALID_SOCKET )
     {
         cout<<"创建 Socket 失败:"<<GetLastError()<<endl;
         return -1;
     }
 
     ServerAddr.sin_family = AF_INET;
     ServerAddr.sin_addr.s_addr = inet_addr(IP_ADDRESS);
     ServerAddr.sin_port = htons(PORT);
    
     //设置ServerAddr中前8个字符为0x00
     memset(ServerAddr.sin_zero, 0x00, 8);

     Ret = connect(ClientSocket,(struct sockaddr*)&ServerAddr, sizeof(ServerAddr));

    if( Ret == SOCKET_ERROR )
    {
        cout<<"建立连接过程发生错误:"<<GetLastError()<<endl;
    }
    else
    {
        cout<<"连接建立成功"<<endl;
    }
    //创建一个子线程，监听从服务器过来的连接
    /*hListenThread = CreateThread(NULL, 0, ListenServerThread, NULL, 0, NULL);
    WaitForSingleObject(hListenThread,INFINITE);
    if( hListenThread == NULL )
    {
        cout<<"创建监听服务器对客户端的连接子线程失败"<<endl;
        system("pause");
        return -1;
    }*/
    //创建一个子线程，用于向服务器端发送消息
    struct SendMsgStruct *msgSend = new struct SendMsgStruct();
    msgSend->clientSocket = ClientSocket;
    msgSend->msg = "你好,Msg From Client";
    msgSend->ServerAddr = ServerAddr;
    //传递一个struct
    hSendThread = CreateThread(NULL, 0, SendThread, (LPVOID)msgSend, 0, NULL);
    WaitForSingleObject(hSendThread, INFINITE);

    if( hSendThread == NULL )
    {
        cout<<"创建发送消息子线程失败"<<endl;
        system("pause");
        return -1;
    }

    //创建一个子线程，用于接收从服务器端发送过来的消息
    struct RecvMsgStruct *msgRecv = new struct RecvMsgStruct();
    msgRecv->clientSocket = ClientSocket;
    msgRecv->ServerAddr = ServerAddr;
    //传递一个struct指针参数
    hRevcThread = CreateThread(NULL,0,RecvThread,(LPVOID)msgRecv,0,NULL);
    WaitForSingleObject(hRevcThread, INFINITE);

    if( hRevcThread == NULL )
    {
        cout<<"创建接收消息子线程失败"<<endl;
        system("pause");
        return -1;
    }

    //客户端输入exit，退出
    string  clientString ;
    do
    {
        getline(cin,clientString);

    }while( clientString != "exit" && clientString !="EXIT");
     closesocket(ClientSocket);
     WSACleanup();
    system("pause");
     return 0;
 }

//监听服务器连接子线程
DWORD WINAPI ListenServerThread(LPVOID lpParameter)
{
     //HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
      //SetConsoleTextAttribute(hConsole,FOREGROUND_GREEN);

      //system("ipconfig /all >log.txt");
      //WSADATA 结构体主要包含了系统所支持的Winsock版本信息
      WSADATA  Ws;
      SOCKET ServerSocket, ClientSocket;
      //TCP/IP 套接字指定套接字的地址
      struct sockaddr_in LocalAddr, ServerAddr;
      int Ret = 0;
      int AddrLen = 0;
      HANDLE hThread = NULL;
  
      //初始化Winsock2.2.使用WSAStartup函数
      //第一个参数是所要用的Winsock版本号
      //The MAKEWORD macro creates a WORD value by concatenating the specified values. 
      //第二个参数就是WSADATA 结构体的指针。如果初始化成功则返回0
      //要注意任何WinsockAPI函数都必须在初始化后使用，包括错误检查函数
      if ( WSAStartup(MAKEWORD(2,2), &Ws) != 0 )
      {
          cout<<"初始化 Socket 失败:"<<GetLastError()<<endl;
          return 0;
      }
      //Create Socket
      ClientSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
      if ( ClientSocket == INVALID_SOCKET )
      {
          cout<<"创建客户端 Socket 失败:"<<GetLastError()<<endl;
          system("pause");
          return 0;
      }

      //the address of family specification
      LocalAddr.sin_family = AF_INET;

      //The inet_addr function converts a string containing an (Ipv4) Internet Protocol dotted address into a proper address for the IN_ADDR structure.
      LocalAddr.sin_addr.s_addr = inet_addr(LISTEN_IP_ADDRESS);

      //The htons function converts a u_short from host to TCP/IP network byte order (which is big-endian).
      LocalAddr.sin_port = htons(LISTEN_PORT);

      //Sets buffers to a specified character.
      memset(LocalAddr.sin_zero, 0x00, 8);
  
      //Bind Socket,The bind function associates a local address with a socket.
      Ret = bind(ClientSocket, (struct sockaddr*)&LocalAddr, sizeof(LocalAddr));
      if ( Ret != 0 )
      {
          cout<<"绑定 Socket 失败:"<<GetLastError()<<endl;
          return 0;
      }
    
      //listen 命令套接字监听来自服务端的连接.
      //第二个参数是最大连接数.
      Ret = listen(ClientSocket, 10);
      if ( Ret != 0 )
      {
          cout<<"监听 Server Socket 失败:"<<GetLastError()<<endl;
          return 0;
      }
    
      cout<<"客户端已经启动，正在监听"<<endl;

          AddrLen = sizeof(ServerAddr);

          //The accept function permits an incoming connection attempt on a socket.
          //接收即将到来的客户端连接。
          ServerSocket = accept(ClientSocket, (struct sockaddr*)&ServerAddr, &AddrLen);
        
          if ( ClientSocket == INVALID_SOCKET )
          {
              cout<<"接收服务器端消息失败 :"<<GetLastError()<<endl;
              system("pause");
             // break;
          }
          else
          {
              //The inet_ntoa function converts an (Ipv4) Internet network address into a string in Internet standard dotted format.
              cout<<"\n服务器端连接 :"<<inet_ntoa(ServerAddr.sin_addr)<<":"<<ServerAddr.sin_port<<endl;
          }
     string cmdstr ; 
     do
     {
         getline(cin,cmdstr);
     }while(cmdstr != "exit" && cmdstr != "EXIT");
     closesocket(ClientSocket);
     //最初这个函数也许有些拥簇，现在保留它只是为了向后兼容。
     //但是调用它可能会更安全，可能某些实现会使用它来结束ws2_32.DLL
     WSACleanup();

    return 0;
}

//发送消息子线程
DWORD WINAPI SendThread(LPVOID lpParameter)
{    
    SendMsgStruct *myStruct = (SendMsgStruct *)lpParameter;
    SOCKET ClientSocket = myStruct->clientSocket;
    string SendMsg = myStruct->msg;
    struct sockaddr_in ServerAddr = myStruct->ServerAddr;

    while( true )
    {    
        int flag = 0;
        int bufSize = SendMsg.length();
        char * buf = const_cast<char*>(SendMsg.c_str());
        flag = send(ClientSocket, buf, bufSize, 0);

        //判断当前时候存在可用连接,如果没有，再次连接
        while( flag == -1 || flag == 0)
        {
            cout<<"准备重连"<<endl;
            //shutdown(ClientSocket,2);
            closesocket(ClientSocket);
            ClientSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
            int cunnectFlag = connect(ClientSocket,(struct sockaddr*)&ServerAddr, sizeof(ServerAddr));
            
            if( cunnectFlag == SOCKET_ERROR )
            {
                cout<<"重连失败 :"<<GetLastError()<<endl;
                Sleep(5000);
                //cunnectFlag = connect(ClientSocket,(struct sockaddr*)&ServerAddr, sizeof(ServerAddr));
            }
            else
            {
                break;
            }
        }

        //传输过程中报错
        //if( flag == SOCKET_ERROR )
        //{
        //        cout<<"消息发送过程中报错:"<<GetLastError()<<endl;
        //}
        //没有传输完成
        //else if( flag < bufSize )
        if( flag < bufSize )
        {
            flag = send(ClientSocket, buf, bufSize - flag, 0);
        }
        //传输成功
        else
        {
            cout<<"\n消息传输成功"<<endl;
        }

        //每5秒发送一次
        Sleep(5000);
    }
    return 0;
}

//接收消息子线程
DWORD WINAPI RecvThread(LPVOID lpParameter)
{

    RecvMsgStruct *recvStruct=(RecvMsgStruct *)lpParameter;
    SOCKET clientSocket = recvStruct->clientSocket;
    struct sockaddr_in ServerAddr = recvStruct->ServerAddr;
    char recvBuf[500]={"0"}; 
     int byteRecv = recv(clientSocket, recvBuf, 500, 0);
     int connectState;
     while( byteRecv == 0 )
     {
         //连接断开，重连
        cout<<"byteRecv == 0"<<endl;
        shutdown(clientSocket,2);
        //closesocket(ClientSocket);
        clientSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        connectState = connect(clientSocket,(struct sockaddr*)&ServerAddr, sizeof(ServerAddr));

        if( connectState == SOCKET_ERROR )
        {
            cout<<"建立连接发生错误,错误代码:"<<GetLastError()<<endl;
        }
        else
        {
            cout<<"-----------------------------------------------In"<<endl;
            byteRecv = recv(clientSocket, recvBuf, 500, 0);//建立连接后，重新获取一次消息
            recvBuf[byteRecv]=0;
        }
        Sleep(5000);
     }
    cout<<recvBuf<<endl;
    return 0;
}

//移除字符串首尾空格
void trim(string &str)
{
      str.erase(str.find_last_not_of(' ')+1,string::npos);
      str.erase(0,str.find_first_not_of(' '));
}

南国_之恋
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux socket客户端断线自动重连
天使也有爱
09-11 1323
arm-linux-gnueabihf-gcc client_line.c Delay.c -o client -pthread 服务器ip 192.168.1.139 ./client 192.168.1.139 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include
linux下tcp重连机制,tcp socket 客户端重连机制
weixin_39777875的博客
05-14 1869
在Linux下编程使用socket 客户端连接服务器时发现一个问题有网友测试(1)客户端已经连接，当服务端关闭程序时，客户端调用send函数发送失败，WSAGetLastError() 返回10054(远程主机强迫关闭了一个现有的连接)(2)客户端已经连接，当客户端关闭程序时，服务端调用recv函数接收失败，WSAGetLastError() 返回10054(远程主机强迫关闭了一个现有的连接) ,...
linux socket断线重连,websocket 断线重连解决方案
weixin_35075655的博客
05-15 1102
websocket是HTML5下一个不错的网络协议解决方案，有一个场景很多猿猿都会遇到，手机锁屏后大约60秒，IOS会自动断开websocket连接，连接丢失了，那我们的数据也就断了。websocket 断线重连方案如下：ReconnectingWebSocketreconnecting websocket是一个javascript封闭的websocket库，非常小，压缩后仅有3KB。它的功能是当...
TCP重传机制及C++代码模拟重传逻辑
Warren++的博客
05-09 817
TCP重传机制及代码模拟重传逻辑
Linux C socket 断开重连
mianfeidehaoa1的博客
12-14 5940
1. socket Server 创建完成后，设置socket类型为可重复性使用； 2. 在server接受client的连接之后，client和server之间可以互相收发数据；         conn = accept(); 3. server可以主动断开连接并继续进入可连接状态：         可以在server端断开连接，但是不能关闭socket， 使用close(conn)，
Linux Socket网络编程UDP、TCP 阻塞与非阻塞 断线重连机制
qq_42475191的博客
09-12 6193
一·、UDP协议及其工作原理 (10条消息) UDP.01.基础知识+基础模型_老毛的博客-CSDN博客 (10条消息) Socket原理讲解_Tony-jiang的博客-CSDN博客_socket 二、UDP在Linux下的编程方式 2.1 参考链接： (10条消息) UDP的编程流程_liqiao_418的博客-CSDN博客_udp流程 (10条消息) UDP编程步骤_judgejames的博客-CSDN博客_udp过程 2.2 编程流程 服务端： //1.创建套接字 #inclu
c语言linux TCP长连接 socket收发范例 断开自动重连
u013238956的博客
07-20 1849
原文链接：https://blog.csdn.net/chenhao0568/article/details/103420615 c语言linux TCP长连接 socket收发范例 断开自动重连 改进1：加入接收超时。可以做别的事，等有接收才响应 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <assert.h> #include <string.h> #i
C++中如何使用HP-Socket
chengxuyuanlaow的博客
10-26 3128
HP-Socket 是一套通用的高性能 TCP/UDP /HTTP 通信 框架 ，包含服务端组件、客户端组件和 Agent 组件，广泛适用于各种不同应用场景的 TCP/UDP /HTTP 通信系统，提供 C/C++ 、 C# 、 Delphi 、 E （易语言）、 Java 、 Python 等编程语言接口。HP-Socket是一套国产的开源通讯库，使用C++语言实现，提供多种编程语言的接口，支持 Windows 和 Linux 平台：Server组件。
Socket编程概念
热门推荐
gqk01的博客
07-27 1万+
一：什么是SOCKET socket的英文原义是“孔”或“插座”。作为进程通信机制，取后一种意思。通常也称作“套接字”，用于描述IP地址和端口，是一个通信链的句柄（其实就是两个程序通信用的）。 socket非常类似于电话插座。以一个电话网为例：电话的通话双方相当于相互通信的2个程序，电话号码就是ip地址。任何用户在通话之前，首先要占有一部电话机，相当于申请一个socket；同时要知道对方的号码，相当于对方有一个固定的socket。然后向对方拨号呼叫，相当于发出连接请求。对方假如在场并空闲，拿起电话话筒，双
Linux tcp客户端断开重连,Linux网络编程——TCP和UDP通信
weixin_36228334的博客
05-12 1474
TCP协议流程图、TCP建立即时聊天TCP即时聊天升级：服务器在客户端断开后不断开，客户端可以多次重连服务器进行即时聊天UDP协议流程图、UDP建立即时连接如果在已经处于 ESTABLISHED状态下的socket(一般由端口号和标志符区分)需调用closesocket(一般不会立即关闭而经历TIME_WAIT的过程)后想继续重用该socket，但也可以直接用setsockopt和reuse。SO...
创建网络聊天客户端程序 小例子，C++.net源代码编写
03-17
9. **断线重连**：考虑到网络不稳定，客户端应具备检测连接状态并在断开后尝试重新连接的功能。 10. **安全性**：虽然这是一个简单的例子，但实际应用中应考虑安全性，如使用加密技术保护数据安全，防止中间人攻击...
循环服务器（socket）
12-18
在服务器端实现中，首先创建一个套接字(socket)： ```c if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { printf("socket error.\n"); exit(1); } ``` 这里使用`AF_INET`表示IPv4协议族，`SOCK_STREAM`...
FileTransfer_demo.zip_CSocket文件传输_csocket_csocket 文件_socket_传输文件
09-23
6. **错误处理**：在文件传输过程中，需要时刻关注可能发生的错误，如连接中断、数据丢失或网络延迟，适当进行重试或断线重连。 标签中的"csocket文件传输"、"csocket"、"csocket_文件"和"socket 传输文件"都是与...
最简单的c++tcp/ip服务器端和客户端程序
07-31
如果想增强功能，可以考虑加入如SSL/TLS加密、负载均衡、断线重连、消息分包与合并等高级特性。 总之，这个项目为学习C++网络编程提供了一个很好的起点，它展示了如何使用基本的socket API创建简单的TCP/IP服务器和...
chromedriver-mac-arm64_126.0.6474.0.zip
07-31
chromedriver-mac-arm64_126.0.6474.0.zip
chromedriver-mac-arm64_128.0.6548.0.zip
07-31
chromedriver-mac-arm64_128.0.6548.0.zip
MySQL查询加速器：利用Query Cache提升效率
07-31
MySQL是一个流行的开源关系型数据库管理系统（RDBMS），广泛用于Web应用程序的后端数据存储。它基于结构化查询语言（SQL）来管理数据，并且是LAMP（Linux, Apache, MySQL, PHP/Python/Perl）技术栈的一部分，这个技术栈常用于构建动态网站和Web应用程序。 MySQL的特点包括： - **开放源代码**：MySQL的源代码是公开的，任何人都可以自由使用和修改。 - **跨平台**：MySQL可以在多种操作系统上运行，包括Linux、Windows、macOS等。 - **高性能**：MySQL以其快速的查询处理和良好的性能而闻名。 - **可靠性**：MySQL提供了多种机制来确保数据的完整性和可靠性，包括事务支持、备份和恢复功能。 - **易于使用**：MySQL提供了简单直观的界面和丰富的文档，便于用户学习和使用。 - **可扩展性**：MySQL支持从小型应用到大型企业级应用的扩展。 - **社区支持**：由于其广泛的使用，MySQL拥有一个活跃的开发者社区，提供大量的资源和支持。 MySQL被广泛应用于各种场景，包括在线事务处理（OL
Objective-C语言的基础教程.md
最新发布
07-31
Objective-C是一种面向对象的编程语言，是C语言的扩展。它主要用于苹果的iOS和macOS应用程序开发。
c++ socket断线重连
07-24
### 回答1： socket断线重连是指在建立socket连接后，由于网络故障或其他问题导致连接中断，需要重新尝试建立连接的过程。 当socket连接断开时，通常会触发相应的错误信息。在C语言中，我们可以使用errno来获取具体的错误码，常见的错误码有ECONNRESET（连接被重置）、ETIMEDOUT（连接超时）等。根据不同的错误码，我们可以采取相应的操作来进行断线重连。 在进行断线重连时，通常的步骤如下： 1. 关闭已经断开的socket连接，清理相应的资源。 2. 创建新的socket实例并初始化。 3. 设置socket选项，如设置非阻塞、设置重用地址等。 4. 进行连接尝试，如果连接成功则重连完成，如果连接失败则进入下一步。 5. 进行等待连接恢复的操作，可以使用sleep函数等待一段时间后再次尝试建立连接。 6. 重复步骤4和步骤5，直到连接成功或达到最大尝试次数。 需要注意的是，在进行重连时，需要合理设置连接的超时时间和重试次数，避免无限循环或耗费过多时间。同时，在重连过程中也需要注意处理一些异常情况，如网络不稳定、服务器不可达等问题，以保证重连的可靠性。 总结起来，socket断线重连是通过关闭已断开连接、创建新的socket实例、设置相应选项并尝试连接来实现的。通过合理的超时设置和重试机制，可以保证连接的可用性和可靠性。 ### 回答2： Socket断线重连是指在网络通信中，当Socket连接异常断开后，通过一定的方法重新建立连接的过程。 Socket断线重连的实现通常需要以下几个步骤： 1. 检测连接状态：在应用程序中需要监测Socket连接状态，一旦发现连接断开，即可触发重连逻辑。 2. 关闭旧连接：在重连前，需要确认旧的Socket连接已经断开并关闭。可以使用close()或shutdown()方法来主动关闭连接。 3. 重新建立连接：关闭旧连接后，使用新的Socket对象重新建立连接。这包括创建新的Socket实例、指定连接的地址和端口号、执行connect()方法等操作。 4. 设置重连策略：为了增加连接的成功率，可以设置重连策略，包括重连的间隔时间、重连次数限制等。 5. 错误处理：在重连过程中，可能会出现各种错误，如网络不可达、连接超时等。应该对这些错误进行适当的处理，比如延迟重连、记录错误日志等。 在实际应用中，可以将上述步骤封装成一个重连模块或函数，方便其他模块共享使用。此外，为了确保数据传输的完整性，还需要对断线期间的数据丢失进行处理，例如使用心跳包、消息序列号等机制。 总结而言，Socket断线重连是在网络通信中处理连接断开后重新建立连接的过程，需要监测连接状态、关闭旧连接、重新建立连接、设置重连策略和处理错误等步骤来实现。 ### 回答3： c语言中的socket断线重连需要通过以下步骤来实现： 1. 创建socket：首先需要创建一个socket来与服务器进行通信。可以使用`socket()`函数来创建一个套接字，并通过`AF_INET`和`SOCK_STREAM`参数指定套接字的类型。 2. 连接服务器：使用`connect()`函数来连接服务器。通过指定服务器的IP地址和端口号来建立连接。如果连接成功，该函数将返回0。 3. 发送和接收数据：经过连接后，客户端可以通过`send()`函数发送数据到服务器，或者通过`recv()`函数接收来自服务器的数据。 4. 检测断线：在连接过程中，如果客户端检测到与服务器的连接中断，则需要进行断线重连的操作。可以通过设置socket的超时选项来检测连接是否中断。通过`setsockopt()`函数来设置socket的选项。 5. 断线重连：如果检测到与服务器的连接中断，需要重新创建一个socket，并尝试重新连接服务器。可以使用一个循环来实现这个过程，直到连接成功。在每次循环时，需要对上一次的socket进行清理和关闭。 6. 处理异常：在重连过程中，可能会出现一些异常情况。例如，服务器可能已经关闭，或者网络连接极差。为了处理这些异常情况，可以在重连过程中设置一些适当的超时时间和重试次数。 总结：通过以上步骤，可以在c语言中实现socket的断线重连功能。这样一来，即使与服务器的连接中断，也可以自动尝试重新连接，确保通信的稳定性和连续性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值