跨临时网络的C程序之间的通信

我有以下服务器代码

    #include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>
#include <string.h>
#include <stdio.h>


#define HELLO_PORT 12345
#define HELLO_GROUP "255.0.0.37"

main(int argc, char *argv[])
{
    struct sockaddr_in addr;
        struct sockaddr_in client,server;
        int s,n;
        char index;
    int f; 
        char b1[100];
        int fd, cnt,i=0;;
        struct ip_mreq mreq;
        //char *message="Hello, World!";
    char *message=NULL;
        /* create what looks like an ordinary UDP socket */
        if ((fd=socket(AF_INET,SOCK_DGRAM,0)) < 0) 
    {
        perror("socket");
        exit(1);
        }
        s=socket(AF_INET,SOCK_DGRAM,0);
        server.sin_family=AF_INET;
        server.sin_port=2000;
        server.sin_addr.s_addr=inet_addr("10.42.0.47");
        bind(s,(struct sockaddr *)&server,sizeof(server));
        printf("\nServer ready,waiting for client....\n");
        n=sizeof(client);
        /* set up destination address */
        memset(&addr,0,sizeof(addr));
        addr.sin_family=AF_INET;
        addr.sin_addr.s_addr=inet_addr(HELLO_GROUP);
        addr.sin_port=htons(HELLO_PORT);

        /* now just sendto() our destination! */
        while (1) 
        {
        recvfrom(s,b1,sizeof(b1),0,(struct sockaddr *) &client,&n);
        printf("client : %s\n",b1);
        //sleep(5);
        index=b1[0];
        f=b1[0];
        //printf("b1[1] is %c\n",index);
        //printf("b1[0] is %c\n",f);
        f=32;
        b1[0]=f;
        //printf("new b1[0] is %c\n",b1[0]);
        //printf("%s\n",b1);
        if(index!='C')
        {
            if (sendto(fd,b1,sizeof(b1),0,(struct sockaddr *) &addr,sizeof(addr)) < 0)
            {
                    perror("sendto");
                    exit(1);
            }
            //i++;
            /*if(i>=4)
            {
                i=0;
            }*/
            sleep(1);
        }
        }
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义HELLO_端口12345
#定义HELLO_组“255.0.0.37”
main（int argc，char*argv[]）
{
地址中的结构sockaddr\u；
客户端、服务器中的结构sockaddr_；
int s，n；
煤焦指数；
int f；
charb1[100]；
int-fd，cnt，i=0；；
结构ip_mreq mreq；
//char*message=“你好，世界！”；
char*message=NULL；
/*创建看起来像普通UDP套接字的内容*/
if（（fd=套接字（AF_INET，SOCK_DGRAM，0））<0）
{
佩罗（“插座”）；
出口（1）；
}
s=插座（AF INET，SOCK DGRAM，0）；
server.sinu family=AF\u INET；
server.sin_port=2000；
server.sin_addr.s_addr=inet_addr（“10.42.0.47”）；
绑定（结构sockaddr*）和服务器，大小为（服务器））；
printf（“\n服务器就绪，正在等待客户端…”\n”）；
n=sizeof（客户）；
/*设置目标地址*/
memset（&addr，0，sizeof（addr））；
地址sinu family=AF\u INET；
addr.sin\u addr.s\u addr=inet\u addr（HELLO\u GROUP）；
地址sin_port=htons（HELLO_port）；
/*现在只发送到我们的目的地*/
而(1)
{
recvfrom（s，b1，sizeof（b1），0，（struct sockaddr*）和client，&n）；
printf（“客户端：%s\n”，b1）；
//睡眠（5）；
指数=b1[0]；
f=b1[0]；
//printf（“b1[1]是%c\n”，索引）；
//printf（“b1[0]是%c\n”，f）；
f=32；
b1[0]=f；
//printf（“新的b1[0]是%c\n”，b1[0]）；
//printf（“%s\n”，b1）；
如果（索引！='C'）
{
if（发送到（fd，b1，sizeof（b1），0，（struct sockaddr*）和addr，sizeof（addr））<0）
{
perror（“sendto”）；
出口（1）；
}
//i++；
/*如果（i>=4）
{
i=0；
}*/
睡眠（1）；
}
}
}

以及以下在不同系统上运行的客户端代码

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
#include <stdio.h> 
#include <mysql.h>

#define HELLO_PORT 12345
#define HELLO_GROUP "225.0.0.37"
#define MSGBUFSIZE 1024

main(int argc, char *argv[])
{
    MYSQL mysql; 
    MYSQL_ROW row; 
    MYSQL_RES *result; 
        unsigned int num_fields; 
    unsigned int i; 
    mysql_init(&mysql); 
        struct sockaddr_in server;
        int s,n;
    char b1[100],b2[100],a[100];
    char re[100]={0};
    char g=" ";
    printf("%c\n",re);
    strcpy(b2,"1");
    char message[20],ch='n';
        struct sockaddr_in addr;
        int fd, nbytes,addrlen,j=0;
        struct ip_mreq mreq;
        char msgbuf[MSGBUFSIZE];
        u_int yes=1;            /*** MODIFICATION TO ORIGINAL */

     /* create what looks like an ordinary UDP socket */
        if ((fd=socket(AF_INET,SOCK_DGRAM,0)) < 0) 
    {
        perror("socket");
        exit(1);
        }
    s=socket(AF_INET,SOCK_DGRAM,0);
        server.sin_family=AF_INET;
        server.sin_port=2000;
        server.sin_addr.s_addr=inet_addr("10.42.0.1");
        printf("\nClient ready....\n");
        n=sizeof(server);

    if (!mysql_real_connect(&mysql,"localhost","root","nidhi","project",0,NULL,0)) 
    {    
            fprintf(stderr, "Failed to connect to database: Error: %s\n", 
            mysql_error(&mysql)); 
    } 
    /**** MODIFICATION TO ORIGINAL */
        /* allow multiple sockets to use the same PORT number */
        if (setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes)) < 0) 
    {
            perror("Reusing ADDR failed");
            exit(1);
        }
    /*** END OF MODIFICATION TO ORIGINAL */
        /* set up destination address */
        memset(&addr,0,sizeof(addr));
        addr.sin_family=AF_INET;
        addr.sin_addr.s_addr=htonl(INADDR_ANY); /* N.B.: differs from sender */
        addr.sin_port=htons(HELLO_PORT);  
        /* bind to receive address */
        if (bind(fd,(struct sockaddr *) &addr,sizeof(addr)) < 0) 
    {
        perror("bind");
        exit(1);
        }

        /* use setsockopt() to request that the kernel join a multicast group */
        mreq.imr_multiaddr.s_addr=inet_addr(HELLO_GROUP);
        mreq.imr_interface.s_addr=htonl(INADDR_ANY);
        if (setsockopt(fd,IPPROTO_IP,IP_ADD_MEMBERSHIP,&mreq,sizeof(mreq)) < 0) 
    {
        perror("setsockopt");
        exit(1);
        }

        /* now just enter a read-print loop */
        while (1) 
    {
        /*if ((nbytes=recvfrom(fd,msgbuf,MSGBUFSIZE,0,(struct sockaddr *) &addr,&addrlen)) < 0) 
        {
                perror("recvfrom");
                exit(1);
        }
        printf("the server says: %s\n",msgbuf);*/
        printf("would you like to send?(y/n)\n");
        scanf("%c",&ch);
        fflush(stdin);
        if(ch=='y')
        {
        printf("\nClient:");
            gets(a);
        printf("%c\n",a);
        strcat(b2,a);
        printf("%s\n",b2);
            sendto(s,b2,sizeof(b2),0,(struct sockaddr *) &server,n);
        b2[100]=NULL;
        strcpy(b2,"1");
        }
        addrlen=sizeof(addr);
        if ((nbytes=recvfrom(fd,msgbuf,MSGBUFSIZE,0,(struct sockaddr *) &addr,&addrlen)) < 0) 
        {
                perror("recvfrom");
                exit(1);
        }
        printf("the server says: %s\n",msgbuf);
        if(mysql_query(&mysql,msgbuf));
        else
        {
            strcpy(re,"Client 1: ");
            sendto(s,re,sizeof(re),0,(struct sockaddr *) &server,n);
            //printf("inside else case\n");
            result=mysql_store_result(&mysql);
            //printf("\n after getting the result...\n");
            num_fields = mysql_num_fields(result); 
            //printf("\n after getting numfields...\n");
                while ((row = mysql_fetch_row(result))) 
                {    
                        unsigned long *lengths; 
                //printf("\n inside while....\n");
                        lengths = mysql_fetch_lengths(result); 
                        for(i = 0; i < num_fields; i++) 
                        { 
                                printf("[%.*s] \t", (int) lengths[i], row[i] ? row[i] : "NULL"); 
                    strcat(re,row[i]);
                    j++;
                    //printf("%d\n",j);
                    if(j==4)
                    {
                        //printf("the result is .....%s\n",re);
                        sendto(s,re,sizeof(re),0,(struct sockaddr *) &server,n);
                        memset(re,0,100);
                        strcpy(re,"Client 1: ");
                        j=0;
                    }

                        }    
                        printf("\n"); 
                } 
            } 
    }
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义HELLO_端口12345
#定义HELLO_组“225.0.0.37”
#定义MSGBUFSIZE 1024
main（int argc，char*argv[]）
{
MYSQL；
MYSQL_行；
MYSQL_RES*结果；
无符号整数字段；
无符号整数i；
mysql_init（&mysql）；
服务器中的结构sockaddr_；
int s，n；
字符b1[100]，b2[100]，a[100]；
char re[100]={0}；
char g=“”；
printf（“%c\n”，re）；
strcpy（b2，“1”）；
字符消息[20]，ch='n'；
地址中的结构sockaddr\u；
int fd，n字节，addrlen，j=0；
结构ip_mreq mreq；
字符msgbuf[MSGBUFSIZE]；
u_int yes=1；/***对原件的修改*/
/*创建看起来像普通UDP套接字的内容*/
if（（fd=套接字（AF_INET，SOCK_DGRAM，0））<0）
{
佩罗（“插座”）；
出口（1）；
}
s=插座（AF INET，SOCK DGRAM，0）；
server.sinu family=AF\u INET；
server.sin_port=2000；
server.sin_addr.s_addr=inet_addr（“10.42.0.1”）；
printf（“\n客户端就绪…”\n”）；
n=sizeof（服务器）；
if（！mysql\u real\u connect（&mysql，“localhost”，“root”，“nidhi”，“project”，0，NULL，0））
{    
fprintf（stderr，“无法连接到数据库：错误：%s\n”，
mysql_错误（&mysql））；
} 
/****对原件的修改*/
/*允许多个套接字使用相同的端口号*/
if（setsockopt（fd，SOL_SOCKET，SO_REUSEADDR，&yes，sizeof（yes））<0）
{
perror（“重用地址失败”）；
出口（1）；
}
/***原稿修改结束*/
/*设置目标地址*/
memset（&addr，0，sizeof（addr））；
地址sinu family=AF\u INET；
地址sin_addr.s_addr=htonl（INADDR_ANY）；/*N.B.：与发件人不同*/
地址sin_port=htons（HELLO_port）；
/*绑定到接收地址*/
if（bind（fd，（struct sockaddr*）&addr，sizeof（addr））<0）
{
佩罗（“绑定”）；
出口（1）；
}
/*使用setsockopt（）请求内核加入多播组*/
mreq.imr\u multiaddr.s\u addr=inet\u addr（HELLO\u GROUP）；
mreq.imr\u interface.s\u addr=htonl（INADDR\u ANY）；
if（setsockopt（fd、IPPROTO_IP、IP_ADD_MEMBERSHIP和mreq、sizeof（mreq））<0）
{
perror（“setsockopt”）；
出口（1）；
}
/*现在只需进入一个读打印循环*/
而(1)
{
/*如果（（nbytes=recvfrom（fd、msgbuf、MSGBUFSIZE、0、（struct sockaddr*）和addr、&addrlen））<0）
{
perror（“recvfrom”）；
出口（1）；
}
printf（“服务器说：%s\n”，msgbuf）*/
printf（“您想发送吗？（是/否）\n”）；
scanf（“%c”和“ch”）；
fflush（stdin）；
如果（ch='y'）
{
printf（“\n客户端：”）；
获得（a）；
printf（“%c\n”，a）；
strcat（b2，a）；
printf（“%s\n”，b2）；
sendto（s，b2，sizeof（b2），0，（struct sockaddr*）和server，n）；
b2[100]=NULL；
strcpy（b2，“1”）；
}
addrlen=sizeof（addr）；
如果（（nbytes=recvfrom（fd、msgbuf、MSGBUFSIZE、0、（struct sockaddr*）和addr、&addrlen））<0）
{
perror（“recvfrom”）；
出口（1）；
}
printf（“服务器说：%s\n”，msgbuf）；
if（mysql_查询（&mysql，msgbuf））；
其他的
{
strcpy（关于“客户1:”）；
发送到（s，re，sizeof（re），0，（struct sockaddr*）和服务器，n）；
//printf（“在其他情况下\n”）；
result=mysql\u store\u result（&mysql）；
//printf（“\n在得到结果之后…\n”）；
num\u fields=mysql\u num\u fields（结果）；
//printf（“\n获取numfields后…\n”）；
while（（row=mysql\u fetch\u row（result）））
{    
无符号长*长度；
//printf（“\n在内部，而….\n”）；