c语言实现简单的hello/hi聊天程序
c语言实现简单的hello/hi程序
使用tcp协议来实现来实现
实现效果
实现过程
对于服务器端：
1.定义sockadr_in结构体
struct sockaddr_in add={
.sin_family=AF_INET,
.sin_port=htons(8000),
.sin_addr.s_addr=htonl(INADDR_ANY),
};
2.初始化：
sin_family表示协议簇,一般用AF_INET表示TCP/IP协议
sin_port端口为8000
sin_addr将本地所有的ip都绑定到地址
3.通过soket获取文件标识符sock_fd=socket(PF_INET,SOCK_STREAM,0)
4.将sockaddr_in结构体与sock_fd标识符绑定
bind(sock_fd,(struct sockaddr*)&add,sizeof(struct sockaddr)
5.监听端口，如果有链接就能响应
ret=listen(sock_fd,MAX_QUEUE_SIZE))
接收请求，同时获取请求方的套接字，通过这个套接字能进行数据的收发
accept(sock_fd,(struct sockaddr*)&addNew,&sin_size)
对于客户端
1.初始化套接字
struct sockaddr_in server;
memset(&server,0,sizeof(struct sockaddr_in ));
server.sin_family = AF_INET;
server.sin_port =8000;
server.sin_addr.s_addr = inet_addr("127.0.0.1");
与服务端的套接字不同，这里初始化的套接字表示服务端的套接字，即客户端要向谁请求服务，就应该将套接字初始化为对应的服务端。
这里定义端口为8000，因为服务端的端口设置为8000，ip地址为127.0.0.1，即回环地址，因为实验在一台主机上完成，服务端也布置在本主机，所以请求服务时的目的地址就是本机的地址。
2.获取文件描述符
sockfd = socket( AF_INET, SOCK_STREAM,0)
通过socket接口，定义服务类型为TCP服务，返回文件描述符，有了文件描述符与套接字，我们就能请求服务了。
3.连接服务端
connect( sockfd,(struct sockaddr*)&server,sizeof( server ))
connet函数传递了三个参数：文件描述符，服务端的套接字结构体，套接字的大小，这个函数会根据套接字尝试服务端。如果服务端此时已经执行过了listen，那么服务端就能相应这个请求，并进行三次握手，从此，服务端于客户端的连接就建立完成了。
4.发送与接收消息
send(client_sockfd,buf,len,0)
recv(client_sockfd,buf,BUFSIZ,0);
对于发送消息与接收消息，服务端与客户端没有区别，其实对于接收和发送消息，read与write操作也能实现。
由于已经建立了连接，所以发送和接收时并不需要目标机的套接字，只需要传递需要发送的数据或者接收数据的缓冲区，自己的文件描述符即可!
代码实现
客户端
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define MAX_len 1024
int sock_fd;
struct sockaddr_in add;
int main()
{
int ret;
char buf[MAX_len]={0};
char buf_rec[MAX_len]={0};
char buf_p[5]={"0"};
memset(&add,0,sizeof(add));
add.sin_family=AF_INET;
add.sin_port=htons(8000);
add.sin_addr.s_addr=inet_addr("127.0.0.1");
if((sock_fd=socket(PF_INET,SOCK_STREAM,0))<=0)
{
perror("socket");
return 1;
}
if((ret=connect(sock_fd,(struct sockaddr*)& add,sizeof(struct sockaddr)))<0)
{
perror("connet");
return 1;
}
if((ret=send(sock_fd,(void*)buf_p,strlen(buf),0))<0)
{
perror("recvfrom");
return 1;
}
while (1)
{
scanf("%s",buf);
if((ret=send(sock_fd,(void*)buf,sizeof(buf),0))<0)
{
perror("sendfrom1");
return 1;
}
if((ret=recv(sock_fd,(void*)buf_rec,sizeof(buf_rec),0))<0)
{
perror("recvfrom1");
return 1;
}
printf("%s\n",buf_rec);
}
return 0;
}
服务端
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#define MAX_len 1024
#define MAX_QUEUE_SIZE 10
#define MAX_CON 10
void dealData(int cilient)
{
char buf[1024];
char buf_p[5]={"hi"};
int des_fd,len=0;
while( 1 ) {
memset(buf,0,sizeof(buf));
len=recv(cilient,(void*)buf,sizeof(buf),0);
send(cilient,buf_p,strlen(buf_p),0);
}
}
int main()
{
int len=0;
int sock_fd_work;
int cilient;
int sin_size=sizeof(struct sockaddr_in);
int sock_fd;
char buf_p[5];
char buf[100];
int ret,current=-1,des;
struct sockaddr_in addNew;
struct sockaddr_in add
={
.sin_family=AF_INET,
.sin_port=htons(8000),
.sin_addr.s_addr=htonl(INADDR_ANY),
};
if((sock_fd=socket(PF_INET,SOCK_STREAM,0))<0)
{
perror("socket");
return 1;
}
if((ret=bind(sock_fd,(struct sockaddr*)&add,sizeof(struct sockaddr)))<0)
{
perror("bind");
return 1;
}
if((ret=listen(sock_fd,MAX_QUEUE_SIZE))<0)
{
perror("listen");
return 1;
}
while(1)
{
if((sock_fd_work=accept(sock_fd,(struct sockaddr*)&addNew,&sin_size))>0)
if(!fork())
{
dealData(sock_fd_work);
exit(0);
}
}
close(sock_fd_work);
return 0; /* code */
}
实现原理
跟踪分析
在linux中，socket也被看做是文件，也正是因为如此，对文件的read和write操作也能对socket使用，进一步来讲，内核实现socket与实现其他文件系统基本类似，也就是说，socket也是一个文件系统。
作为一个linux下的文件系统，我们关注的数据结构有：
超级块
struct super_block {
...
struct file_system_type *s_type;
struct super_operations *s_op;
...
}
显然，file_system_type为文件系统的类型，socket文件系统对应的内容为
static struct file_system_type sock_fs_type ={
.name ="sockfs",// 文件系统名称
.mount = sockfs_mount,// 挂载sockfs函数，其中会创建super block
.kill_sb = kill_anon_super,// 销毁super block函数
};
里面的内容其实很少，名称、挂载操作，还有销毁操作。
那么struct super_operations呢? 这里面保存了一些文件系统在创建或删除文件时会用到的操作
static const struct super_operations sockfs_ops ={
.alloc_inode = sock_alloc_inode,// 分配inode
.destroy_inode = sock_destroy_inode,// 释放inode
.statfs = simple_statfs,// 用于获取sockfs文件系统的状态信息
};
由于linux将socket也当作一个文件对待，那么在新建一个连接（执行socket())时，应该也会创建一个文件才对，一个磁盘文件对应了一个inode，也就是每执行一次socket，都会执行sock_alloc_inode操作，然后创建一个inode，然后创建一个file文件，将file文件指向那个inode，然后返回文件描述符。
验证
若执行socket(PF_INET,SOCK_STREAM,0)，就会执行系统调用 sys_socketcall，实际上就是SYSCALL_DEFINE2
SYSCALL_DEFINE2(socketcall,int, call,unsignedlong __user *, args)
{
switch(call){
case SYS_SOCKET:
// 与 socket(int domain, int type, int protocol) 对应，创建socket
err = sys_socket(a0, a1, a[2]);
break;
case SYS_BIND:
err = sys_bind(a0,(struct sockaddr __user *)a1, a[2]);
break;
case SYS_CONNECT:
err = sys_connect(a0,(struct sockaddr __user *)a1, a[2]);
break;
}
从这里的代码可以看到，sys_socketcall是几乎所有socket操作的入口（socket、bind、connect、listen），每次执行都会根据系统调用号SYS_SOCKET来判断用户程序的请求，进而执行对应的系统调用：sys_socket、sys_bind、sys_connet。
sys_socket：内核将sys_socket重定位为SYSCALL_DEFINE3
SYSCALL_DEFINE3(socket,int, family,int, type,int, protocol)
{
...
retval = sock_create(family, type, protocol,&sock);
....
retval = sock_map_fd(sock, flags &(O_CLOEXEC | O_NONBLOCK));
}
对于sock_create内核会分配一个socket结构体，结构体内包括socket的操作，等待队列（监听会用到）等
struct socket {
socket_state state;// 连接状态：SS_CONNECTING, SS_CONNECTED 等
short type;// 类型：SOCK_STREAM, SOCK_DGRAM 等
unsignedlong flags;// 标志位：SOCK_ASYNC_NOSPACE(发送队列是否已满)等
struct socket_wq __rcu *wq;// 等待队列
struct file *file;// 该socket结构体对应VFS中的file指针
struct sock *sk;// socket网络层表示，真正处理网络协议的地方
conststruct proto_ops *ops;// socket操作函数集：bind, connect, accept 等
};
sock_create的内容：
int __sock_create(struct net *net,int family,int type,int protocol,
struct socket **res,int kern)
{
...
err = security_socket_create(family, type, protocol, kern);
sock = sock_alloc();
...
}
security_socket_create函数主要是是判断了传递的参数是否合法，在用户态创建还是内核空间创建，它的实现如下：
static struct socket *sock_alloc(void)
{
struct inode *inode;
struct socket *sock;
inode = new_inode_pseudo(sock_mnt->mnt_sb);
sock = SOCKET_I(inode);
....
}
new_inode_pseudo调用了socket文件系统的分配节点操作alloc_inode，最终实现了socket节点的创建
static struct inode *alloc_inode(struct super_block *sb)
{
if(sb->s_op->alloc_inode)
inode = sb->s_op->alloc_inode(sb);
...
}
这里的sb就是socket的超级块，调用的alloc_inode，正是在初始化文件系统时赋值给超级块sockfs_ops
域的函数指针，这也部分验证了我们的猜想，那打开的文件呢？显然就是由系统调用中sock_map_fd来完成。
对于sock_map_fd，内核会创建一个文件，并将socket与文件绑定起来，同时会分配文件描述符，也就是socket的返回值，通过文件描述符，既能将socket看着文件来对待，又能执行socket特有的函数。
staticint sock_map_fd(struct socket *sock,int flags)
{
struct file *newfile;
// 从本进程的文件描述符表中获取一个可用的文件描述符
int fd = get_unused_fd_flags(flags);、
// 创建一个新的file，并将file和inode以及socket关联
newfile = sock_alloc_file(sock, flags, NULL);
}
这一步通过get_unused_fd_flags得到了文件描述符，sock_alloc_file负责创建对应的文件
struct file *sock_alloc_file(struct socket *sock,int
flags,constchar*dname)
{
struct file *file;
file = alloc_file(&path, FMODE_READ | FMODE_WRITE, &socket_file_ops);
file->private_data = sock;
}
清晰的看到，文件被创建、得到文件指针、将socket文件操作赋值给file、将scket结构体sock赋值到file->private——data。这一步完成，我们就能将socket看做一个文件了。
验证完毕
参考：https://blog.csdn.net/qq_14978113/article/details/80738787
