【网络】Windows 下 socket 编程范例

#include "winsock2.h"
#include <stdint.h>
#include <stdio.h>

#include <ctype.h>
#include <time.h>

#define MAX_BUF_LEN 1024

#define ERR (-1)
#define OK  0

enum {
    TCP = 6,
    UDP = 17,
};

struct ClientPeer;
typedef int (*ClientVoidHandler)(struct ClientPeer *);
typedef int (*ClientRecvHandler)(struct ClientPeer *peer, char *buf, int len);
typedef int (*ClientSendHandler)(struct ClientPeer *peer, const char *buf, int len);

struct ClientPeerOp {
    ClientVoidHandler createsocket;
    ClientVoidHandler connect;
    ClientRecvHandler recv;
    ClientSendHandler send;
    ClientVoidHandler close;
};

struct ClientPeer {
    ClientPeerOp op;

    SOCKET fd;

    struct sockaddr_in remote;
};

int PeerEnvInit(void)
{
    WORD sockVersion = MAKEWORD(2, 2);
    WSADATA wsaData;
    if (WSAStartup(sockVersion, &wsaData) != 0) {
        return ERR;
    }
    return OK;
}

int PeerEnvDestroy(void)
{
    WSACleanup();
    return OK;
}

struct ClientPeer *ClientPeerNewWithRemote(const char *ip, unsigned short port)
{
    struct ClientPeer *peer = (struct ClientPeer *)calloc(1, sizeof(struct ClientPeer));

    peer->remote.sin_family = AF_INET;
    peer->remote.sin_port = htons(port);
    peer->remote.sin_addr.S_un.S_addr = inet_addr(ip);

    return peer;
};

int TCPClientPeerCreateSocket(struct ClientPeer *peer)
{
    SOCKET fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (fd == INVALID_SOCKET) {
        printf("socket error !");
        return ERR;
    }
    peer->fd = fd;
    return OK;
}

int TCPClientPeerConnect(struct ClientPeer *peer)
{
    if (connect(peer->fd, (struct sockaddr *)&(peer->remote), sizeof(struct sockaddr)) == SOCKET_ERROR) {
        printf("connect error !");
        return ERR;
    }
    return OK;
}

int TCPClientPeerSend(struct ClientPeer *peer, const char *buf, int len)
{
    return send(peer->fd, buf, len, 0);
}

int TCPClientPeerRecv(struct ClientPeer *peer, char *buf, int len)
{
    return recv(peer->fd, buf, len, 0);
}

int TCPClientPeerClose(struct ClientPeer *peer)
{
    closesocket(peer->fd);
    return OK;
}


int UDPClientPeerCreateSocket(struct ClientPeer *peer)
{
    SOCKET fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (fd == INVALID_SOCKET) {
        printf("socket error !");
        return ERR;
    }
    peer->fd = fd;
    return OK;
}

int UDPClientPeerConnect(struct ClientPeer *peer)
{
    return OK;
}

int UDPClientPeerSend(struct ClientPeer *peer, const char *buf, int len)
{
    return sendto(peer->fd, buf, len, 0, (struct sockaddr *)&(peer->remote), sizeof(struct sockaddr));
}

int UDPClientPeerRecv(struct ClientPeer *peer, char *buf, int len)
{
    int addrlen = sizeof(struct sockaddr_in);
    return recvfrom(peer->fd, buf, len, 0, (struct sockaddr *)&(peer->remote), &addrlen);
}

int UDPClientPeerClose(struct ClientPeer *peer)
{
    closesocket(peer->fd);
    return OK;
}

struct ClientPeer *ClientPeerFactory(int type, const char *ip, unsigned short port)
{
    struct ClientPeer *peer = ClientPeerNewWithRemote(ip, port);

    switch (type) {
        case TCP:
            peer->op.createsocket = TCPClientPeerCreateSocket;
            peer->op.connect = TCPClientPeerConnect;
            peer->op.recv = TCPClientPeerRecv;
            peer->op.send = TCPClientPeerSend;
            peer->op.close = TCPClientPeerClose;
            break;

        case UDP:
            peer->op.createsocket = UDPClientPeerCreateSocket;
            peer->op.connect = UDPClientPeerConnect;
            peer->op.recv = UDPClientPeerRecv;
            peer->op.send = UDPClientPeerSend;
            peer->op.close = UDPClientPeerClose;
            break;
    }

    return peer;
}




