linux网络编程笔记——UDP

目前这部分代码会出现阻塞问题，暂时尚未解决

#include "udp.h"
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <malloc.h>
 
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>
#include <arpa/inet.h>
 
int PrintDiff(diff_t *diff)
{
    printf("\n\n-----------------------\n");
    printf("tow   : %f\n", diff->tow);
    printf("numBds: %d\n", diff->numBds);
    printf("numGps: %d\n", diff->numGps);
    printf("numGln: %d\n", diff->numGln);
    int j;
    printf("system: ");
    for (j = ; j < MAXSAT; ++j)
    {
        printf("%d ", diff->system[j]);
    }
    printf("\n");
 
    printf("PRN: ");
    for (j = ; j < MAXSAT; ++j)
    {
        printf("%d ", diff->PRN[j]);
    }
    printf("\n");
 
    printf("dDO: ");
    for (j = ; j < MAXSAT; ++j)
    {
        printf("%f ", diff->dDO[j]);
    }
    printf("\n");
 
    printf("dPR: ");
    for (j = ; j < MAXSAT; ++j)
    {
        printf("%f ", diff->dPR[j]);
    }
    printf("\n");
 
    printf("------------------------------------\n");
}
 
int server_len;
int client_len;
 
#define RECV_LOOP_COUNT 10
int recv_within_time(int fd, char *buf, size_t buf_n,struct sockaddr* addr,socklen_t *len,unsigned int sec,unsigned usec)
{
    struct timeval tv;
    fd_set readfds;
    int i=;
    unsigned int n=;
    for(i=;i<RECV_LOOP_COUNT;i++)
    {
        FD_ZERO(&readfds);
        FD_SET(fd,&readfds);
        tv.tv_sec=sec;
        tv.tv_usec=usec;
        select(fd+,&readfds,NULL,NULL,&tv);
        if(FD_ISSET(fd,&readfds))
        {
            if((n=recvfrom(fd,buf,buf_n,,addr,len))>=)
            {
                return n;
            }
        }
    }
    return -;
}
 
int rover_sock_fd;/*套接字文件描述符*/
struct sockaddr_in addr_rover_server;
int UdpRoverInit(char *server_ip)
{
    char SERVER_IP_ADDRESS[]="127.0.0.1";
    strcpy(SERVER_IP_ADDRESS, server_ip);
 
    rover_sock_fd = socket(AF_INET,SOCK_DGRAM,);//创建套接子
    //初始化服务器端地址
    memset(&addr_rover_server,,sizeof(addr_rover_server));
    addr_rover_server.sin_family = AF_INET;
    addr_rover_server.sin_addr.s_addr = inet_addr(SERVER_IP_ADDRESS);
    addr_rover_server.sin_port = htons(SERVER_PORT);
 
    server_len = sizeof(struct sockaddr_in);
    //printf("begin:\n");
    return rover_sock_fd;
}
 
int UdpRoverRecieve(diff_t *diff)
{
    int recv_num, i=;
    unsigned char recv_buf[MAX_LEN_ONCE];
    unsigned char send_buf[MAX_LEN_ONCE];
 
    unsigned char *_dest=malloc(sizeof(diff_t)+MAX_LEN_ONCE);
    memset((void *)_dest,,sizeof(diff_t)+MAX_LEN_ONCE);
 
    //发送命令
    memset(send_buf,,MAX_LEN_ONCE);
    strcpy(send_buf,"\nrover_get\n");
    //do
        sendto(rover_sock_fd,send_buf,MAX_LEN_ONCE,,(struct sockaddr *)&addr_rover_server,server_len);
        usleep();
        while()
        {
            recv_num = recv_within_time(rover_sock_fd,recv_buf,MAX_LEN_ONCE,(struct sockaddr *)&addr_rover_server,&server_len,,);
            if (recv_num<MAX_LEN_ONCE)
            {
                continue;
            }
            if(strncmp(recv_buf,"\nserver_start\n",strlen("\nserver_start\n")))
            {
                putchar(recv_buf);
                printf("@@%d\n", recv_num);
                //return 1;
            }
            else{
                printf("good\n");
                break;}
        }   
 
    while() {
        recv_within_time(rover_sock_fd,recv_buf,MAX_LEN_ONCE,(struct sockaddr *)&addr_rover_server,&server_len,,);
        if (!strncmp(recv_buf,"\nserver_end\n",strlen("\nserver_end\n"))) break;
        if (!strncmp("\nserver |",recv_buf,strlen("\nserver |")))
        {
            memcpy(_dest+i*(MAX_LEN_ONCE/),recv_buf+(MAX_LEN_ONCE/),MAX_LEN_ONCE/);
            ++i;
        }
        printf(".");
    }
 
    printf("-------------%d------------\n", i);
    if (i!=sizeof(diff_t)/(MAX_LEN_ONCE/)+)
    {
        printf("%d ,get wrong, will not update this time!\n", i);
    }
    else{
        memcpy((void *)diff, _dest, sizeof(diff_t)+MAX_LEN_ONCE);
        if ()
        {
            PrintDiff(diff);
        }
    }
 
    free(_dest);
    UdpClose(rover_sock_fd);
    return ;
}
 
