TCP循环服务器 UDP循环服务器 TCP并发服务器

1.编写使用TCP协议的服务器程序

2.编写使用TCP协议的客户端程序

3.客户端向服务器发送字符串，服务器打印收到的字符串

服务器

hw1server.c

#include <sys/socket.h>

#include <stdio.h>

#include <netdb.h>

#include <errno.h>

#include <string.h>

#include <stdlib.h>

#include <netinet/in.h>

#include <sys/types.h>

#define portnum 3456

int main(int argc,char *argv[])

{

int s_fd,c_fd;

char buffer[1024];

struct sockaddr_in server_addr;//服务器ip地址

struct sockaddr_in client_addr;//客户端ip地址

int nbytes;

int cli_size;

/*

struct sockaddr_in

{

short int sin_family; //ip地址族

unsigned short int sin_port; //端口号

struct in_addr sin_addr; //ip地址

unsigned char sin_zero[8]; //填0

}

*/

/*

struct in_addr

{

unsigned long s_addr;

}

*/

s_fd=socket(AF_INET,SOCK_STREAM,0);

//地址描述，套接口类型，套接口所用的协议

if(s_fd==-1)

{

fprintf(stderr,"Socket error:%s\n\a",strerror(errno));

exit(1);

}

printf("socket() return value:%d\n",s_fd);

//服务器填充sockaddr结构

bzero(&server_addr,sizeof(struct sockaddr_in));//初始化，置0

server_addr.sin_family=AF_INET; //Internet

//(将本机器上的long数据转化为网络上的long数据)和任何主机通信

//INADDR_ANY表示额可以接收任意IP地址的数据

server_addr.sin_addr.s_addr=htonl(INADDR_ANY);

server_addr.sin_port=htons(portnum);

bzero(&(server_addr.sin_zero),8);

int b;

b=bind(s_fd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr));

//未捆绑套接口的描述字，赋予套接口的地址，地址的长度

if(b==-1)

{

fprintf(stderr,"Bind error:%s\n\a",strerror(errno));

exit(1);

}

printf("bind() return value:%d\n",b);

//设置允许连接的最大客户端数

int c;

c=listen(s_fd,5);//最大监听数是5

if(c==-1)

{

fprintf(stderr,"Listen error:%s\n\a",strerror(errno));

exit(1);

}

printf("listen() return value:%d\n",c);

//TCP循环服务器

while(1)

{

cli_size=sizeof(struct sockaddr_in); //获取ip地址结构的大小

if((c_fd=accept(s_fd,(struct sockaddr *)&client_addr,&cli_size))==-1)

{

fprintf(stderr,"Accept error:%s\n\a",strerror(errno));

exit(1);

}

//套接口的描述字，客户端的ip地址，地址长度

printf("accept() return value:%d\n",c_fd);

//将网络地址转换成可读的ip地址

fprintf(stderr,"Server get connection from %s\n",inet_ntoa(client_addr.sin_addr));

//接收从客户端发送来的数据,返回读取的字节数

//if(!fork())

//{

if((nbytes=read(c_fd,buffer,1024))==-1)

{

fprintf(stderr,"Read Error:%s\n",strerror(errno));

exit(1);

}

buffer[nbytes]='\0'; //给数据结束标志

//输出从客户端读取的数据

printf("Server received %s\n",buffer);

//process();

close(c_fd);

exit(0);

//}

}

// close(c_fd);//关闭客户端的文件描述符

// close(s_fd);

close(s_fd);

exit(0);

}

客户端

hw1client.c

#include "stdio.h"

#include <sys/socket.h>

#include <netdb.h>

#include <string.h>

#include <netinet/in.h>

#include <stdlib.h>

#include <errno.h>

#include <sys/types.h>

#define portnum 3456

int main(int argc,char *argv[])

{

struct sockaddr_in server_addr;

int c_fd;

char buffer[1024];

struct hostent *host;

if(argc != 2)

{

fprintf(stderr,"Gethostname error\n");

exit(1);

}

if((host=gethostbyname(argv[1])) == NULL)

{

fprintf(stderr,"Gethostname error\n");

exit(1);

}

c_fd=socket(AF_INET,SOCK_STREAM,0);

if(c_fd == -1)

{

fprintf(stderr,"Socket Error:%s\a\n",strerror(errno));

}

printf("socket() return value:%d\n",c_fd);

//客户端sockaddr结构

bzero(&server_addr,sizeof(struct sockaddr_in));//初始化，置0

server_addr.sin_family=AF_INET; //Internet

server_addr.sin_port=htons(portnum);

//server_addr.sin_addr=*((struct in_addr *)host.h_addr);//指向主机的第一个ip地址

int a;

a=connect(c_fd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr_in));

