网络编程3-UDP协议

一、概念

1、核心特点

        无连接>>>发送方可以直接将数据封装成 UDP 数据报,按照目标地址和端口号发送出去

        不可靠>>>数据发送不稳定

        数据报>>>每个 UDP 数据报都包含报头和数据两部分

        开销小、支持广播和多播、效率 实时性

2、数据报

        从结构上看，一个 UDP 数据报由两大部分组成，即首部和数据部分 ：

• 首部：长度固定为 8 个字节，包含 4 个字段，分别是
  • 源端口号（2 字节，标识发送方的应用进程端口，可省略，若全为 0 则表示无端口 ）、
  • 目的端口号（2 字节，标识接收方的应用进程端口，必不可少 ）
  • 长度（2 字节，记录 UDP 数据报整体长度，包含首部和数据部分，最小值为 8，即只有首部时 ）
  • 校验和（2 字节，用于检测数据报在传输过程中是否出现错误，可选 ）
• 数据部分：承载着应用层传递下来的实际数据内容，长度不固定，但受限于 IP 数据报的最大长度（理论上 IP 数据报最大长度为 65535 字节，减去 UDP 首部和 IP 首部长度后，留给 UDP 数据部分的空间会更小 ）

二、UDP编程应用

1、c/s模型

• 客户端 主要函数接口
  • socket 
  •  sendto
• 服务器 主要函数接口
  • socket
  • bind //固定的地址信息 
  • recvfrom

2、示例

1）客户端：

2）服务器：

三、UDP聊天室

1、思路

1. 目的：构建udp类型的聊天室(类似于王者游戏大厅里陌生人之间的聊天)
2. 能够实现通过服务器能够使多个在线客户端进行聊天
3. 首先利用udp协议完成客户端和服务器的连接
4. 客户端
   1. 终端接收数据发往服务器，接收服务器发来的消息，可以利用线程实现
5. 服务器端
   1. 能够实现对在线客户端信息的接收和转发，发送的对象是聊天室所以在线人数除自己的所有人
   2. 如何界定上面聊天室的在线人数
      1. 利用数组实现，需要设置最大人数，在这个范围内遍历数组状态这一项，所以我们在发送数据时应该带上各自客户端的地址，找到在线状态，便可以向对应地址转发消息
      2. 利用链表，原则上就可以没有人数限制，然后对链表进行遍历（人数不限制，那反应的效率，资源开销问题，就有待考虑，本次练习并未尝试这种方法，感兴趣的话，可以试试）
6. 其次枚举客户端三种不同的状态，上线，聊天，下线
7. 传输数据时建立结构体，实现发送数据时，可以同时发送状态、名字、内容
8. 其次就是实现时的一些小细节
   1. 存放客户端信息入数组时，如何进行
      1. 应该再设置一个结构体，存放地址和存放状态
      2. 客户端上线之后，找空的数组（本身状态为0和是退出状态的客户端）
         1. 有空数组，将对应的信息存入数组结构体中
         2. 无空数组，即聊天室满了，设置客户端将进不去，并给服务器发送提示消息，并转发至聊天室提示信息（此项功能不是最主要的目标功能，在完成聊天室能够聊天之后再进行添加）
   2. 客户端要退出时，如何进行
      1. 先向聊天室发送消息，某客户端要退出
      2. 找到要退出客户端的数组，将其状态设置为QUIT
   3. 想要实现不同状态的不同操作（我们设置的状态是利用枚举）所以便可以用switch循环进行实现
   4. 结束退出时文件，进程的关闭
   5. 使用到的函数，以及知识点
      1. memcmp
         1. int memcmp(const void *ptr1, const void *ptr2, size_t num);比较从 ptr1 和 ptr2 开始的 num 个字节的内存内容（二者等于时返回值-0 、prt1小返回值-小于0、prt大 返回值-大于0 ）
      2. 枚举中的名字会对应一个数字值（默认或手动指定），但名字本身是标识符，数字是其属性，二者并非完全等同，而是 “名字关联数字” 的关系
      3. 网络构建：
         1. 绑定bind *就是服务器建设时，绑定自己的ip，让别人能够找到你
         2. 接收recvfrom（提前定义cliaddr）收到上线消息

2、代码实现        

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

#include <sys/types.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>

#define  MAX_PERSONS    3 


enum MSG_TYPE
{
	LOGIN = 1,
	CHAT,
	QUIT,
	FULL,
};

typedef struct Msg{
	enum MSG_TYPE type;
	char name[20];
	char text[256];
}msg_t;



#endif

客户端

#include "../head.h"

msg_t msg;
int clifd = 0;
pthread_t w_id;
pthread_t r_id;
struct sockaddr_in seraddr;