int station_sock_fd;
struct sockaddr_in addr_station_server;
int UdpStationInit(char *server_ip)
{
    char SERVER_IP_ADDRESS[]="127.0.0.1";
    strcpy(SERVER_IP_ADDRESS, server_ip);
 
    station_sock_fd = socket(AF_INET,SOCK_DGRAM,);//创建套接子
    //初始化服务器端地址
    memset(&addr_station_server,,sizeof(addr_station_server));
    addr_station_server.sin_family = AF_INET;
    addr_station_server.sin_addr.s_addr = inet_addr(SERVER_IP_ADDRESS);
    addr_station_server.sin_port = htons(SERVER_PORT);
 
    server_len = sizeof(struct sockaddr_in);
    printf("begin send:\n");
 
    return ;
}
int UdpStationSend(diff_t *diff)
{
    int i=;
    int send_num;
 
    unsigned char send_buf[MAX_LEN_ONCE];
    unsigned char *src = (unsigned char *)diff;
 
    memset(send_buf,,MAX_LEN_ONCE);
    strcpy(send_buf,"\nstation_start\n");
    sendto(station_sock_fd,send_buf,MAX_LEN_ONCE,,(struct sockaddr *)&addr_station_server,server_len);
 
        int j;
        for (j = ; j < MAX_LEN_ONCE; ++j)
        {
            putchar(send_buf[j]);
        }
 
    for(i=;i<sizeof(diff_t)/+;++i)
    {
        memset(send_buf,,MAX_LEN_ONCE);
        strcpy(send_buf,"\nstation|");
        memcpy(send_buf+,src+i*(MAX_LEN_ONCE/),MAX_LEN_ONCE/);
 
        for (j = ; j < MAX_LEN_ONCE; ++j)
        {
            putchar(send_buf[j]);
        }
 
        send_num = sendto(station_sock_fd,send_buf,MAX_LEN_ONCE,,(struct sockaddr *)&addr_station_server,server_len);
 
        usleep();
    }
    printf("---%d----%d----%d----%d----\n", i,sizeof(diff_t),MAX_LEN_ONCE/,sizeof(diff_t)/(MAX_LEN_ONCE/));
 
    memset(send_buf,,MAX_LEN_ONCE);
    strcpy(send_buf,"\nstation_end\n");
    sendto(station_sock_fd,send_buf,MAX_LEN_ONCE,,(struct sockaddr *)&addr_station_server,server_len);
 
        for (j = ; j < MAX_LEN_ONCE; ++j)
        {
            putchar(send_buf[j]);
        }
 
    return ;
}
 
