Linux UDP网络编程套接字sockets介绍

struct sockaddr_in {
    short int sin_family;           // 地址族，一般为af_inet或pf_inet
    unsigned short int sin_port;    // 端口号，网络字节序
    struct in_addr sin_addr;        // ip地址
    unsigned char sin_zero[8];      // 用于填充，使sizeof(sockaddr_in)等于16
};

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <strings.h>
#include <string.h>
#include <cerrno>
#include "log.hpp"


log lg;
const std::string defaultip = "0.0.0.0";

enum
{
    sockfderr = 1,
    binderr,

};
class udpserver
{
public:
    udpserver(const uint16_t& port = 8080,const std::string& ip = defaultip)
    :_port(port)
    ,_ip(ip)
    ,sockfd(-1)
    {}
    void init()
    {
        //1.创建套接字
        sockfd = socket(af_inet,sock_dgram,0);
        if(sockfd < 0)
        {
            lg(fatal,"sockfd create error %d", sockfd);
            exit(sockfderr);
        }
        lg(info,"sockfd create success %d", sockfd);
        //2.bind:将用户设置的的ip和port在内核中和我们当前的进程相关联
        struct sockaddr_in local;
        bzero(&local,0);
        local.sin_family = af_inet;
        local.sin_port = htons(_port); //主机转网络 h表示host，n表示network
        local.sin_addr.s_addr = inet_addr(_ip.c_str());  //1. string -> uint32_t 2. uint32_t必须是网络序列的 //
        if(bind(sockfd,(const struct sockaddr*)&local,sizeof(local)) < 0)
        {
            lg(fatal, "bind error, errno: %d, err string: %s", errno, strerror(errno));
            exit(binderr);
        }
        lg(info,"bind success!");
    }
    void start()
    {
        char buffer[1024];
        while(true)
        {
            //纯输出型参数
            struct sockaddr_in client;
            //清空数据
            bzero(&client,0);
            socklen_t len = sizeof(client);
            ssize_t n = recvfrom( sockfd , buffer,sizeof(buffer)-1, 0 , (struct sockaddr*)&client , &len);
            if(n < 0)
            {
                lg(warning, "recvfrom error, errno: %d, err string: %s", errno, strerror(errno));
                continue;
            } 
            buffer[n] = 0;
            uint16_t port = ntohs(client.sin_port); //client是从网络来，我们要转为主机字序
            std::string ip = inet_ntoa(client.sin_addr); //4字节的网络序列要转化回本主机的字符串风格的ip
            sendto(sockfd, buffer, strlen(buffer), 0, (const sockaddr*)&client, len);
        }
    }
    ~udpserver()
    {
        if(sockfd>0) close(sockfd);
    }

private:
    int sockfd; //网络套接字描述符
    std::string _ip;    //ip地址
    uint16_t _port;        //端口号
};

#include "udpserver.hpp"
#include <memory>

void usage(std::string s)
{
    std::cout << "\n\rusage: " << s << " port[1024+]\n" << std::endl;
}
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        usage(argv[0]);
        exit(0);
    }
    uint16_t port = std::stoi(argv[1]);
    udpserver* ptr = new udpserver(port);  //创建一个服务器对象
    ptr->init();  //初始化服务器对象
    ptr->start();  //启动服务器

    return 0;
}

#include <iostream>
#include <string.h>
#include <string>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

void usage(const std::string& s)
{
    std::cout << "\n\rusage: " << s << " serverip serverport\n" << std::endl;
}
int main(int argc , char* argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        exit(0);
    }
    int sockfd = socket(af_inet,sock_dgram,0);
    if(sockfd < 0)
    {
        std::cerr << "socket error!" <<std::endl;
        exit(1);
    }
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);

    struct sockaddr_in server;
    bzero(&server,0);
    server.sin_family = af_inet;
    server.sin_port = htons(serverport);
    server.sin_addr.s_addr = inet_addr(serverip.c_str());
    char buffer[1024];
    std::string message;
    socklen_t len = sizeof(server);
    while(true)
    {
        std::cout << "client say# ";
        std::getline(std::cin,message);
        //当client首次给服务器发送消息的时候，os会自动bind client的port和ip
        sendto(sockfd,message.c_str(),message.size(),0,(struct sockaddr*)&server,len);

        struct sockaddr_in temp;
        socklen_t temp_len = sizeof(temp);
        ssize_t n = recvfrom(sockfd,buffer,sizeof(buffer)-1,0,(sockaddr*)&temp,&temp_len);
        if(n > 0)
        {
            buffer[n] = 0;
            std::cout << "server say$ " << buffer << std::endl;
        }
    }
    close(sockfd);
   

    return 0;
}

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <strings.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include "terminal.hpp"

