Linux下网络编程实验

 （1）TCP程序设计

服务器端tcp_server.c

 

 
 
#include <stdlib.h>  
#include <stdio.h>  
#include <errno.h>  
#include <string.h>  
#include <netdb.h>  
#include <sys/types.h>  
#include <netinet/in.h>  
#include <sys/socket.h>  
 
#define portnumber 3333 
 
int main(int argc, char *argv[])  
{  
    int sockfd,new_fd;  
    struct sockaddr_in server_addr;  
    struct sockaddr_in client_addr;  
    int sin_size;  
    int nbytes; 
    char buffer[1024]; 
     
 
    /* 服务器端开始建立sockfd描述符 */  
    if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1) // AF_INET:IPV4;SOCK_STREAM:TCP 
    {  
        fprintf(stderr,"Socket error:%s\n\a",strerror(errno));  
        exit(1);  
    }  
 
    /* 服务器端填充 sockaddr结构 */  
    bzero(&server_addr,sizeof(struct sockaddr_in)); // 初始化,置0 
    server_addr.sin_family=AF_INET;                 // Internet 
    server_addr.sin_addr.s_addr=htonl(INADDR_ANY);  // (将本机器上的long数据转化为网络上的long数据)和任何主机通信  //INADDR_ANY 表示可以接收任意IP地址的数据，即绑定到所有的IP 
    //server_addr.sin_addr.s_addr=inet_addr("192.168.1.1");  //用于绑定到一个固定IP,inet_addr用于把数字加格式的ip转化为整形ip 
    server_addr.sin_port=htons(portnumber);         // (将本机器上的short数据转化为网络上的short数据)端口号 
     
    /* 捆绑sockfd描述符到IP地址 */  
    if(bind(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==-1)  
    {  
        fprintf(stderr,"Bind error:%s\n\a",strerror(errno));  
        exit(1);  
    }  
 
    /* 设置允许连接的最大客户端数 */  
    if(listen(sockfd,5)==-1)  
    {  
        fprintf(stderr,"Listen error:%s\n\a",strerror(errno));  
        exit(1);  
    }  
 
    while(1)  
    {  
        /* 服务器阻塞,直到客户程序建立连接 */  
        sin_size=sizeof(struct sockaddr_in);  
        if((new_fd=accept(sockfd,(struct sockaddr *)(&client_addr),&sin_size))==-1)  
        {  
            fprintf(stderr,"Accept error:%s\n\a",strerror(errno));  
            exit(1);  
        }  
        fprintf(stderr,"Server get connection from %s\n",inet_ntoa(client_addr.sin_addr)); // 将网络地址转换成.字符串 
         
        if((nbytes=read(new_fd,buffer,1024))==-1)  
        {  
            fprintf(stderr,"Read Error:%s\n",strerror(errno));  
            exit(1);  
        }        
        buffer[nbytes]='\0'; 
        printf("Server received %s\n",buffer); 
         
        /* 这个通讯已经结束 */  
        close(new_fd);  
        /* 循环下一个 */  
    }  
 
    /* 结束通讯 */  
    close(sockfd);  
    exit(0);  
}  
 

客户端tcp_client.c

 

 
 
#include <stdlib.h>  
#include <stdio.h>  
#include <errno.h>  
#include <string.h>  
#include <netdb.h>  
#include <sys/types.h>  
#include <netinet/in.h>  
#include <sys/socket.h>  
 
#define portnumber 3333 
 