if(a==-1)

{

fprintf(stderr,"Connect Error:%s\a\n",strerror(errno));

exit(1);

}

printf("connect() return value:%d\n",a);

//从标准输入获取buffer大小的数据放入buffer中

fgets(buffer,sizeof(buffer),stdin);

write(c_fd,buffer,sizeof(buffer));//向服务器写数据

close(c_fd);

return 0;

}

实验要求：

1.编写使用UDP协议的服务器程序

2.编写使用UDP协议的客户端程序

3.客户端向服务器发送字符串，服务器打印收到的字符串

服务器：

hw2server.c

#include <stdio.h>

#include <netdb.h>

#include <sys/socket.h>

#include <errno.h>

#include <sys/types.h>

#include <string.h>

#include <netinet/in.h>

#include <stdlib.h>

#include <unistd.h>

#include <arpa/inet.h>

#define SERVER_PORT 3344

#define MAX_BUFFER_SIZE 1024

int main(int argc,char *argv)

{

struct sockaddr_in server_addr;

struct sockaddr_in client_addr;

int server_fd;

int addr_size;

int nbytes;

char buffer[1024];

server_fd = socket(AF_INET,SOCK_DGRAM,0);

if(server_fd < 0)

{

fprintf(stderr,"create socket error:%s\n",strerror(errno));

exit(1);

}

bzero(&server_addr,sizeof(struct sockaddr_in));

server_addr.sin_family = AF_INET;

server_addr.sin_port = htons(SERVER_PORT);

server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

if(bind(server_fd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr_in)) < 0)

{

fprintf(stderr,"bind error:%s\n",strerror(errno));

exit(1);

}

while(1)

{

bzero(buffer,sizeof(buffer));

addr_size = sizeof(struct sockaddr);

nbytes = recvfrom(server_fd,buffer,MAX_BUFFER_SIZE,0,(struct sockaddr*)&client_addr,&addr_size);

buffer[nbytes] = 0;

fprintf(stdout,"server have received:%s\n",buffer);

}

close(server_fd);

return 0;

}

客户端：

hw2client.c

#include <stdio.h>

#include <netdb.h>

#include <sys/socket.h>

#include <errno.h>

#include <sys/types.h>

#include <string.h>

#include <netinet/in.h>

#include <stdlib.h>

#include <arpa/inet.h>

#include <unistd.h>

#define portnumber 3344

#define MAX_BUFFER_SIZE 1024

int main(int argc,char **argv)

{

struct sockaddr_in addr;

int sockfd;

int nbytes;

char buffer[MAX_BUFFER_SIZE];

if(argc != 2)

{

fprintf(stderr,"Usage:%s server_ip\n",argv[0]);

exit(1);

}

sockfd = socket(AF_INET,SOCK_DGRAM,0);

if(sockfd<0)

{

fprintf(stderr,"create socket error:%s\n",strerror(errno));

exit(1);

}

bzero(&addr,sizeof(struct sockaddr_in));

addr.sin_family = AF_INET;

addr.sin_port = htons(portnumber);

int n;

if(n=inet_aton(argv[1],&addr.sin_addr)<0);

{

fprintf(stderr,"ip change error:%s\n",strerror(errno));

printf("鎴戞槸 %d\n",n);

//exit(1);

}

//printf("n = %d \n",n);

/*if(bind(client_fd,(struct sockaddr *)(&addr),sizeof(addr)) == -1)

{

fprintf(stderr,"bind error:%s\n",strerror(errno));

exit(1);

}*/

while(1)

{

fgets(buffer,MAX_BUFFER_SIZE,stdin);

sendto(sockfd,buffer,MAX_BUFFER_SIZE,0,(struct sockaddr *)(&addr),sizeof(struct sockaddr_in));

bzero(buffer,MAX_BUFFER_SIZE);

}

close(sockfd);

return 0;

}

1.实现基于TCP协议的并发服务器

2.比较并发服务器与循环服务器的区别

服务器：

hw3server.c

#include <sys/socket.h>

#include <stdio.h>

#include <netdb.h>

#include <errno.h>

#include <string.h>

#include <stdlib.h>

#include <netinet/in.h>

#include <sys/types.h>

#define portnum 3456

int main(int argc,char *argv[])

