socket_client_tcp

最新推荐文章于 2023-05-11 00:59:51 发布
最新推荐文章于 2023-05-11 00:59:51 发布
阅读量1.1k 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/danxibaoxxx/article/details/88058793
版权

socket_client_tcp.h

#ifndef __SOCKET_CLIENT_TCP_H__
#define __SOCKET_CLIENT_TCP_H__

#ifdef __cplusplus
extern "C" {
#endif
#pragma pack(1)

#define SOCKET_STATUS ODVS_STATUS
#define SOCKET_ERROR  ODVS_ERROR
#define SOCKET_OK     ODVS_OK

#define SOCKET_BOOL   ODVS_BOOL
#define SOCKET_TRUE   ODVS_TRUE
#define SOCKET_FALSE  ODVS_FALSE

/*通过socket接收外部数据的等待超时时间*/
#define CLIENT_CONNECT_TIMEOUT_SEC   1  /*s*/
#define CLIENT_CONNECT_TIMEOUT_USEC  0  /*us*/
#define CLIENT_RECV_TIMEOUT_SEC      1  /*s*/
#define CLIENT_RECV_TIMEOUT_USEC     0  /*us*/
#define CLIENT_SEND_TIMEOUT_SEC      1  /*s*/
#define CLIENT_SEND_TIMEOUT_USEC     0  /*us*/

#define CLIENT_RECV_BUFF_SIZE 1024 /*1 k*/

typedef INT32 (* func)(BYTE *, WORD32);
typedef struct timeout
{
    TimeInfo Connect;
    TimeInfo Send;
    TimeInfo Recv; 
}ClientTimeout;
typedef enum status
{
    CLIENT_STOPPED       = 0, /*stopped*/
    CLIENT_INIT          = 1,/*initialized*/
    CLIENT_CONNECT       = 2,/*connect server*/
    CLIENT_RUNNING       = 3,
    CLIENT_CHANGE_SERVER = 4,/*connected server info changed,need to reconnect*/
}ClientStatus;
typedef struct client
{
    ClientStatus ClientSts;
    INT32 Sockfd;
    CHAR ServerIp[20];
    UINT32 ServerPort;
    ClientTimeout timeout;
    func  RecvHandler;
    CHAR  Buffer[CLIENT_RECV_BUFF_SIZE];
}SocketClientInfo;


/****************************extern functions************************/
extern void ChangeSocketServerInfo(CHAR *server, UINT32 port);
extern SOCKET_STATUS ModifyClientTimeout(TimeInfo send, TimeInfo recv);
extern void RegisterRecvHandler(func handler);
extern SOCKET_STATUS StartTcpClientMdl();
extern void StartClient();
extern void StopClient();

#pragma pack()
#ifdef __cplusplus
}
#endif
#endif

 

 

socket_client_tcp.c

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <time.h>
#include <unistd.h>

#include "comm_types_ex.h"
#include "comm_struct_ex.h"
#include "comm_utils_ex.h"
#include "comm_log_ex.h"
#include "import_wrapper_ex.h"
#include "socket_client_tcp.h"

SocketClientInfo g_stClient = 
{
    CLIENT_STOPPED, 
    SOCKET_ERROR, 
    "10.63.180.66", 
    2899, 
    { 
        {CLIENT_CONNECT_TIMEOUT_SEC,CLIENT_CONNECT_TIMEOUT_USEC},
        {CLIENT_SEND_TIMEOUT_SEC,CLIENT_SEND_TIMEOUT_USEC},
        {CLIENT_RECV_TIMEOUT_SEC,CLIENT_RECV_TIMEOUT_USEC}
    }, 
    NULL,
    {0}
};