int main(int argc, char *argv[])  
{  
    int sockfd;  
    char buffer[1024];  
    struct sockaddr_in server_addr;  
    struct hostent *host;  
 
        /* 使用hostname查询host 名字 */ 
    if(argc!=2)  
    {  
        fprintf(stderr,"Usage:%s hostname \a\n",argv[0]);  
        exit(1);  
    }  
 
    if((host=gethostbyname(argv[1]))==NULL)  
    {  
        fprintf(stderr,"Gethostname error\n");  
        exit(1);  
    }  
 
    /* 客户程序开始建立 sockfd描述符 */  
    if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1) // AF_INET:Internet;SOCK_STREAM:TCP 
    {  
        fprintf(stderr,"Socket Error:%s\a\n",strerror(errno));  
        exit(1);  
    }  
 
    /* 客户程序填充服务端的资料 */  
    bzero(&server_addr,sizeof(server_addr)); // 初始化,置0 
    server_addr.sin_family=AF_INET;          // IPV4 
    server_addr.sin_port=htons(portnumber);  // (将本机器上的short数据转化为网络上的short数据)端口号 
    server_addr.sin_addr=*((struct in_addr *)host->h_addr); // IP地址 
     
    /* 客户程序发起连接请求 */  
    if(connect(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==-1)  
    {  
        fprintf(stderr,"Connect Error:%s\a\n",strerror(errno));  
        exit(1);  
    }  
 
    /* 连接成功了 */  
    printf("Please input char:\n"); 
     
    /* 发送数据 */ 
    fgets(buffer,1024,stdin);  
    write(sockfd,buffer,strlen(buffer));  
 
    /* 结束通讯 */  
    close(sockfd);  
    exit(0);  
}  

（2）UDP程序设计

服务器端udp_server.c

 

 
 
#include <stdlib.h> 
#include <stdio.h> 
#include <errno.h> 
#include <string.h> 
#include <unistd.h> 
#include <netdb.h> 
#include <sys/socket.h> 
#include <netinet/in.h> 
#include <sys/types.h> 
#include <arpa/inet.h> 
 
#define SERVER_PORT 8888  
#define MAX_MSG_SIZE 1024  
 
void udps_respon(int sockfd)  
{  
    struct sockaddr_in addr;  
    int addrlen,n;  
    char msg[MAX_MSG_SIZE];  
 
    while(1)  
    {   /* 从网络上读,并写到网络上 */  
        bzero(msg,sizeof(msg)); // 初始化,清零 
        addrlen = sizeof(struct sockaddr);  
        n=recvfrom(sockfd,msg,MAX_MSG_SIZE,0,(struct sockaddr*)&addr,&addrlen); // 从客户端接收消息 
        msg[n]=0;  
        /* 显示服务端已经收到了信息 */  
        fprintf(stdout,"Server have received %s",msg); // 显示消息 
    }  
}  
 
int main(void)  
{  
    int sockfd;  
    struct sockaddr_in addr;  
 
    /* 服务器端开始建立socket描述符 */  
    sockfd=socket(AF_INET,SOCK_DGRAM,0);  
    if(sockfd<0)  
    {  
        fprintf(stderr,"Socket Error:%s\n",strerror(errno));  
        exit(1);  
    }  
 
    /* 服务器端填充 sockaddr结构 */  
    bzero(&addr,sizeof(struct sockaddr_in));  
    addr.sin_family=AF_INET;  
    addr.sin_addr.s_addr=htonl(INADDR_ANY);  
    addr.sin_port=htons(SERVER_PORT);  
 
    /* 捆绑sockfd描述符 */  
    if(bind(sockfd,(struct sockaddr *)&addr,sizeof(struct sockaddr_in))<0)  
    {  
        fprintf(stderr,"Bind Error:%s\n",strerror(errno));  
        exit(1);  
    }  
 
    udps_respon(sockfd); // 进行读写操作 
    close(sockfd);  
}  

客户端udp_client.c

 

 
 
#include <stdlib.h> 
#include <stdio.h> 
#include <errno.h> 
#include <string.h> 
#include <unistd.h> 
#include <netdb.h> 
#include <sys/socket.h> 
#include <netinet/in.h> 
#include <sys/types.h> 
#include <arpa/inet.h> 
 
#define SERVER_PORT 8888  
#define MAX_BUF_SIZE 1024  
 
void udpc_requ(int sockfd,const struct sockaddr_in *addr,int len)  
{  
    char buffer[MAX_BUF_SIZE];  
    int n;  
    while(1)  
    {   /* 从键盘读入,写到服务端 */  
        printf("Please input char:\n"); 
        fgets(buffer,MAX_BUF_SIZE,stdin);  
        sendto(sockfd,buffer,strlen(buffer),0,addr,len);  
        bzero(buffer,MAX_BUF_SIZE);  
    }  
}  
 