{

int s_fd,c_fd;

char buffer[1024];

struct sockaddr_in server_addr;//服务器ip地址

struct sockaddr_in client_addr;//客户端ip地址

int nbytes;

int cli_size;

/*

struct sockaddr_in

{

short int sin_family; //ip地址族

unsigned short int sin_port; //端口号

struct in_addr sin_addr; //ip地址

unsigned char sin_zero[8]; //填0

}

*/

/*

struct in_addr

{

unsigned long s_addr;

}

*/

s_fd=socket(AF_INET,SOCK_STREAM,0);

//地址描述，套接口类型，套接口所用的协议

if(s_fd==-1)

{

fprintf(stderr,"Socket error:%s\n\a",strerror(errno));

exit(1);

}

printf("socket() return value:%d\n",s_fd);

//服务器填充sockaddr结构

bzero(&server_addr,sizeof(struct sockaddr_in));//初始化，置0

server_addr.sin_family=AF_INET; //Internet

//(将本机器上的long数据转化为网络上的long数据)和任何主机通信

//INADDR_ANY表示额可以接收任意IP地址的数据

server_addr.sin_addr.s_addr=htonl(INADDR_ANY);

server_addr.sin_port=htons(portnum);

bzero(&(server_addr.sin_zero),8);

int b;

b=bind(s_fd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr));

//未捆绑套接口的描述字，赋予套接口的地址，地址的长度

if(b==-1)

{

fprintf(stderr,"Bind error:%s\n\a",strerror(errno));

exit(1);

}

printf("bind() return value:%d\n",b);

//设置允许连接的最大客户端数

int c;

c=listen(s_fd,5);//最大监听数是5

if(c==-1)

{

fprintf(stderr,"Listen error:%s\n\a",strerror(errno));

exit(1);

}

printf("listen() return value:%d\n",c);

//TCP循环服务器

while(1)

{

cli_size=sizeof(struct sockaddr_in); //获取ip地址结构的大小

if((c_fd=accept(s_fd,(struct sockaddr *)&client_addr,&cli_size))==-1)

{

fprintf(stderr,"Accept error:%s\n\a",strerror(errno));

exit(1);

}

//套接口的描述字，客户端的ip地址，地址长度

printf("accept() return value:%d\n",c_fd);

//将网络地址转换成可读的ip地址

fprintf(stderr,"Server get connection from %s\n",inet_ntoa(client_addr.sin_addr));

//接收从客户端发送来的数据,返回读取的字节数

if(!fork())

{

if((nbytes=read(c_fd,buffer,1024))==-1)

{

fprintf(stderr,"Read Error:%s\n",strerror(errno));

exit(1);

}

buffer[nbytes]='\0'; //给数据结束标志

//输出从客户端读取的数据

printf("Server received %s\n",buffer);

//process();

close(c_fd);

exit(0);

}

}

// close(c_fd);//关闭客户端的文件描述符

// close(s_fd);

close(s_fd);

exit(0);

}

客户端：

hw3client.c

#include "stdio.h"

#include <sys/socket.h>

#include <netdb.h>

#include <string.h>

#include <netinet/in.h>

#include <stdlib.h>

#include <errno.h>

#include <sys/types.h>

#define portnum 3456

int main(int argc,char *argv[])

{

struct sockaddr_in server_addr;

int c_fd;

char buffer[1024];

struct hostent *host;

if(argc != 2)

{

fprintf(stderr,"Gethostname error\n");

exit(1);

}

if((host=gethostbyname(argv[1])) == NULL)

{

fprintf(stderr,"Gethostname error\n");

exit(1);

}

c_fd=socket(AF_INET,SOCK_STREAM,0);

if(c_fd == -1)

{

fprintf(stderr,"Socket Error:%s\a\n",strerror(errno));

}

printf("socket() return value:%d\n",c_fd);

//客户端sockaddr结构

bzero(&server_addr,sizeof(struct sockaddr_in));//初始化，置0

server_addr.sin_family=AF_INET; //Internet

server_addr.sin_port=htons(portnum);

//server_addr.sin_addr=*((struct in_addr *)host.h_addr);//指向主机的第一个ip地址

int a;

a=connect(c_fd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr_in));

if(a==-1)

{

fprintf(stderr,"Connect Error:%s\a\n",strerror(errno));

exit(1);

}

printf("connect() return value:%d\n",a);

//从标准输入获取buffer大小的数据放入buffer中

fgets(buffer,sizeof(buffer),stdin);

write(c_fd,buffer,sizeof(buffer));//向服务器写数据

close(c_fd);

return 0;

}

-------------------------------------------------------

并发服务器与循环服务器的区别：

·循环服务器：服务器在同一时刻只能响应一个客户端的请求

·并发服务器：服务器在同一时刻可以响应多个客户端的请求