SOCKET_STATUS CloseSocket()
{
    if(close(g_stClient.Sockfd))
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: Close socket failed");
        return SOCKET_ERROR;
    }
    g_stClient.Sockfd = -1;
    DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Success: Client is closed!");
    return SOCKET_OK;
}
SOCKET_STATUS ClientCreateSocket()
{
    memset(g_stClient.Buffer, 0, CLIENT_RECV_BUFF_SIZE);
    
    /* 创建客户端套接字--IPv4协议，面向连接通信，TCP协议 */
    g_stClient.Sockfd= socket(PF_INET, SOCK_STREAM, 0);
    if (g_stClient.Sockfd < 0)
    {
        return SOCKET_ERROR;
    }
    return SOCKET_OK;
}
void NON_BLOCK()
{
    INT32 flag = 0;
    
    flag = fcntl(g_stClient.Sockfd, F_GETFL, NULL);
    fcntl(g_stClient.Sockfd, F_SETFL, flag | O_NONBLOCK);/* non-blocking mode */
}
void BLOCK()
{
    INT32 flag = 0;
    
    flag = fcntl(g_stClient.Sockfd, F_GETFL, NULL);
    fcntl(g_stClient.Sockfd, F_SETFL, flag & (~O_NONBLOCK));/*blocking mode*/
}
SOCKET_STATUS NonblockConnect()
{
    SOCKET_STATUS connRet = SOCKET_ERROR;
    SockAddrIn remoteAddr;
    
    if(g_stClient.Sockfd < 0)
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: Socket has not been created!");

        connRet = SOCKET_ERROR;
    }
    else
    {
        memset(&remoteAddr, 0, sizeof(remoteAddr));
        remoteAddr.sin_family      = AF_INET;
        remoteAddr.sin_addr.s_addr = inet_addr(g_stClient.ServerIp);
        remoteAddr.sin_port        = htons(g_stClient.ServerPort);

        connRet = connect(g_stClient.Sockfd, (SockAddr *)&(remoteAddr), sizeof(SockAddr));
        
        if(SOCKET_ERROR == connRet)
        {
            DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: Connect server failed");
        }
    }
    
    return connRet;
}
SOCKET_BOOL CanSockWrite(fd_set *writeset)
{
    INT32 error = 0, ret = SOCKET_ERROR;
    INT32 len = sizeof(INT32);
    
    if(FD_ISSET(g_stClient.Sockfd, writeset))
    {
        if(getsockopt(g_stClient.Sockfd, SOL_SOCKET, SO_ERROR, &error, &len)<0)
        {
            ret = SOCKET_FALSE;
        }
        if(error == 0)
        {
            DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Success: Connect server success");
            ret = SOCKET_TRUE;
        }
        else
        {
            DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: Unexpect error in getsockopt");
            ret = SOCKET_FALSE;
        }
    }
    else
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: Connect failed");
        ret = SOCKET_FALSE;
    }
    return ret;
}
SOCKET_STATUS TestSockWriteable()
{
    SOCKET_BOOL ret;
    SOCKET_STATUS selecRet;
    fd_set writeset;
    TimeInfo timeout = g_stClient.timeout.Connect;
    
    FD_ZERO(&writeset);
    FD_SET(g_stClient.Sockfd, &writeset);
    selecRet = select(g_stClient.Sockfd+1, NULL, &writeset, NULL, &timeout);

    if(selecRet < 0)
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: Select failed");
        ret = SOCKET_FALSE;
    }
    else if(selecRet == 0)
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: Connect timeout");
        ret = SOCKET_FALSE;
    }
    else/* check if socket writeable*/
    {
        if(CanSockWrite(&writeset))
        {
            ret = SOCKET_TRUE;
        }
        else
        {
            ret = SOCKET_FALSE;
        }
    }
    return ret;
}
SOCKET_STATUS CheckConnStatus()
{
    SOCKET_STATUS ret = SOCKET_ERROR;
    
    if(errno != EINPROGRESS)/* 连接不在进行中，出现错误*/
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: Connect failed");

        if(errno == EISCONN)/*  关闭连着状态的服务 */
        {
            close(g_stClient.Sockfd);
            g_stClient.Sockfd = SOCKET_ERROR;
            g_stClient.ClientSts = CLIENT_INIT;
        }

        ret = SOCKET_ERROR;
    }
    else/* connection is under porgress */
    {
        if(TestSockWriteable())
        {
            ret = SOCKET_OK;
        }
        else
        {
            ret = SOCKET_ERROR;
        }
    }
    return ret;
}
/* 设置超时连接，连接超时返回错误 */
SOCKET_STATUS ClientConnectServer()
{
    SOCKET_STATUS ret = SOCKET_ERROR;
    
    NON_BLOCK();
    
    if(NonblockConnect() == SOCKET_ERROR)/* under process:非阻塞模式，返回值-1不表示错误 */
    {
        ret = CheckConnStatus();
    }
    else/* connect success */
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Success: Connect OK!");
        ret = SOCKET_OK;
    }
    
    BLOCK();

    return ret;
}
void ChangeSocketServerInfo(CHAR *pServer, UINT32 port)
{
    if(pServer != NULL && strcmp(pServer, g_stClient.ServerIp) != 0)
    {
        memcpy(g_stClient.ServerIp, pServer, strlen(pServer));
        g_stClient.ServerIp[strlen(pServer)] = '\0';
    }
    if(port != 0 && port != g_stClient.ServerPort)
    {
        g_stClient.ServerPort = port;
    }
    
    g_stClient.ClientSts = CLIENT_CHANGE_SERVER;
}

INT32 TcpClientSend(WORD32 *buf, WORD32 len)
{
    INT32 sendNum = 0;
    
    if(g_stClient.Sockfd < 0)
    {
        return SOCKET_ERROR;
    }
    sendNum = send(g_stClient.Sockfd, (CHAR *)buf, len, 0);
    if(sendNum < 0)
    {
        /* TO-DO:send failed */
    }
    return sendNum;
}

SOCKET_STATUS ClientRecv()
{
    INT32 recvNum = 0;
    
    if(g_stClient.Sockfd < 0)
    {
        return SOCKET_ERROR;
    }
    memset(g_stClient.Buffer, 0, CLIENT_RECV_BUFF_SIZE);
    recvNum = recv(g_stClient.Sockfd, g_stClient.Buffer, CLIENT_RECV_BUFF_SIZE, 0);

    return recvNum;
}

