UDP通信流程&简单cs模型

UDP通信流程

sendto()函数，recvfrom()函数

#include <sys/types.h>
#include <sys/socket.h>

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                 struct sockaddr *src_addr, socklen_t *addrlen);
参数：
    sockfd：套接字
    buf：存从服务器（客户端）发来的数据
    len：buf的大小
    flags：0
    src_addr：服务器地址端口（客户端地址端口）注意强制类型转换和取地址
    addrlen：地址结构体的大小，注意取地址
返回值：
    成功：接收数据字节数
    失败：-1，并且error set
    对端关闭：0

/****************/
#include <sys/types.h>
#include <sys/socket.h>

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
               const struct sockaddr *dest_addr, socklen_t addrlen);
参数：
    sockfd：套接字
    buf：存要发送的数据
    len：buf的大小
    flags：0
    src_addr：目的端地址端口，注意强制类型转换和取地址
    addrlen：地址结构体的大小（不用取地址）
返回值：
    成功：成功发送数据字节数
    失败：-1，并且error set

服务器程序框架

fd = socket(报式协议);         
bind(fd,服务器地址端口);
while(1) {
 	n = recvfrom(fd,信息，客户端地址端口);
    信息处理；
    sendto(fd,处理后的信息，客户端地址端口);
}
close(fd);

代码：

#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8000

int main(void) {

        struct sockaddr_in servaddr, cliaddr;
        int  sockfd;
        socklen_t cliaddr_len;
        char buf[MAXLINE];
        int n, i;
        char str[INET_ADDRSTRLEN];//接收客户端的IP地址
        //创建socket
        sockfd = Socket(AF_INET, SOCK_DGRAM, 0);
        //初始化服务器IP和端口
        bzero(&servaddr, sizeof(servaddr));     //结构体清零
        servaddr.sin_family = AF_INET;                  //IPv4
        servaddr.sin_port = htons(SERV_PORT);   //port
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);   //ip
        //绑定套接字，IP和端口
        Bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
        //阻塞等待客户端连接
        printf("Accepting connections ...\n");
        while (1) {
                cliaddr_len = sizeof(cliaddr);
                //接受客户端发来的信息
                n = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&cliaddr, &cliaddr_len);
                if (n == -1) {
                        perr_exit("recvfrom error");
                }
                printf("received from %s at Port %d\n", inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)), ntohs(cliaddr.sin_port));
                //小写转大写处理
                for (i = 0; i < n; i++) {
                        buf[i] = toupper(buf[i]);
                }
                //将处理完的数据发回给客户端
                n = sendto(sockfd, buf, n, 0, (struct sockaddr *)&cliaddr, sizeof(cliaddr));
                if (n == -1) {
                        perr_exit("sendto error");
                }
        }
        Close(sockfd);
        return 0;
}

客户端程序框架

fd = socket(报式协议);         
while(能从键盘读取数据) {
    sendto(fd,信息，服务器地址端口);
 	n = recvfrom(fd,服务器处理后的信息，服务器地址端口);
	将服务器处理后的信息输出到屏幕；
}
close(fd);

代码：

#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8000

int main(int argc, char *argv[]){

        struct sockaddr_in servaddr;
        int sockfd;
        char buf[MAXLINE];
        char str[INET_ADDRSTRLEN];
        int n;
        socklen_t servaddr_len;
        //创建套接字
        sockfd = Socket(AF_INET, SOCK_DGRAM, 0);
        //初始化服务器IP和PORT
        bzero((struct sockaddr *)&servaddr, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(SERV_PORT);
        servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");

        while (fgets(buf, sizeof(buf), stdin) != NULL) {        //键盘读 取
                //发送信息给服务器
                n = sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr *)&servaddr, sizeof(servaddr));
                if (n == -1) {
                        perr_exit("sendto error");
                }
                //读取服务器返回的信息
                n = recvfrom(sockfd, buf, sizeof(buf), 0, NULL, 0);
                if (n == -1) {
                        perr_exit("recvfrom error");
                }
                //将接受到的信息输出到屏幕
                Write(STDOUT_FILENO, buf, n);

        }
        Close(sockfd);

        return 0;
}