void *wthread(void *arg)
{
    while (1)
    {
        msg.type = CHAT;
        fgets(msg.text,sizeof(msg.text),stdin);
        msg.text[strlen(msg.text)-1] = '\0';
        if (0 == strcmp(msg.text,".quit"))
		{
            msg.type = QUIT;
		}
        sendto(clifd,&msg,sizeof(msg),0,(const struct sockaddr *)&seraddr,sizeof(seraddr));
        if (0 == strcmp(msg.text,".quit"))
        {
            msg.type = QUIT;
            break;
        }
    }
    pthread_cancel(r_id);

    return NULL;
}
void *rthread(void *arg)
{
    while (1)
    {
        msg_t msg1;
        recvfrom(clifd,&msg1,sizeof(msg1),0,NULL,NULL); 
        printf("[%s]%s\n",msg1.name,msg1.text);
        if (msg1.type == FULL)
        {
            break;
        }
    }
    pthread_cancel(w_id);


    return NULL;
}
int main(void)
{
    clifd = socket(AF_INET,SOCK_DGRAM,0);
    if (-1 == clifd)
    {
        perror("socket failed");
        return -1;
    }
    
    msg.type = LOGIN;
    printf("请输入你的名字\n");
    fgets(msg.name,sizeof(msg.name),stdin);
    msg.name[strlen(msg.name)-1] = '\0';
    sprintf(msg.text,"%s is login!",msg.name);


    bzero(&seraddr,sizeof(seraddr));
    seraddr.sin_family = AF_INET;
    seraddr.sin_port = htons(50000);
    seraddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    sendto(clifd,&msg,sizeof(msg),0,(const struct sockaddr *)&seraddr,sizeof(seraddr));

    pthread_create(&w_id,NULL,wthread,NULL);
    pthread_create(&r_id,NULL,rthread,NULL);

    pthread_join(w_id,NULL);
    pthread_join(r_id,NULL);

    close(clifd);

    return 0;
}

服务器

#include "../head.h"

#define  MAX_PERSONS    3 

struct table_cliaddr{
    struct sockaddr_in addr;
    int state;
}addrInfo[MAX_PERSONS];

int broadcast_msg(int serfd,struct sockaddr_in *cliaddr,msg_t *msg) //函数形参的类型//serfd不取地址
{
    int i = 0;
    for (i = 0; i < MAX_PERSONS; i++)
    {
        if (addrInfo[i].state == LOGIN && memcmp(&addrInfo[i].addr,cliaddr,sizeof(struct sockaddr_in)) != 0)
        {
            sendto(serfd,msg,sizeof(msg_t),0,(const struct sockaddr *)&addrInfo[i].addr,sizeof(struct sockaddr));
            //只需要考虑将这个msg发过去,至于打什么内容就看客户端
            
        }
    }
    return 0;
}


int main(void)
{
    int  serfd = socket(AF_INET,SOCK_DGRAM,0);
    if (-1 == serfd)
    {
        perror("socket failed");
        return -1;
    }

    struct sockaddr_in seraddr;

    bzero(&seraddr,sizeof(seraddr));
    seraddr.sin_family = AF_INET;
    seraddr.sin_port = htons(50000);
    seraddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    if (bind(serfd,(const struct sockaddr *)&seraddr,sizeof(seraddr)) < 0)
    {
        perror("bind failed");
        return -1;
    }

    struct sockaddr_in cliaddr;
    bzero(&cliaddr,sizeof(cliaddr));
    socklen_t len = sizeof(cliaddr);

    msg_t msg;
    int i = 0;
    char fialremain[256] = {"chat room full,try again later !"};


    while (1)
    {
        recvfrom(serfd,&msg,sizeof(msg),0,(struct sockaddr*)&cliaddr,&len);
	    printf("type = %d\n",msg.type);
	    printf("name = %s\n",msg.name);
	    printf("text = %s\n",msg.text);

        switch (msg.type){
            case LOGIN:
                //存数组里
                printf("--------login--------\n");
                for (i = 0; i < MAX_PERSONS; i++) //就是找空数组
                {
                    if (addrInfo[i].state == 0 || addrInfo[i].state == QUIT)
                    {
                        break;
                    }
                }
                if (i == MAX_PERSONS)
                {
                    printf("--------full--------\n");

                    addrInfo[i].state = FULL;
                    sprintf(msg.text,"chat room full,[%s] can't join,max_persons is %d\n",msg.name,MAX_PERSONS);
                    printf("%s",msg.text);
                    broadcast_msg(serfd,&cliaddr,&msg);
                    
                    
                    msg.type = FULL;
                    strcpy(msg.name,"serves");
                    strcpy(msg.text,"chat room full,try again later !");
                    sendto(serfd,&msg,sizeof(msg_t),0,(const struct sockaddr *)&cliaddr,sizeof(cliaddr));
                    break;
                }
                addrInfo[i].addr = cliaddr;
                addrInfo[i].state = LOGIN; // msg.type;have a try

                broadcast_msg(serfd,&cliaddr,&msg);//serfd?
                break;
            case CHAT:
                printf("--------chat-------\n");
                broadcast_msg(serfd,&cliaddr,&msg);
                break;
            case QUIT:
                printf("--------quit--------\n");
                
                broadcast_msg(serfd,&cliaddr,&msg);
                for (i = 0; i < MAX_PERSONS; i++)
                {
                    if (0 == memcmp(&addrInfo[i].addr,&cliaddr,sizeof(struct sockaddr_in))) 
                    {
                        addrInfo[i].state = QUIT;
                        break;
                    }
                }

        }
    } 


    close(serfd);

    return 0;
}

结果

注意事项

1. 多思考、多实践、多测试
2. 写完代码，多测试，把写的能出现的情况都细细测试一遍，尤其是后续实现完主要目的后，补充的内容，能够根据实际情况进行改变，增减，调试出符合预期的程序
3. 加油吧！！