SOCKET_STATUS SetClientTimeout()
{
    SOCKET_STATUS ret;
    
    if(g_stClient.Sockfd < 0)
    {
        return SOCKET_ERROR;
    }

    ret = setsockopt(g_stClient.Sockfd, SOL_SOCKET, SO_RCVTIMEO, &g_stClient.timeout.Recv,sizeof(TimeInfo));
    ret = setsockopt(g_stClient.Sockfd, SOL_SOCKET, SO_SNDTIMEO, &g_stClient.timeout.Send,sizeof(TimeInfo));

    return ret;
}
SOCKET_STATUS ModifyClientTimeout(TimeInfo send, TimeInfo recv)
{
    SOCKET_STATUS ret;
    
    if(g_stClient.Sockfd < 0)
    {
        return SOCKET_ERROR;
    }
    g_stClient.timeout.Recv = recv;
    g_stClient.timeout.Send = send;
    ret = SetClientTimeout();
    
    return ret;
}
SOCKET_STATUS ClientRecvHandler(BYTE *data, INT32 len)
{
    if(NULL == data || NULL == g_stClient.RecvHandler)
    {
        return SOCKET_ERROR;
    }
    if(IsModLogOn(LOG_MDL_TCP_CLIENT))
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Client recv %d data", len);
        ShowHexData((WORD8 *)data, len);
    }
   
    return g_stClient.RecvHandler(data, len);
}
void StopClient()
{
    g_stClient.ClientSts = CLIENT_STOPPED;
}
void StartClient()
{
    g_stClient.ClientSts = CLIENT_RUNNING;
}
ClientStatus GetClientStatus()
{
    return g_stClient.ClientSts;
}
void RegisterRecvHandler(func handler)
{
    g_stClient.RecvHandler = handler;
}
SOCKET_STATUS ClientRecving()
{
    INT32 recvNum = 0;
    SOCKET_STATUS iRet = SOCKET_OK;
    
    recvNum = ClientRecv();

    if(recvNum < 0)
    {
        OdvsTaskDelay(100);
    }
    else if(recvNum == 0)/* connect is terminated */
    {
        iRet = SOCKET_ERROR;
        close(g_stClient.Sockfd);
        OdvsTaskDelay(100);
    }
    else if(recvNum > 0)
    {   
        ClientRecvHandler(g_stClient.Buffer, recvNum);
        OdvsTaskDelay(1);
    }
    
    return iRet;
}
SOCKET_STATUS CreateOkMoveNext(SOCKET_STATUS sts, INT32 delay)
{
    SOCKET_BOOL ret = SOCKET_TRUE;
    
    if(SOCKET_ERROR == sts)
    {
        OdvsTaskDelay(delay);
        ret = SOCKET_FALSE;
    }
    
    return ret;
}
SOCKET_STATUS ConnectOkMoveNext(SOCKET_STATUS sts, INT32 delay)
{
    SOCKET_BOOL ret = SOCKET_TRUE;
    
    if(SOCKET_ERROR == sts)
    {
        OdvsTaskDelay(delay);
        ret = SOCKET_FALSE;
    }
    else
    {   
        SetClientTimeout();
    }
    return ret;
}
SOCKET_STATUS RecvErrMoveNext(SOCKET_STATUS sts, INT32 delay)
{
    SOCKET_BOOL ret = SOCKET_TRUE;
    if(SOCKET_OK == sts)
    {
        OdvsTaskDelay(delay);
        ret = SOCKET_FALSE;
    }
    return ret;
}
SOCKET_STATUS ClientRun(INT32 arg1, INT32 arg2, INT32 arg3, INT32 arg4, INT32 arg5,
                       INT32 arg6, INT32 arg7, INT32 arg8, INT32 arg9, INT32 arg10)
{   
    INT32 iDefaultDelay = 100; /* 100 * 10ms */

    while(SOCKET_TRUE)
    {
        switch(g_stClient.ClientSts)
        {
            case CLIENT_INIT:
                if(CreateOkMoveNext(ClientCreateSocket(), iDefaultDelay))
                {
                    g_stClient.ClientSts = CLIENT_CONNECT;
                }
                break;
            case CLIENT_CONNECT:
                if(ConnectOkMoveNext(ClientConnectServer(), iDefaultDelay))
                {
                    g_stClient.ClientSts = CLIENT_RUNNING;
                }
                break;
            case CLIENT_RUNNING:
                if(RecvErrMoveNext(ClientRecving(), iDefaultDelay))
                {
                    g_stClient.ClientSts = CLIENT_INIT;
                }
                break;
            case CLIENT_CHANGE_SERVER:
                CloseSocket();
                g_stClient.ClientSts = CLIENT_INIT;
                break;
            case CLIENT_STOPPED:
                OdvsTaskDelay(200);
                break;
            default:
                OdvsTaskDelay(100);
                break;
                
        }
    }
}
SOCKET_STATUS StartupClientThread()
{
    return OdvsTaskSpawn("ClientTcp", 90, 0, 0x2000, (ODVS_FUNCPTR)ClientRun, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
SOCKET_STATUS StartTcpClientMdl()
{
    SOCKET_STATUS ret = SOCKET_ERROR;
    
    g_stClient.ClientSts = CLIENT_INIT;
    StartupClientThread();

    return ret;
}
/***********************HELP*******************/
void ShowClientInfoHelp()
{
    CHAR *sts[] = {"CLIENT_STOPPED", "CLIENT_INIT", "CLIENT_CONNECT","CLIENT_RUNNING", "CLIENT_CHANGE_SERVER"};

    printf("\n===============================================");
    printf("\n------------Client Information-----------------\n");
    printf("Client Status          : %s\n", sts[g_stClient.ClientSts]);
    printf("Client Socket FD       : %d\n", g_stClient.Sockfd);
    printf("Client Server ip       : %s\n", g_stClient.ServerIp);
    printf("Client Server port     : %d\n", g_stClient.ServerPort);
    printf("Client timeout connect : %ld\n", g_stClient.timeout.Connect.tv_sec);
    printf("Client timeout Send    : %ld\n", g_stClient.timeout.Send.tv_sec);
    printf("Client timeout Recv    : %ld\n", g_stClient.timeout.Recv.tv_sec);
    printf("Client recv buffer addr: %p\n", g_stClient.Buffer);
    printf("handler                : %p\n", g_stClient.RecvHandler);
    printf("===============================================\n");
}

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <ifaddrs.h> 
#include <fcntl.h>
#include <time.h>
#include <unistd.h>

#include "comm_types_ex.h"
#include "comm_struct_ex.h"
#include "comm_utils_ex.h"
#include "comm_log_ex.h"
#include "import_wrapper_ex.h"
#include "socket_ex.h"
#include "socket_client_tcp.h"
#include "layer_if_ex.h"
#include "cfg_ex.h"


WORD32 SOCKET_SND_DEBUG = 0;
SocketClientInfo g_stClient =
{
    CLIENT_STOPPED,
    SOCKET_ERROR,
    CFG_DEFAULT_TCP_IP,
    CFG_DEFAULT_TCP_PORT,
    {
        {CLIENT_CONNECT_TIMEOUT_SEC, CLIENT_CONNECT_TIMEOUT_USEC},
        {CLIENT_SEND_TIMEOUT_SEC, CLIENT_SEND_TIMEOUT_USEC},
        {CLIENT_RECV_TIMEOUT_SEC, CLIENT_RECV_TIMEOUT_USEC}
    },
    NULL,
    {0}, {0}
};

/* tcp server */
void SetConfigTcpServer(CHAR *pIp, WORD32 port)
{
    strcpy(g_stClient.ServerIp, pIp);
    g_stClient.ServerPort = port;
}

void GetTcpServerInfo(CHAR *pIp, WORD32 *pPort)
{
    strcpy(pIp, g_stClient.ServerIp);
    *pPort = g_stClient.ServerPort;
}

WORD32 GetTcpServerPort()
{
    return g_stClient.ServerPort;
}

INT32 GetGatewayAddr(CHAR *gateway)
{
    CHAR buff[256] = {0};
    INT32  nl = 0, fl = 0;
    InAddr gw;
    INT32  ref, use, metric;
    UINT32 flgs;
    ULONG  d,g,m;
    FILE  *fp = NULL;
    
    fp = fopen("/proc/net/route", "r");
    if (fp == NULL)
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: open /proc/net/route failed!");
        return SOCKET_ERROR;
    }
        
    while (fgets(buff, sizeof(buff), fp) != NULL) 
    {
        if (nl) 
        {
            fl = 0;
            while ((buff[fl] != ' ') && (buff[fl] != '\t') && (buff[fl] != '\0'))
            {
                fl++;
            }
            buff[fl] = 0;    /* interface */
            if (sscanf(buff+fl+1, "%lx%lx%x%d%d%d%lx", &d, &g, &flgs, &ref, &use, &metric, &m) != 7) 
            {
                fclose(fp);
                DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: sscanf failed!");
                return SOCKET_ERROR;
            }
            gw.s_addr = g;  /* parse flags */
            if (d == 0)
            {
                strcpy(gateway, inet_ntoa(gw));
                DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC,  __FUNCTION__, __LINE__, "\ngateway: %s\n", gateway);
                fclose(fp);
                return SOCKET_OK;
            }                
        }
        nl++;
    }    

    fclose(fp);
    fp = NULL;
    
    DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: fgets failed!");
    return SOCKET_ERROR;
}