int server_sock_fd;   //套接子描述符号
struct sockaddr_in  addr_server, addr_server_client;
int UdpServerInit()
{
    int recv_num;
    int send_num;
 
    char recv_buf[MAX_LEN_ONCE];
 
    server_sock_fd = socket(AF_INET,SOCK_DGRAM,);
 
    if(server_sock_fd < ){
            perror("client socket");
            exit();
    } else{
            printf("client sock sucessful\n");
    }
 
    memset(&addr_server,,sizeof(struct sockaddr_in));
    addr_server.sin_family = AF_INET;//协议族
    addr_server.sin_port = htons(SERVER_PORT);
    addr_server.sin_addr.s_addr = htonl(INADDR_ANY);//任意本地址
 
    client_len = sizeof(struct sockaddr_in);
 
    /*绑定套接字*/
    if(bind(server_sock_fd,(struct sockaddr *)&addr_server,sizeof(struct sockaddr_in))< ){
            perror("server bind");
            return -;
    } else{
            printf("server bind sucess\n");
    }
 
    return ;
}
 
int UdpServerLoop(diff_t *diff, int arg)
{
    int recv_num,send_num, i=;
    unsigned char recv_buf[MAX_LEN_ONCE];
    unsigned char send_buf[MAX_LEN_ONCE];
 
    unsigned char *dest=malloc(sizeof(diff_t)+MAX_LEN_ONCE);
    memset((void *)dest,,sizeof(diff_t)+MAX_LEN_ONCE);
 
    unsigned char *src = (unsigned char *)diff;
    while()
    {
        //update diff data
        recv_num = recvfrom(server_sock_fd,recv_buf,MAX_LEN_ONCE,,(struct sockaddr *)&addr_server_client,&client_len);
        int j;
        if(recv_num < ) {
            perror("recv_from");
            return -;
        } 
 
            //update diff data
            if (!strncmp(recv_buf,"\nstation_start\n",strlen("\nstation_start\n")))
            {
                i=;
                while() {
                    recv_num = recvfrom(server_sock_fd,recv_buf,MAX_LEN_ONCE,,(struct sockaddr *)&addr_server_client,&client_len);
                    if(recv_num < ) {
                        perror("recv_from");
                        return -;
                    } 
 
                    if (!strncmp(recv_buf,"\nstation_end\n",strlen("\nstation_end\n"))) break;
                    if (!strncmp("\nstation|",recv_buf,strlen("\nstation|")))
                    {
                        memcpy(dest+i*(MAX_LEN_ONCE/),recv_buf+(MAX_LEN_ONCE/),MAX_LEN_ONCE/);
                        ++i;
                    }
                    //printf("recv sucessful\n");
 
                }
 
                printf("-------------%d------------\n", i);
                if (i!=sizeof(diff_t)/(MAX_LEN_ONCE/)+)
                {
                    printf("get wrong, will not update this time!\n");
                }
                else{
                    memcpy((void *)diff, dest, sizeof(diff_t)+MAX_LEN_ONCE);
                    if (arg)
                    {
                        PrintDiff(diff);
                    }
                }
 
            }
 
            //send diff data
            if(!strncmp(recv_buf,"\nrover_get\n",strlen("\nrover_get\n")))
            {
                memset(send_buf,,MAX_LEN_ONCE);
                strcpy(send_buf,"\nserver_start\n");
                sendto(server_sock_fd,send_buf,MAX_LEN_ONCE,,(struct sockaddr *)&addr_server_client,client_len);
 
                //以后要防溢出s
                for(i=;i<sizeof(diff_t)/(MAX_LEN_ONCE/)+;++i)
                {
                    strcpy(send_buf,"\nserver |");
                    memcpy(send_buf+(MAX_LEN_ONCE/),src+i*(MAX_LEN_ONCE/),MAX_LEN_ONCE/);
                    send_num = sendto(server_sock_fd,send_buf,MAX_LEN_ONCE,,(struct sockaddr *)&addr_server_client,client_len);
                    if(send_num < ){
                            perror("sendto");
                            return -;
                    } 
 
                }
                memset(send_buf,,MAX_LEN_ONCE);
                strcpy(send_buf,"\nserver_end\n");
                sendto(server_sock_fd,send_buf,MAX_LEN_ONCE,,(struct sockaddr *)&addr_server_client,client_len);
            }
    }
    return ;
}
 
int UdpClose(int sock_fd)
{
    close(sock_fd);
    return ;
}