struct ServerPeer;
typedef int (*ServerVoidHandler)(struct ServerPeer *);
typedef int (*ServerRecvHandler)(struct ServerPeer *peer, char *buf, int len);
typedef int (*ServerSendHandler)(struct ServerPeer *peer, const char *buf, int len);

struct ServerPeerOp {
    ServerVoidHandler createsocket;
    ServerVoidHandler bindaddr;
    ServerVoidHandler listen;
    ServerVoidHandler accept;
    ServerRecvHandler recv;
    ServerSendHandler send;
    ServerVoidHandler closeclient;
    ServerVoidHandler close;
};

struct ServerPeer {
    SOCKET lfd;
    SOCKET rfd;

    struct sockaddr_in laddr;
    struct sockaddr_in raddr;

    struct ServerPeerOp op;
};


struct ServerPeer *ServerPeerNewWithAddr(const char *ip, unsigned short port)
{
    struct ServerPeer *peer = (struct ServerPeer *)calloc(1, sizeof(struct ServerPeer));

    peer->laddr.sin_family = AF_INET;
    peer->laddr.sin_port = htons(port);
    peer->laddr.sin_addr.S_un.S_addr = inet_addr(ip);

    return peer;
}

int TCPServerPeerCreateSocket(struct ServerPeer *peer)
{

    SOCKET fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (fd == INVALID_SOCKET) {
        printf("socket error !");
        return ERR;
    }
    peer->lfd = fd;
    return OK;
}

int TCPServerPeerBindaddr(struct ServerPeer *peer)
{
    if (bind(peer->lfd, (struct sockaddr *)&(peer->laddr), sizeof(struct sockaddr)) == SOCKET_ERROR) {
        printf("bind error !");
        return ERR;
    }

    return OK;
}

int TCPServerPeerListen(struct ServerPeer *peer)
{
    if (listen(peer->lfd, 5) == SOCKET_ERROR) {
        printf("listen error !");
        return ERR;
    }

    return OK;
}

int TCPServerPeerAccept(struct ServerPeer *peer)
{
    int len = sizeof(struct sockaddr_in);
    peer->rfd = accept(peer->lfd, (struct sockaddr *)&(peer->raddr), &len);
    if (peer->rfd == INVALID_SOCKET) {
        printf("accept error !");
        return ERR;
    }
    return OK;
}

int TCPServerPeerSend(struct ServerPeer *peer, const char *buf, int len)
{
    return send(peer->rfd, buf, len, 0);
}

int TCPServerPeerRecv(struct ServerPeer *peer, char *buf, int len)
{
    return recv(peer->rfd, buf, len, 0);
}

int TCPServerPeerCloseClient(struct ServerPeer *peer)
{
    closesocket(peer->rfd);
    return OK;
}

int TCPServerPeerClose(struct ServerPeer *peer)
{
    closesocket(peer->lfd);
    return OK;
}








int UDPServerPeerCreateSocket(struct ServerPeer *peer)
{

    SOCKET fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (fd == INVALID_SOCKET) {
        printf("socket error !");
        return ERR;
    }
    peer->lfd = fd;
    return OK;
}

int UDPServerPeerBindaddr(struct ServerPeer *peer)
{
    if (bind(peer->lfd, (struct sockaddr *)&(peer->laddr), sizeof(struct sockaddr)) == SOCKET_ERROR) {
        printf("bind error !");
        return ERR;
    }

    return OK;
}

int UDPServerPeerListen(struct ServerPeer *peer)
{
    return OK;
}

int UDPServerPeerAccept(struct ServerPeer *peer)
{
    return OK;
}

int UDPServerPeerSend(struct ServerPeer *peer, const char *buf, int len)
{
    return sendto(peer->lfd, buf, len, 0, (struct sockaddr *)&(peer->raddr), sizeof(struct sockaddr_in));
}

int UDPServerPeerRecv(struct ServerPeer *peer, char *buf, int len)
{
    int addrlen = sizeof(struct sockaddr_in);
    return recvfrom(peer->lfd, buf, len, 0, (struct sockaddr *)&(peer->raddr), &addrlen);
}

int UDPServerPeerCloseClient(struct ServerPeer *peer)
{
    return OK;
}

int UDPServerPeerClose(struct ServerPeer *peer)
{
    closesocket(peer->lfd);
    return OK;
}


struct ServerPeer *ServerPeerFactory(int type, const char *ip, unsigned short port)
{
    struct ServerPeer *peer = ServerPeerNewWithAddr(ip, port);