INT32 GetMacAddr(INT32 sockfd, CHAR *ip, CHAR *mac) 
{
    WORD8  *pMac = NULL;
    ArpReq arpreq;  
    SockAddrIn *dstadd_in = NULL; 
    INT32  interfaceNum = 0;
    IfReq  buf[16] = {0};
    IfConf ifc;
    
    memset(&arpreq, 0, sizeof(ArpReq));  
    arpreq.arp_pa.sa_family = AF_INET;  
    arpreq.arp_ha.sa_family = AF_UNSPEC; 
    dstadd_in = (SockAddrIn *)&(arpreq.arp_pa);
    inet_pton(AF_INET, ip, &(dstadd_in->sin_addr));

    ifc.ifc_len = sizeof(buf);
    ifc.ifc_buf = (caddr_t)buf;
    if (!ioctl(sockfd, SIOCGIFCONF, (CHAR *)&ifc))
    {
        interfaceNum = ifc.ifc_len / sizeof(IfReq);
        while (interfaceNum-- > 0)
        {
            DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "\ndevice name: %s\n", buf[interfaceNum].ifr_name);
            strcpy(arpreq.arp_dev, buf[interfaceNum].ifr_name); 
            if (!ioctl(sockfd, SIOCGARP, &arpreq))
            {
                pMac = (WORD8 *)arpreq.arp_ha.sa_data;
                memcpy(mac, pMac, MAC_ADDRESS_LEN);
                #if 0
                sprintf(mac, "%02x-%02x-%02x-%02x-%02x-%02x",
                        pMac[0], pMac[1], pMac[2], pMac[3], pMac[4], pMac[5]);
                #endif
                DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, 
                        "\nMAC: %x-%x-%x-%x-%x-%x\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
                return SOCKET_OK;
            }
            else
            {
                DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: ioctl() SIOCGARP failed!");
            }
        }
    }
    else
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: ioctl() SIOCGIFCONF failed!");
    }

    return SOCKET_ERROR;  
} 

INT32 GetRouteMacAddr(INT32 sockfd, CHAR *mac)
{
    CHAR gateway[15] = {0};
    
    if (SOCKET_ERROR == GetGatewayAddr(gateway))
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: Get gateway addr failed!");
        return SOCKET_ERROR;
    }
    if (SOCKET_ERROR == GetMacAddr(sockfd, gateway, mac))
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: Get mac addr failed!");
        return SOCKET_ERROR;
    }
    
    return SOCKET_OK;
}