using namespace std;

void usage(std::string proc)
{
    std::cout << "\n\rusage: " << proc << " serverip serverport\n"
              << std::endl;
}

struct threaddata
{
    struct sockaddr_in server;
    int sockfd;
    std::string serverip;
};

void *recv_message(void *args)
{
    // openterminal();
    threaddata *td = static_cast<threaddata *>(args);
    char buffer[1024];
    while (true)
    {
        memset(buffer, 0, sizeof(buffer));
        struct sockaddr_in temp;
        socklen_t len = sizeof(temp);

        ssize_t s = recvfrom(td->sockfd, buffer, 1023, 0, (struct sockaddr *)&temp, &len);
        if (s > 0)
        {
            buffer[s] = 0;
            cerr << buffer << endl;
        }
    }
}

void *send_message(void *args)
{
    threaddata *td = static_cast<threaddata *>(args);
    string message;
    socklen_t len = sizeof(td->server);

    std::string welcome = td->serverip;
    welcome += " comming...";
    sendto(td->sockfd, message.c_str(), message.size(), 0, (struct sockaddr *)&(td->server), len);

    while (true)
    {
        cout << "please enter@ ";
        getline(cin, message);

        // std::cout << message << std::endl;
        // 1. 数据 2. 给谁发
        sendto(td->sockfd, message.c_str(), message.size(), 0, (struct sockaddr *)&(td->server), len);
    }
}

// 多线程
// ./udpclient serverip serverport
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        usage(argv[0]);
        exit(0);
    }
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);

    struct threaddata td;
    bzero(&td.server, sizeof(td.server));
    td.server.sin_family = af_inet;
    td.server.sin_port = htons(serverport); //?
    td.server.sin_addr.s_addr = inet_addr(serverip.c_str());

    td.sockfd = socket(af_inet, sock_dgram, 0);
    if (td.sockfd < 0)
    {
        cout << "socker error" << endl;
        return 1;
    }

    td.serverip = serverip;

    pthread_t recvr, sender;
    pthread_create(&recvr, nullptr, recv_message, &td);
    pthread_create(&sender, nullptr, send_message, &td);

    pthread_join(recvr, nullptr);
    pthread_join(sender, nullptr);

    close(td.sockfd);
    return 0;
}

#define _winsock_deprecated_no_warnings 1
#include <iostream>
#include <winsock2.h>
#include <windows.h>
#include <string>
using namespace std;

uint16_t port = 8080;
std::string serverip = "8.155.26.31";
#pragma comment(lib, "ws2_32.lib")
int main()//_tmain,要加＃include <tchar.h>才能用
{
    wsadata wsadata;           //初始化信息
    word sockversion = makeword(2, 2);

    //启动winsock
    if (wsastartup(sockversion,&wsadata) != 0) {
        cout << "wsastartup error = " << wsagetlasterror() << endl;
        return 0;
    }
    else {
        cout << "start success" << endl;
    }

    //创建socket
    socket clientsocket = socket(af_inet, sock_dgram, 0);
    if (clientsocket == socket_error) {
        cout << "socket error = " << wsagetlasterror() << endl;
        return 1;
    }
    else {
        cout << "socket success" << endl;
    }

    sockaddr_in dstaddr;
    dstaddr.sin_family = af_inet;
    dstaddr.sin_port = htons(port);
    dstaddr.sin_addr.s_un.s_addr = inet_addr(serverip.c_str());
    char buffer[1024];
    while (true)
    {
        std::string message;
        std::cout << "client say# ";
        std::getline(std::cin, message);
        sendto(clientsocket, message.c_str(), (int)message.size(), 0, (struct sockaddr*)&dstaddr, sizeof(dstaddr));
        struct sockaddr_in temp;
        int len = sizeof(temp);

        int s = recvfrom(clientsocket, buffer, 1023, 0, (struct sockaddr*)&temp, &len);
        if (s > 0)
        {
            buffer[s] = 0;
            std::cout << "server say$ " << buffer << std::endl;
        }
    }
    //关闭socket连接
    closesocket(clientsocket);
    wsacleanup();
    return 0;
}