错误处理模块

//wrap.c
#include "wrap.h"

void perr_exit(const char *s){
        perror(s);
        exit(1);
}
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr){
        int n;

        while ((n = accept(fd, sa, salenptr)) < 0) {
                if ((errno == ECONNABORTED) || (errno == EINTR)) {
                        continue;
                } else {
                        perr_exit("accept error");
                        break;
                }
        }
        return n;
}
void Bind(int fd, const struct sockaddr *sa, socklen_t salen){
        if (bind(fd, sa, salen) < 0)
                perr_exit("bind error");
}
void Connect(int fd, const struct sockaddr *sa, socklen_t salen){
        if (connect(fd, sa, salen) < 0)
                perr_exit("connect error");
}
void Listen(int fd, int backlog){
        if (listen(fd, backlog) < 0)
                perr_exit("listen error");
}
int Socket(int family, int type, int protocol){
        int n;
        if ( (n = socket(family, type, protocol)) < 0)
                perr_exit("socket error");
        return n;
}
ssize_t Read(int fd, void *ptr, size_t nbytes){
        ssize_t n;

        while ( (n = read(fd, ptr, nbytes)) == -1) {
                if (errno == EINTR) {
                        continue;
                } else {
                        return -1;
                        break;
                }

        }
        return n;
}
ssize_t Readn(int fd, void *vptr, size_t n){
        size_t nleft;
        ssize_t nread;
        char *ptr;

        ptr = vptr;
        nleft = n;
        while (nleft > 0) {
                if ( (nread = read(fd, ptr, nleft)) < 0) {
                        if (errno == EINTR)
                                nread = 0;
                        else
                                return -1;
                } else if (nread == 0)
                        break;
                nleft -= nread;
                ptr += nread;
        }
        return n - nleft;
}

static ssize_t my_read(int fd, char *ptr){
        static int read_cnt;
        static char *read_ptr;
        static char read_buf[100];

        if (read_cnt <= 0) {

                while ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
                    if (errno == EINTR) {
                                continue;
                        }
                    return -1;
                }
            if (read_cnt == 0)
                        return 0;
            read_ptr = read_buf;
        }
        read_cnt--;
        *ptr = *read_ptr++;
        return 1;
}
ssize_t Readline(int fd, void *vptr, size_t maxlen) {
        ssize_t n, rc;
        char c, *ptr;

        ptr = vptr;
        for (n = 1; n < maxlen; n++) {
                if ((rc = my_read(fd, &c)) == 1) {
                        *ptr++ = c;
                        if (c == '\n')
                                break;
                } else if (rc == 0) {
                        *ptr = 0;
                        return n - 1;
                } else
                        return -1;
        }
        *ptr = 0;
        return n;
}

ssize_t Write(int fd, const void *ptr, size_t nbytes){
        ssize_t n;

        while ( (n = write(fd, ptr, nbytes)) == -1) {
                if (errno == EINTR) {
                        continue;
                } else {
                        return -1;
                }
        }
        return n;
}
ssize_t Writen(int fd, const void *vptr, size_t n){
        size_t nleft;
        ssize_t nwritten;
        const char *ptr;

        ptr = vptr;
        nleft = n;
        while (nleft > 0) {
                if ((nwritten = write(fd, ptr, nleft)) <= 0) {
                        if (nwritten < 0 && errno == EINTR)
                                nwritten = 0;
                        else
                                return -1;
                }
                nleft -= nwritten;
                ptr += nwritten;
        }
        return n;
}
void Close(int fd){
        if (close(fd) == -1)
                perr_exit("close error");
}
//wrap.h
#ifndef WRAP_H
#define WRAP_H

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <strings.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <signal.h>
#include <sys/wait.h>

void perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
void Bind(int fd, const struct sockaddr *sa, socklen_t salen);
void Connect(int fd, const struct sockaddr *sa, socklen_t salen);
void Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Readn(int fd, void *vptr, size_t n);
static ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
ssize_t Writen(int fd, const void *vptr, size_t n);
void Close(int fd);

#endif