SOCKET_STATUS CloseSocket()
{
    if (close(g_stClient.Sockfd))
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: Close socket failed");
        return SOCKET_ERROR;
    }
    g_stClient.Sockfd = -1;
    DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Success: Client is closed!");
    return SOCKET_OK;
}
SOCKET_STATUS ClientCreateSocket()
{
    memset(g_stClient.Buffer, 0, CLIENT_RECV_BUFF_SIZE);
    
    /* 创建客户端套接字--IPv4协议，面向连接通信，TCP协议 */
    g_stClient.Sockfd= socket(PF_INET, SOCK_STREAM, 0);
    if (g_stClient.Sockfd < 0)
    {
        return SOCKET_ERROR;
    }
    return SOCKET_OK;
}
void NON_BLOCK()
{
    INT32 flag = 0;
    
    flag = fcntl(g_stClient.Sockfd, F_GETFL, NULL);
    fcntl(g_stClient.Sockfd, F_SETFL, flag | O_NONBLOCK);/* non-blocking mode */
}
void BLOCK()
{
    INT32 flag = 0;
    
    flag = fcntl(g_stClient.Sockfd, F_GETFL, NULL);
    fcntl(g_stClient.Sockfd, F_SETFL, flag & (~O_NONBLOCK));/*blocking mode*/
}
SOCKET_STATUS NonblockConnect()
{
    SOCKET_STATUS connRet = SOCKET_ERROR;
    SockAddrIn remoteAddr;
    
    if(g_stClient.Sockfd < 0)
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: Socket has not been created!");

        connRet = SOCKET_ERROR;
    }
    else
    {
        memset(&remoteAddr, 0, sizeof(remoteAddr));
        remoteAddr.sin_family      = AF_INET;
        remoteAddr.sin_addr.s_addr = inet_addr(g_stClient.ServerIp);
        remoteAddr.sin_port        = htons(g_stClient.ServerPort);

        connRet = connect(g_stClient.Sockfd, (SockAddr *)&(remoteAddr), sizeof(SockAddr));
        
        if(SOCKET_ERROR == connRet)
        {
            DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_DETAIL, __FUNCTION__, __LINE__, "Error: Connect server failed");
        }
    }
    
    return connRet;
}
SOCKET_BOOL CanSockWrite(fd_set *writeset)
{
    INT32 error = 0, ret = SOCKET_ERROR;
    INT32 len = sizeof(INT32);
    
    if(FD_ISSET(g_stClient.Sockfd, writeset))
    {
        if(getsockopt(g_stClient.Sockfd, SOL_SOCKET, SO_ERROR, &error, &len)<0)
        {
            ret = SOCKET_FALSE;
        }
        if(error == 0)
        {
            DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Success: Connect server success");
            ret = SOCKET_TRUE;
        }
        else
        {
            DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_DETAIL, __FUNCTION__, __LINE__, "Error: Unexpect error in getsockopt");
            ret = SOCKET_FALSE;
        }
    }
    else
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_DETAIL, __FUNCTION__, __LINE__, "Error: Connect failed");
        ret = SOCKET_FALSE;
    }
    return ret;
}
SOCKET_STATUS TestSockWriteable()
{
    SOCKET_BOOL ret;
    SOCKET_STATUS selecRet;
    fd_set writeset;
    TimeInfo timeout = g_stClient.timeout.Connect;
    
    FD_ZERO(&writeset);
    FD_SET(g_stClient.Sockfd, &writeset);
    selecRet = select(g_stClient.Sockfd+1, NULL, &writeset, NULL, &timeout);

    if(selecRet < 0)
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Error: Select failed");
        ret = SOCKET_FALSE;
    }
    else if(selecRet == 0)
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_DETAIL, __FUNCTION__, __LINE__, "Error: Connect timeout");
        ret = SOCKET_FALSE;
    }
    else/* check if socket writeable*/
    {
        if(CanSockWrite(&writeset))
        {
            ret = SOCKET_TRUE;
        }
        else
        {
            ret = SOCKET_FALSE;
        }
    }
    return ret;
}
SOCKET_STATUS CheckConnStatus()
{
    SOCKET_STATUS ret = SOCKET_ERROR;
    
    if(errno != EINPROGRESS)/* 连接不在进行中，出现错误*/
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_DETAIL, __FUNCTION__, __LINE__, "Error: Connect failed");

        if(errno == EISCONN)/*  关闭连着状态的服务 */
        {
            close(g_stClient.Sockfd);
            g_stClient.Sockfd = SOCKET_ERROR;
            g_stClient.ClientSts = CLIENT_INIT;
        }

        ret = SOCKET_ERROR;
    }
    else/* connection is under porgress */
    {
        if(TestSockWriteable())
        {
            ret = SOCKET_OK;
        }
        else
        {
            ret = SOCKET_ERROR;
        }
    }
    return ret;
}
/* 设置超时连接，连接超时返回错误 */
SOCKET_STATUS ClientConnectServer()
{
    SOCKET_STATUS ret = SOCKET_ERROR;
    
    NON_BLOCK();
    
    if(NonblockConnect() == SOCKET_ERROR)/* under process:非阻塞模式，返回值-1不表示错误 */
    {
        ret = CheckConnStatus();
    }
    else/* connect success */
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Success: Connect OK!");
        ret = SOCKET_OK;
    }
    
    BLOCK();

    return ret;
}
void ChangeSocketServerInfo(CHAR *pServer, UINT32 port)
{
    if (pServer != NULL && strcmp(pServer, g_stClient.ServerIp) != 0)
    {
        memcpy(g_stClient.ServerIp, pServer, strlen(pServer));
        g_stClient.ServerIp[strlen(pServer)] = '\0';
    }
    if (port != 0 && port != g_stClient.ServerPort)
    {
        g_stClient.ServerPort = port;
    }

    g_stClient.ClientSts = CLIENT_CHANGE_SERVER;
}

