开源库实现对UDP协议的处理［作业］

0.UDP客户端

/**
  udpclient.c
*/
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <string.h>
#include <strings.h>

#define PORT 8111
#define MSG_LEN 1024

int main(int argc, char* argv[])
{
    int  sockfd;
    char send_buf[MSG_LEN] = { 0 };
    char recv_buf[MSG_LEN + 1] = { 0 };
    struct sockaddr_in serv_addr;

    if (argc != 2) {
        printf("usage: udpclient <ip address>\n");
        _exit(-1);
    }

    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
    inet_pton(AF_INET, argv[1], &serv_addr.sin_addr);
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);

    while (gets(send_buf) != NULL) {
        sendto(sockfd, 
            send_buf, 
            strlen(send_buf), 
            0, 
            (struct sockaddr *)&serv_addr, 
            sizeof(serv_addr));
        int n = recvfrom(sockfd, recv_buf, MSG_LEN, 0, NULL, NULL);
        if (n > 0) {
            recv_buf[n] = '\0';
            printf("recv[%s|%d]\n", recv_buf, n);
        }
    }

    return 0;
}

# gcc -g -o udpclient udpclient.c
# ./udpclient

 

1.使用libevent实现对UDP的处理

/**
  event_udpserver.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <event.h>
#include <event2/listener.h>

#define PORT 8111
#define MSG_LEN 1024

void read_cb(int fd, short event, void *arg) {
    char buf[MSG_LEN];
    int len;
    socklen_t addr_len = sizeof(struct sockaddr);
    struct sockaddr_in cli_addr;

    memset(buf, 0, sizeof(buf));
    len = recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *)&cli_addr, &addr_len);

    if (len == -1) {
        perror("recvfrom");
    } else if (len == 0) {
        printf("Connection Closed\n");
    } else {
        buf[len] = '\0';
        printf("recv[%s:%d]\n", buf, len);
        sendto(fd, buf, len, 0, (struct sockaddr *)&cli_addr, addr_len);
    }
}

int bind_socket(struct event *ev) {
    int sock_fd;
    int flag = 1;
    struct sockaddr_in local_addr;

    if ((sock_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket");
        return -1;
    }

    if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag)) < 0) {
        perror("setsockopt");
        return 1;
    }

    memset(&local_addr, 0, sizeof(local_addr));
    local_addr.sin_family = AF_INET;
    local_addr.sin_port = htons(PORT);
    local_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind(sock_fd, (struct sockaddr *)&local_addr, sizeof(struct sockaddr)) < 0) {
        perror("bind");
        return -1;
    } else {
        printf("bind success, port[%d]\n", PORT);
    }

    event_set(ev, sock_fd, EV_READ | EV_PERSIST, &read_cb, NULL);
    if (event_add(ev, NULL) == -1) {
        perror("event_set");
    }

    return 0;
}

int main() 
{
    struct event ev;

    if (event_init() == NULL) {
        perror("event_init");
        _exit(-1);
    }

    if (bind_socket(&ev) != 0) {
        perror("bind_socket");
        _exit(-1);
    }

    event_dispatch();

    return 0;
}

# gcc -std=c11 -g -o event_udpserver event_udpserver.c `pkg-config --libs --cflags libevent`
# ./event_udpserver

 

2.使用libuv实现对UDP的处理

/**
  uv_udpserver.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <uv.h>

#define PORT 8111
#define MSG_LEN 1024

uv_loop_t* loop = NULL;
uv_udp_t serv_socket;
uv_udp_t cli_socket;

void alloc_buffer(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf);

void on_read(uv_udp_t* handle, ssize_t nread, 
    const uv_buf_t* buf, const struct sockaddr * addr, unsigned flags);

void on_send(uv_udp_send_t* req, int status);

int main(int argc, char* argv[])
{
    loop = uv_default_loop();

    struct sockaddr_in serv_addr;
    uv_ip4_addr("0.0.0.0", PORT, &serv_addr);
    uv_udp_init(loop, &serv_socket);
    uv_udp_bind(&serv_socket, (struct sockaddr *)&serv_addr, UV_UDP_REUSEADDR);
    uv_udp_recv_start(&serv_socket, alloc_buffer, on_read);

    uv_udp_init(loop, &cli_socket);

    return uv_run(loop, UV_RUN_DEFAULT);;
}

void alloc_buffer(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf)
{
    printf("alloc size[%d]\n", suggested_size);
    buf->base = (char *)malloc(suggested_size);
    buf->len = suggested_size;
}

void on_read(uv_udp_t* handle, ssize_t nread, 
    const uv_buf_t* buf, const struct sockaddr * addr, unsigned flags)
{
    printf("on_read, nread[%d]\n", nread);
    uv_udp_send_t* req = NULL;
    if (nread == 0) {
        return;
    }

    req = malloc(sizeof(uv_udp_send_t));
    if (req == NULL) {
        return;    
    }

    uv_buf_t send_buf = uv_buf_init(buf->base, nread);
    uv_udp_send(req, handle, &send_buf, 1, addr, on_send);

    free(buf->base);
}

void on_send(uv_udp_send_t* req, int status)
{
    if (status != 0) {
        fprintf(stderr, "uv_udp_send error:%s\n", uv_strerror(status));
    }
}

# gcc -std=c11 -g -o uv_udpserver uv_udpserver.c `pkg-config --libs --cflags libuv` -D_XOPEN_SOURCE=600
# ./uv_udpserver