    switch (type) {
        case TCP:
            peer->op.createsocket = TCPServerPeerCreateSocket;
            peer->op.bindaddr = TCPServerPeerBindaddr;
            peer->op.listen = TCPServerPeerListen;
            peer->op.accept = TCPServerPeerAccept;
            peer->op.recv = TCPServerPeerRecv;
            peer->op.send = TCPServerPeerSend;
            peer->op.closeclient = TCPServerPeerCloseClient;
            peer->op.close = TCPServerPeerClose;
            break;

        case UDP:
            peer->op.createsocket = UDPServerPeerCreateSocket;
            peer->op.bindaddr = UDPServerPeerBindaddr;
            peer->op.listen = UDPServerPeerListen;
            peer->op.accept = UDPServerPeerAccept;
            peer->op.recv = UDPServerPeerRecv;
            peer->op.send = UDPServerPeerSend;
            peer->op.closeclient = UDPServerPeerCloseClient;
            peer->op.close = UDPServerPeerClose;
            break;
    }

    return peer;
}


struct Peer;
typedef void (*runhandler)(struct Peer *);



struct Peer {
    union {
        ClientPeer *client;
        ServerPeer *server;
    };
    runhandler op;
};

void ServerRun(struct Peer *p)
{
    struct ServerPeer *peer = p->server;
    struct ServerPeerOp *op = &(peer->op);

    op->createsocket(peer);
    op->bindaddr(peer);
    op->listen(peer);
    op->accept(peer);
    while (1) {
        int ret;
        char buf[MAX_BUF_LEN];
        time_t t = time(NULL);

        memset(buf, 0, sizeof(buf));
        op->recv(peer, buf, sizeof(buf));

        printf("server recv: %s
", buf);

        strncpy(buf, ctime(&t), sizeof(buf));
        ret = op->send(peer, buf, strlen(buf));
        if (ret <= 0) {
            printf("send failed(%d - %d).
", ret, WSAGetLastError());
            break;
        }
    }
}

void ClientRun(struct Peer *p)
{
    struct ClientPeer *peer = p->client;
    struct ClientPeerOp *op = &(peer->op);

    op->createsocket(peer);
    op->connect(peer);

    char hello[] = "Hello, I am client.
";

    op->send(peer, hello, strlen(hello));

    while (1) {
        char buf[MAX_BUF_LEN] = {0};
        int len = 0;

        len = op->recv(peer, buf, sizeof(buf));
        if (len <= 0) {
            printf("recv error (%d - %d) !
", len, WSAGetLastError());
            break;
        }
        printf("client recv: %s
", buf);

        for (int i = 0; i < len; i++) {
            buf[i] = toupper(buf[i]);
        }
        op->send(peer, buf, strlen(buf));

        Sleep(1000);
    }

    op->close(peer);
}


enum {
    TCP_SERVER = 1,
    TCP_CLIENT,
    UDP_SERVER,
    UDP_CLIENT,
};

struct Peer *PeerFactory(int type, const char *ip, unsigned short port)
{
    struct Peer *peer = (struct Peer *)calloc(1, sizeof(struct Peer));

    switch (type) {
        case TCP_SERVER:
            peer->server = ServerPeerFactory(TCP, ip, port);
            peer->op = ServerRun;
            break;
        case TCP_CLIENT:
            peer->client = ClientPeerFactory(TCP, ip, port);
            peer->op = ClientRun;
            break;
        case UDP_SERVER:
            peer->server = ServerPeerFactory(UDP, ip, port);
            peer->op = ServerRun;
            break;
        case UDP_CLIENT:
            peer->client = ClientPeerFactory(UDP, ip, port);
            peer->op = ClientRun;
            break;
    }

    return peer;
};


void PeerRun(struct Peer *peer)
{
    peer->op(peer);
}


int main()
{
    int type;
    printf("input way:              

              1. tcp server         

              2. tcp client         

              3. udp server         

              4. udp client         

           ");
    scanf("%d", &type);

    const char *ip = "127.0.0.1";
    unsigned short port = 10240;

    PeerEnvInit();

    struct Peer *peer = NULL;

    switch(type) {
        case 1:
        case 2:
        case 3:
        case 4:
            peer = PeerFactory(type, ip, port);
            PeerRun(peer);
            break;
        default:
            printf("unknown.");
            break;
    }

    PeerEnvDestroy();
}

使用的是 codeblock，需要链接 wsock32