INT32 TcpClientSend(BYTE *buf, WORD32 len)
{
    INT32 sendNum = 0;
    
    if((g_stClient.Sockfd < 0) || (g_stClient.ClientSts != CLIENT_RUNNING))
    {
        return SOCKET_ERROR;
    }
    if(SOCKET_SND_DEBUG)
    {
        printf("socket send data len %d; data: \n", len);
        ShowHexData(buf, len);
        printf("\n");
    }
    sendNum = send(g_stClient.Sockfd, buf, len, 0);
    if(sendNum < 0)
    {
        /* TO-DO:send failed */
    }
    return sendNum;
}

SOCKET_STATUS ClientRecv()
{
    INT32 recvNum = 0;
    
    if(g_stClient.Sockfd < 0)
    {
        return SOCKET_ERROR;
    }
    memset(g_stClient.Buffer, 0, CLIENT_RECV_BUFF_SIZE);
    recvNum = recv(g_stClient.Sockfd, g_stClient.Buffer, CLIENT_RECV_BUFF_SIZE, 0);

    return recvNum;
}

SOCKET_STATUS SetClientTimeout()
{
    SOCKET_STATUS ret;
    
    if(g_stClient.Sockfd < 0)
    {
        return SOCKET_ERROR;
    }

    ret = setsockopt(g_stClient.Sockfd, SOL_SOCKET, SO_RCVTIMEO, &g_stClient.timeout.Recv,sizeof(TimeInfo));
    ret = setsockopt(g_stClient.Sockfd, SOL_SOCKET, SO_SNDTIMEO, &g_stClient.timeout.Send,sizeof(TimeInfo));

    return ret;
}
SOCKET_STATUS ModifyClientTimeout(TimeInfo send, TimeInfo recv)
{
    SOCKET_STATUS ret;
    
    if(g_stClient.Sockfd < 0)
    {
        return SOCKET_ERROR;
    }
    g_stClient.timeout.Recv = recv;
    g_stClient.timeout.Send = send;
    ret = SetClientTimeout();
    
    return ret;
}
SOCKET_STATUS ClientRecvHandler(BYTE *data, INT32 len)
{
    if(NULL == data || NULL == g_stClient.RecvHandler)
    {
        return SOCKET_ERROR;
    }
    if(IsModLogOn(LOG_MDL_TCP_CLIENT))
    {
        DmsaLog(LOG_MDL_TCP_CLIENT, LOG_LEVEL_BASIC, __FUNCTION__, __LINE__, "Client recv %d data", len);
        ShowHexData((WORD8 *)data, len);
    }

    return g_stClient.RecvHandler(data, len);
}
void StopClient()
{
    g_stClient.ClientSts = CLIENT_STOPPED;
}
void StartClient()
{
    g_stClient.ClientSts = CLIENT_RUNNING;
}
ClientStatus GetClientStatus()
{
    return g_stClient.ClientSts;
}
void RegisterRecvHandler(func handler)
{
    g_stClient.RecvHandler = handler;
}
SOCKET_STATUS ClientRecving()
{
    INT32 recvNum = 0;
    SOCKET_STATUS iRet = SOCKET_OK;
    
    recvNum = ClientRecv();

    if(recvNum < 0)
    {
        OdvsTaskDelay(100);
    }
    else if(recvNum == 0)/* connect is terminated */
    {
        iRet = SOCKET_ERROR;
        close(g_stClient.Sockfd);
        OdvsTaskDelay(100);
    }
    else if(recvNum > 0)
    {   
        ClientRecvHandler(g_stClient.Buffer, recvNum);
        OdvsTaskDelay(1);
    }
    
    return iRet;
}
SOCKET_STATUS CreateOkMoveNext(SOCKET_STATUS sts, INT32 delay)
{
    SOCKET_BOOL ret = SOCKET_TRUE;
    
    if(SOCKET_ERROR == sts)
    {
        OdvsTaskDelay(delay);
        ret = SOCKET_FALSE;
    }
    
    return ret;
}
SOCKET_STATUS ConnectOkMoveNext(SOCKET_STATUS sts, INT32 delay)
{
    SOCKET_BOOL ret = SOCKET_TRUE;
    
    if(SOCKET_ERROR == sts)
    {
        OdvsTaskDelay(delay);
        ret = SOCKET_FALSE;
    }
    else
    {   
        SetClientTimeout();
    }
    return ret;
}
SOCKET_STATUS RecvErrMoveNext(SOCKET_STATUS sts, INT32 delay)
{
    SOCKET_BOOL ret = SOCKET_TRUE;
    if(SOCKET_OK == sts)
    {
        OdvsTaskDelay(delay);
        ret = SOCKET_FALSE;
    }
    return ret;
}
SOCKET_STATUS ClientRun(INT32 arg1, INT32 arg2, INT32 arg3, INT32 arg4, INT32 arg5,
                       INT32 arg6, INT32 arg7, INT32 arg8, INT32 arg9, INT32 arg10)
{   
    INT32 iDefaultDelay = 100; /* 100 * 10ms */

    while(SOCKET_TRUE)
    {
        switch(g_stClient.ClientSts)
        {
            case CLIENT_INIT:
                if(CreateOkMoveNext(ClientCreateSocket(), iDefaultDelay))
                {
                    g_stClient.ClientSts = CLIENT_CONNECT;
                }
                break;
            case CLIENT_CONNECT:
                if(ConnectOkMoveNext(ClientConnectServer(), iDefaultDelay))
                {
                    g_stClient.ClientSts = CLIENT_RUNNING;
                    if (SOCKET_OK == GetRouteMacAddr(g_stClient.Sockfd, g_stClient.gatewayMac))
                    {
                        SetUdpServerCtrlIf(0, g_stClient.gatewayMac, ntohl(inet_addr(g_stClient.ServerIp)), g_stClient.ServerPort);
                        SetUdpServerCtrlIf(1, g_stClient.gatewayMac, ntohl(inet_addr(g_stClient.ServerIp)), g_stClient.ServerPort);
                    }
                }
                break;
            case CLIENT_RUNNING:
                if(RecvErrMoveNext(ClientRecving(), iDefaultDelay))
                {
                    g_stClient.ClientSts = CLIENT_INIT;
                }
                break;
            case CLIENT_CHANGE_SERVER:
                CloseSocket();
                g_stClient.ClientSts = CLIENT_INIT;
                break;
            case CLIENT_STOPPED:
                OdvsTaskDelay(200);
                break;
            default:
                OdvsTaskDelay(100);
                break;
        }
    }
}
SOCKET_STATUS StartupClientThread()
{
    return OdvsTaskSpawn("ClientTcp", 90, 0, 0x2000, (ODVS_FUNCPTR)ClientRun, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
SOCKET_STATUS StartTcpClientMdl()
{
    SOCKET_STATUS ret = SOCKET_ERROR;
    
    g_stClient.ClientSts = CLIENT_INIT;
    StartupClientThread();

    return ret;
}
/***********************HELP*******************/
void ShowClientInfoHelp()
{
    CHAR *sts[] = {"CLIENT_STOPPED", "CLIENT_INIT", "CLIENT_CONNECT","CLIENT_RUNNING", "CLIENT_CHANGE_SERVER"};

    printf("\n===============================================");
    printf("\n------------Client Information-----------------\n");
    printf("Client Status          : %s\n", sts[g_stClient.ClientSts]);
    printf("Client Socket FD       : %d\n", g_stClient.Sockfd);
    printf("Client Server ip       : %s\n", g_stClient.ServerIp);
    printf("Client Server port     : %d\n", g_stClient.ServerPort);
    printf("Client timeout connect : %ld\n", g_stClient.timeout.Connect.tv_sec);
    printf("Client timeout Send    : %ld\n", g_stClient.timeout.Send.tv_sec);
    printf("Client timeout Recv    : %ld\n", g_stClient.timeout.Recv.tv_sec);
    printf("Client recv buffer addr: %p\n", g_stClient.Buffer);
    printf("Client gateway mac addr: %s\n", g_stClient.gatewayMac);
    printf("handler                : %p\n", g_stClient.RecvHandler);
    printf("===============================================\n");
}

 

danxibaoxxx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
tcp socket client端
ding283595861的博客
02-19 637
#include<stdio.h> #include<sys/types.h> #include<sys/socket.h> #include<unistd.h> #include<stdlib.h> #include<errno.h> #include<arpa/inet.h> #include<netin...
使用Socket与TCP实现服务端与客户端的聊天
oo00O_O00oo的博客
08-29 260
对于Socket与TCP的简单理解 在中国，人与人通过“手机”，使用普通话进行通信，在应用程序之间，程序与程序通过“Socket”，使用“TCP协议进行通信” 具体操作 Socket通过IP地址访问服务器，通过端口号确定需要通信的应用程序 下图清晰的展示了客户端与服务器 请求、连接、发送数据最后断开的整个流程。 学习笔记 上面有详细的编码步骤 界面 源码 客户端代码 using System...
网络编程——socket服务端和客户端（TCP）
Cuifature的博客
05-11 4659
socket 、TCP
socket客户端与服务器通信
qq_45139808的博客
10-31 1729
Socket - 套接字，在计算机通信领域，被翻译为“套接字”，它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发 送数据。基于Tcp协议的Socket通讯类似于B/S架构，面向连接，但不同的是服务器端可以向客户端 主动推送消息。2.TCP通信流程(1).建立一个套接字(Socket)(2).绑定服务器端IP地址及端口号--服务器端(3).利用Listen()方法开启监听--服务器端。
TCP Socket服务端客户端（二）
qq_37833413的博客
10-09 293
文章目录前言1.类库1.1 服务端1.2客户端1.3消息类1.4客户端存储类1.5消息类2.调用方法2.1服务端2.2客户端调用 前言 本文基于最基本的socket，编写一套tcp 服务端客户端代码，本文转自如下链接，并做了简单的修改：C#网络编程系列文章(一)之Socket实现异步TCP服务器 PS：本文无心跳包，未做客户端断线重连 1.类库 1.1 服务端 using System; usin...
TCP_Client.rar_TCP client_socket_socket 客户端_tcp
09-21
在这个名为“TCP_Client.rar”的压缩包中，包含了一个基于socket编程的TCP客户端示例。 首先，我们要理解什么是socket。Socket是计算机网络中的应用程序接口（API），它允许进程通过网络发送和接收数据。在TCP/IP...
tcp_client_socket.rar_TCP socket_client_socket_socket tcp_socket
09-23
本资源“tcp_client_socket.rar”包含了一个TCP客户端socket编程的示例，可以帮助开发者理解如何创建和使用TCP socket进行数据交换。 TCP socket客户端是网络通信的一端，它通过TCP协议与服务器建立连接，发送和...
client_sockettcp_client_
09-28
本篇将详细讲解如何使用C语言实现一个TCP客户端程序，即"client_sockettcp_client_"。我们将探讨TCP套接字的基本概念，以及如何创建、连接和通信。 首先，TCP套接字是应用层与TCP传输层之间的接口，它允许应用程序...
Socket_M_Client_sockettcp_TCP/IPclient_C++socket_
10-02
本文将详细讲解"Socket_M_Client_sockettcp_TCP/IPclient_C++socket_"这个主题，涵盖TCP/IP通信的基本概念、C++中Socket API的使用以及如何构建一个简单的TCP客户端。 首先，TCP/IP（Transmission Control Protocol...
socket_client_linuxsocket_Client9_
10-03
标题中的"socket_client_linuxsocket_Client9_"提示我们讨论的主题是关于Linux环境下的Socket客户端编程，具体版本可能针对Ubuntu 9.10。描述指出在执行客户端程序时，必须将服务端URL改为运行Ubuntu服务器的URL，...
tcp_client
08-30
客户端控制台程序源代码，希望给大家带来帮助。
Socket Client 长连接及心跳检测
qq_22074337的博客
04-29 3975
说明: springBoot下socket一对一建立长连接通讯，包括客户端心跳检测、掉线重连、收发信息等
【网络】socket API的使用+client/server代码演示+封装socket模块
crr411422的博客
05-09 1699
前言：本章旨在讲解常见的socket API及其使用练习，尾部有封装好的（socket相关的一些系统函数加上错误处理代码包装成新的函数）模块wrap.c。
WebSocket和Socket Client连共同Sever端并实现相互通信（C#、JS、C++）
刘朋
09-15 5499
分析websocket client传过来的http header中包含“Upgrade: websocket”，只需要在socket server端，检测到客户端连上来之后，马上接收一次信息，并判断本次接收到的信息是否包含websocket就可以了。3、开启C#实现的socket server，再用websocket连接下，server端检测到有客户端连上来了，客户端也没有报错，说明websocket已连到socket server。
socket client
weixin_37603532的博客
05-12 299
`` 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <sys/socket.h> 4 #include <arpa/inet.h> 5 #include <string.h> 6 #include <unistd.h> 7 8 #define SERV_PORT 6...
Socket编程下篇-----TCP协议的C/S案例
HusterClearLove
07-10 295
一共有4个源码文件组成。
网络聊天室_TCP客户端
qq_42211003的博客
06-17 136
初学Python记录 ps:要不是记不住,谁会写笔记 #导入模块 import socket import threading #定义函数,传入服务端的IP和端口号 def friend(tcp_client_socket): while True: #接收需要发送的消息 friend_content = input("客户端-请输入消息:\n") #约定当用户输入quit则退出客户端 if friend_content == 'qui
Python 网络编程3：tcp客户端与tcp服务器以及下载器
03-21 183
一、TCP介绍 1.1、TCP协议，传输控制协议（英语：Transmission Control Protocol，缩写为 TCP）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。 1.2、TCP通信需要经过 创建连接、数据传送、终止连接 三个步骤。 1.3、TCP通信模型中，在通信开始之前，一定要先建立相关的链接，才能发送数据，类似于生活中，“打电话”，而D...
TCP客户端与服务端
一醉一休的博客
02-23 6499
前言 socket(简称：套接字)是进程之间通信的一个工具，好比现实中的插座，所有的家用电器要想工作都是基于插座进行，进程之间想要进行网络通信需要基于这个socket，负责进程之间的网络数据传输，好比数据的搬运工 一、TCP客户端开发 import socket # 1.创建客户端套接字对象 # 参数1：ipv4（ip协议的版本） # 参数2：选择协议（SOCK_STREAM==>TCP协议） tcp_client_socket = socket.socket(socket.AF_I..
from socket import socket, AF_INET, SOCK_STREAM from threading import Thread configs_file = open("configs") configs = eval("".join(configs_file.readlines())) tcp_socket_server = socket(AF_INET, SOCK_STREAM) def mainThread(): global tcp_socket_server address = ('localhost', 6000) tcp_socket_server.bind(address) tcp_socket_server.listen(128) while True: client_socket, client_addr = tcp_socket_server.accept() client_socket.send(configs["START"].encode('utf-8')) while True: recv_data = client_socket.recv(2048) recv_data = recv_data.decode('utf-8')[1:] if recv_data: print("We got:", recv_data) client_socket.send('Copy that'.encode('utf-8')) else: client_socket.close() break def inputThread(): # FIXME: The server cannot be stopped properly, # and if the client turns down after the server 'stops', the server crashes. global tcp_socket_server print("Type 'stop' to stop the server\nHowever make sure that there is no people online\nOr client will CRASH") while True: if input() == 'stop': tcp_socket_server.shutdown(2) tcp_socket_server.close() print("Server closed") return if __name__ == "__main__": main = Thread(target=mainThread) input_things = Thread(target=inputThread) main.start() input_things.start()
最新发布
05-24
这是一个使用 Python 编写的简单 Socket 服务器程序。主要包含两个线程：`mainThread` 和 `inputThread`。 `mainThread` 线程主要负责监听客户端的连接请求，并接收客户端发送的数据，然后进行处理并回复客户端。其中 `configs` 是从配置文件中读取的一些配置信息，`tcp_socket_server` 是服务器的 socket 对象，用于监听客户端连接请求。 `inputThread` 线程主要负责从控制台接收用户输入，如果用户输入了 "stop"，则会调用 `tcp_socket_server.shutdown(2)` 和 `tcp_socket_server.close()` 方法来停止服务器。 需要注意的是，该程序存在一些缺陷，比如不能安全地停止服务器，如果没有处理好在线用户的情况，停止服务器后客户端可能会崩溃。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值