udp广播发送数据

//server

#include   <stdio.h>
#include   <sys/types.h>
#include   <sys/socket.h>
#include   <stdlib.h>
#include   <errno.h>
#include   <string.h>
#include   <unistd.h>
#include   <netinet/in.h>
#include   <fcntl.h>

int   Udp_Init(char   *local_ip,unsigned   short   local_port,char   *goal_ip,unsigned   short   goal_port,struct   sockaddr_in   *sendaddr,int   flag)
{
    int   i,sockfd,Broadcast;
    struct   sockaddr_in   local_addr;

    sockfd=socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd==-1)
    {
        close(sockfd);
        #ifndef   DAMEON
        printf( "socket   creat   error/n ");
        #else
        syslog(LOG_ERR, "UDP   SOCKET   Create   error/n ");
        #endif
        return   -1;
    }

    memset(&local_addr,0,sizeof(struct   sockaddr));
    local_addr.sin_family=AF_INET;
    local_addr.sin_addr.s_addr=inet_addr(local_ip);
    local_addr.sin_port=htons(local_port);

    if(bind(sockfd,(struct   sockaddr   *)&(local_addr),sizeof(struct   sockaddr))==-1)
    {
        close(sockfd);
        printf( "   %s/n ",local_ip);
        #ifdef   DAMEON
        syslog(LOG_ERR, "UDP   BIND/n ");
        #else
        printf( "bind   error/n ");
        #endif
        return   sockfd;
    }

    //判断套接字的创建是否为非阻塞方式
    if(flag> 0){
        if( (flag=fcntl(sockfd,F_SETFL,0)) < 0)
        #ifndef   DAMEON
        printf( "fcntl   error/n ");
        #endif
        flag   |=O_NONBLOCK;
        if( fcntl(sockfd,F_SETFL,flag) < 0)
        #ifndef   DAMEON
        printf( "fcntl   nonblock   error/n ");
        #endif
    }
    if( goal_ip != NULL ){
        memset(sendaddr,0,sizeof(struct   sockaddr));
        sendaddr-> sin_family=AF_INET;
        sendaddr-> sin_addr.s_addr=inet_addr(goal_ip);
        sendaddr-> sin_port=htons(goal_port);

        //判断发送IP是否为广播IP
        if( (sendaddr->sin_addr.s_addr >> 24) == 0xff)
        {
            int   Broadcast=1;
            sendaddr-> sin_addr.s_addr   =   htonl(INADDR_BROADCAST);
            if( setsockopt(sockfd,SOL_SOCKET,SO_BROADCAST,(const char *)&(Broadcast),sizeof(int)) == -1)
            {
                close(sockfd);
                #ifdef   DAMEON
                syslog(LOG_ERR, "UDP   BROADCAST   SET   error/n ");
                #else
                printf( "   broadcast   setup   error/n ");
                #endif

                return -1;
            }
        }
        printf("set sockfd broadcast ok/n");
    }
    printf("sockfd init ok/n");
    return   sockfd;
}

int main(int argc, char ** argv)
{
    struct   sockaddr_in   sendaddr;
    int sock_fd;
    int count=100;
    int rec;
    if( argc <3 ){
        printf("usage error input local IP  to IP/n");
        return ;
    }
    if( (sock_fd=Udp_Init(argv[1],9001,argv[2],9001,&sendaddr,0) ) == -1)
    {
        perror("udp_init error");
    }
        sleep(1);
        printf("socket:%d/n",sock_fd);
    while( count-- ){
        rec=0;
        rec=sendto(sock_fd, "hello",5, 0, (struct sockaddr*)&sendaddr, sizeof(struct sockaddr_in));
        printf("sendto len:%d/n",rec);
        rec=0;
        usleep(100);
    }
}

 

//client

#include   <stdio.h>
#include   <sys/types.h>
#include   <sys/socket.h>
#include   <stdlib.h>
#include   <errno.h>
#include   <string.h>
#include   <unistd.h>
#include   <netinet/in.h>
#include   <fcntl.h>
#include   <assert.h>
//========================================================
static int sock_fd;


//========================================================
//name:int udpc_init(void *p)
//args:void *p
//retu:
//func:
//========================================================
int udpc_init(void *p){
    int   nSize,fBroadcast,count=1;
    int   port=*(int*)p;
    struct   sockaddr_in   Local_rec_addr;
    nSize = sizeof(struct   sockaddr);
    if( ( sock_fd = socket(AF_INET,SOCK_DGRAM,0) ) < 0 ){
        perror("socket error");
        return -1;
    }

    memset(&Local_rec_addr,0,sizeof(Local_rec_addr));
    Local_rec_addr.sin_family=AF_INET;
    Local_rec_addr.sin_port = htons(port);
    int   Broadcast=1;
    if( setsockopt(sock_fd,SOL_SOCKET,SO_BROADCAST,(const char *)&(Broadcast),sizeof(int)) == -1){
            perror("setsockopt error");
        }
    int flag=0;
    if(flag > 0){
        if((flag = fcntl(sock_fd,F_SETFL,0)) < 0 )
        #ifndef   DAMEON
        perror( "fcntl   error/n ");
        #endif
        flag   |= O_NONBLOCK;
        if(fcntl(sock_fd,F_SETFL,flag) < 0 )
        #ifndef   DAMEON
        perror( "fcntl   nonblock   error/n ");
        #endif
    }
    if( bind(sock_fd,(struct   sockaddr   *)&Local_rec_addr,sizeof(Local_rec_addr)) == -1){
        perror("bind error");
        return -1;
    };
    return sock_fd;
}
//========================================================
//name:int udpc_getdata(char *buff, int max)
//args:char *, int
//retu:the lenof recevd data.
//func:
//========================================================
int udpc_getdata(char *buff, int max){
    printf("sock_fd:%d/n",sock_fd);
    assert(buff != NULL);
    char *buffp=buff;
    int count=max;
    int tmp;
    struct sockaddr_in Remote_rec_addr;
    int nSize = sizeof(struct sockaddr);

    while(count >0)
    {
        tmp= recvfrom(sock_fd,buffp,count,   0,(struct sockaddr *)&(Remote_rec_addr), &nSize) ;
        if(tmp < 0 ){
            perror("recvfrom error");
            break;
        }
        printf( " %s:%d/n ",buffp,tmp);
        buffp +=tmp;
        count -=tmp;
    }
    return   max-count;
}
//========================================================
//name:int udpc_fina()
//args:
//retu:
//func:
//========================================================
int udpc_fina(){
    close(sock_fd);
}

 

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

    char  buff[2000];
    int   recvlen;
       int   udp_port=9001;
        memset((char *)buff, 0 , sizeof(buff));
    if(  udpc_init(&udp_port) == -1){
        perror("init sock_fd error");
        exit(1);
    }
    recvlen=udpc_getdata(buff, sizeof(buff));
    udpc_fina();
    return   0;
}