一、socket通信原理简述
socket是 一种特殊的IO,完成的是网络中的两个主机上的两个特定进程的通信,我们暂且忽略协议栈和具体的网络传输过程,其原理简单地说就是主机A的x号进程将要通信的数据通过网络发送给主机B上的y号进程,而我们知道在网络中用IP地址可以标识一台主机,在一个机器上,用一个序号(将用以通信的进程序号称为端口号)就可以标识一个进程,所以套接字就由IP+端口号组成,这就是socket通信的原理。
二、基本函数
1、socket函数
int socket(int domain, int type, int protocol);
功能说明:
调用成功,返回socket文件描述符;失败,返回-1,并设置errno
参数说明:
domain指明所使用的协议族,通常为PF_INET,表示TCP/IP协议;
type参数指定socket的类型,基本上有三种:数据流套接字、数据报套接字、原始套接字
protocol通常赋值”0”。
两个网络程序之间的一个网络连接包括五种信息:通信协议、本地协议地址、本地主机端口、远端主机地址和远端协议端口。socket数据结构中包含这五种信息。
2、bind函数
int bind(int sock_fd,struct sockaddr_in *my_addr, int addrlen);
功能说明:
将套接字和指定的端口相连。成功返回0,否则,返回-1,并置errno.
参数说明:
sock_fd是调用socket函数返回值,
my_addr是一个指向包含有本机IP地址及端口号等信息的sockaddr类型的指针;
struct sockaddr_in结构类型是用来保存socket信息的:
struct sockaddr_in {
short int sin_family;
unsigned short int sin_port;
struct in_addr sin_addr;
unsigned char sin_zero[8];
};
addrlen为sockaddr的长度。
3、connect函数
int connect(int sock_fd, struct sockaddr *serv_addr,int addrlen);
功能说明:
客户端发送服务请求。成功返回0,否则返回-1,并置errno。
参数说明:
sock_fd 是socket函数返回的socket描述符;
saddrlen是结构sockaddr_in的长度。
4、listen函数
int listen(int sock_fd, int backlog);
功能说明:
等待指定的端口的出现客户端连接。调用成功返回0,否则,返回-1,并置errno.
参数说明:
sock_fd 是socket()函数返回值;
backlog指定在请求队列中允许的最大请求数
5、accecpt函数
int accept(int sock_fd, struct sockadd_in* addr, int addrlen);
功能说明:
用于接受客户端的服务请求,成功返回新的套接字描述符,失败返回-1,并置errno。
参数说明:
sock_fd是被监听的socket描述符,
addr通常是一个指向sockaddr_in变量的指针,
addrlen是结构sockaddr_in的长度。
6、write函数
ssize_t write(int fd,const void *buf,size_t nbytes)
功能说明:
write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节数.失败时返回-1. 并设置errno变量.
在网络程序中,当我们向套接字文件描述符写时有俩种可能:
1)write的返回值大于0,表示写了部分或者是全部的数据.
2)返回的值小于0,此时出现了错误.需要根据错误类型来处理.
如果错误为EINTR表示在写的时候出现了中断错误.
如果错误为EPIPE表示网络连接出现了问题.
7、read函数
ssize_t read(int fd,void *buf,size_t nbyte)
函数说明:
read函数是负责从fd中读取内容.当读成功时,read返回实际所读的字节数,如果返回的值是0 表示已经读到文件的结束了,也就是说对端关闭了连接,小于0表示出现了错误.
如果错误为EINTR说明读是由中断引起的,
如果错误是ECONNREST表示网络连接出了问题.
8、close函数
int close(sock_fd);
说明:
当所有的数据操作结束以后,你可以调用close()函数来释放该socket,从而停止在该socket上的任何数据操作,函数运行成功返回0,否则返回-1
三、基本流程
四、实例
server端:
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
static void Usage(const char* msg)
{
printf("Usage:%s [local_ip] [local_prot]",msg);
}
int startup(const char* _ip,int _port)
{
int sock=socket(AF_INET,SOCK_STREAM,0);
if(sock<0){
perror("socket");
exit(2);
}
printf("sockt_fd: %d\n",sock);
struct sockaddr_in local;
local.sin_family=AF_INET;
local.sin_port=htons(_port);
local.sin_addr.s_addr=inet_addr(_ip);
if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0){
perror("bind");
exit(3);
}
if(listen(sock,10)<0){
perror("listen");
exit(4);
}
return sock;
}
void*request(void* arg)
{
int new_sock=(int)arg;
char buf[1024];
while(1){
ssize_t s=read(new_sock,buf,sizeof(buf)-1);
if(s>0){
buf[s]=0;
printf("client echo## ");
write(new_sock,buf,strlen(buf));
}else if(s==0){
printf("client quit");
break;
}else{
perror("read");
return 5;
}
}
close(new_sock);
return (void*)0;
}
int main(int argc,char* argv[])
{
if(argc!=3){
Usage(argv[0]);
}
int listen_sock=startup(argv[1],atoi(argv[2]));
printf("listen_sock:%d\n",listen_sock);
while(1){
struct sockaddr_in client;
socklen_t len=sizeof(client);
int new_sock=accept(listen_sock,(struct sockaddr*)&client,&len);
if(new_sock<0){
perror("accept");
continue;
}
printf("get a client:[%s:%d]\n",\
inet_ntoa(client.sin_addr),\
ntohs(client.sin_port));
// 线程实现版本
// pthread_t id;
// pthread_creat(&id,NULL,requst,(void*)new_sock);
// pthread_detach(id);
// 进程实现版本
pid_t id=fork();
if(id<0){
perror("fork");
exit(5);
}else if(id==0){
if(fork() > 0){
exit(6);
}
char buf[1024];
while(1){
ssize_t s=read(new_sock,buf,sizeof(buf)-1);
if(s>0){
buf[s]=0;
printf("client echo## ");
write(new_sock,buf,strlen(buf));
}else if(s==0){
printf("client quit");
break;
}else{
perror("read");
return 5;
}
}
}else{
close(new_sock);
waitpid(id,NULL,0);
}
}
return 0;
}
三种服务器模型分析:
- 单进程服务器
一个进程只服务一个客户端的请求,并发性太低,但是绝对稳定。 - 多进程服务器
每个进程单独处理一个客户端请求,并发性高,但是每个机器能创建的进程数是有限的, 而且进程的创建、执行、切换对撤销系统开销较大,如果进程较多则会造成饥饿现象,使得有的客户端请求不能被处理。 - 多线程服务器
每一个线程单独处理一个客户端的请求,而且线程的创建、执行、切换对撤销系统开销小,这种模型是理想的方式。
client端:
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <string.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
static void Usage(const char* msg)
{
printf("Usage:%s [server_ip] [server_prot]",msg);
}
int main(int argc,char* argv[])
{
if(argc!=3){
Usage(argv[0]);
}
int sock=socket(AF_INET,SOCK_STREAM,0);
if(sock<0){
perror("sock");
return 2;
}
struct sockaddr_in server;
server.sin_family=AF_INET;
server.sin_port=htons(atoi(argv[2]));
server.sin_addr.s_addr=inet_addr(argv[1]);
socklen_t len=sizeof(server);
if(connect(sock,(struct sockaddr*)&server,len)<0){
perror("connect");
return 3;
}
char buf[1024];
while(1){
printf("Please enter## ");
fflush(stdout);
ssize_t s=read(0,buf,sizeof(buf)-1);
if(s<0){
perror("read");
return 4;
}else{
buf[s-1]=0;
write(sock,buf,strlen(buf));
ssize_t _s=read(sock,buf,sizeof(buf)-1);
if(_s<0){
perror("read");
return 6;
}else if(_s==0){
printf("server quit!\n");
break;
}else if(_s>0){
buf[_s]=0;
printf("Server say## %s\n",buf);
}
}
}
close(sock);
return 0;
}