int main(int argc,char **argv)  
{  
    int sockfd;  
    struct sockaddr_in addr;  
 
    if(argc!=2)  
    {  
        fprintf(stderr,"Usage:%s server_ip\n",argv[0]);  
        exit(1);  
    } 
 
    /* 建立 sockfd描述符 */  
    sockfd=socket(AF_INET,SOCK_DGRAM,0);  
    if(sockfd<0)  
    {  
        fprintf(stderr,"Socket Error:%s\n",strerror(errno));  
        exit(1);  
    }  
 
    /* 填充服务端的资料 */  
    bzero(&addr,sizeof(struct sockaddr_in));  
    addr.sin_family=AF_INET;  
    addr.sin_port=htons(SERVER_PORT); 
    if(inet_aton(argv[1],&addr.sin_addr)<0)  /*inet_aton函数用于把字符串型的IP地址转化成网络2进制数字*/  
    {  
        fprintf(stderr,"Ip error:%s\n",strerror(errno));  
        exit(1);  
    }  
 
    udpc_requ(sockfd,&addr,sizeof(struct sockaddr_in)); // 进行读写操作 
    close(sockfd);  
}  

（3）并发服务器设计（TCP需建立连接，故为循环服务器，可通过创建一个子进程fork（）来实现；UDP可并发）

服务器端tcp_server_fork.c，客户端同上

 
 
#include <stdlib.h>  
#include <stdio.h>  
#include <errno.h>  
#include <string.h>  
#include <netdb.h>  
#include <sys/types.h>  
#include <netinet/in.h>  
#include <sys/socket.h>  
 
#define MY_PORT 3333 
 
 
 
int main(int argc ,char **argv) 
 
{ 
 
 int listen_fd,accept_fd; 
 
 struct sockaddr_in     client_addr; 
 
 int n; 
 
  
 
 if((listen_fd=socket(AF_INET,SOCK_STREAM,0))<0) 
 
  { 
 
        printf("Socket Error:%s\n\a",strerror(errno)); 
 
        exit(1); 
 
  } 
 
  
 
 bzero(&client_addr,sizeof(struct sockaddr_in)); 
 
 client_addr.sin_family=AF_INET; 
 
 client_addr.sin_port=htons(MY_PORT); 
 
 client_addr.sin_addr.s_addr=htonl(INADDR_ANY); 
 
 n=1; 
 
 /* 如果服务器终止后,服务器可以第二次快速启动而不用等待一段时间  */ 
 
 setsockopt(listen_fd,SOL_SOCKET,SO_REUSEADDR,&n,sizeof(int)); 
 
 if(bind(listen_fd,(struct sockaddr *)&client_addr,sizeof(client_addr))<0) 
 
  { 
 
        printf("Bind Error:%s\n\a",strerror(errno)); 
 
        exit(1); 
 
  } 
 
  listen(listen_fd,5); 
 
  while(1) 
 
  { 
 
   accept_fd=accept(listen_fd,NULL,NULL); 
 
   if((accept_fd<0)&&(errno==EINTR)) 
 
          continue; 
 
   else if(accept_fd<0) 
 
    { 
 
        printf("Accept Error:%s\n\a",strerror(errno)); 
 
        continue; 
 
    } 
 
  if((n=fork())==0) 
 
   { 
 
        /* 子进程处理客户端的连接 */ 
 
        char buffer[1024]; 
 
 
 
        close(listen_fd); 
 
        n=read(accept_fd,buffer,1024); 
 
        write(accept_fd,buffer,n); 
 
        close(accept_fd); 
 
        exit(0); 
 
   } 
 
   else if(n<0) 
 
        printf("Fork Error:%s\n\a",strerror(errno)); 
 
   close(accept_fd); 
 
  } 
 
}  

 

本文出自 “Mr~钟” 博客，请务必保留此出处http://6386296.blog.51cto.com/6376296/1121626