网络子系统80_inet协议族-SOCK_RAW（一）

//	SOCK_RAW
1.1 static struct inet_protosw inetsw_array[] =
{
...
{
.type =       SOCK_RAW,
.protocol =   IPPROTO_IP,	/* 通配符 */
.prot =       &raw_prot,	/*	Networking protocol blocks attached to sockets	*/
.ops =        &inet_sockraw_ops,
.no_check =   UDP_CSUM_DEFAULT,
.flags =      INET_PROTOSW_REUSE,
}
...
}

//	struct socket->ops字段
//		向上的数据结构
2.1 static const struct proto_ops inet_sockraw_ops = {
.family		   = PF_INET,
.owner		   = THIS_MODULE,
.release	   = inet_release,
.bind		   = inet_bind,
.connect	   = inet_dgram_connect,
.socketpair	   = sock_no_socketpair,
.accept		   = sock_no_accept,
.getname	   = inet_getname,
.poll		   = datagram_poll,
.ioctl		   = inet_ioctl,
.listen		   = sock_no_listen,
.shutdown	   = inet_shutdown,
.setsockopt	   = sock_common_setsockopt,
.getsockopt	   = sock_common_getsockopt,
.sendmsg	   = inet_sendmsg,
.recvmsg	   = inet_recvmsg,
.mmap		   = sock_no_mmap,
.sendpage	   = inet_sendpage,
};

//	sock绑定地址
//		inet_sock->inet_rcv_saddr - Bound local ipv4 addr
//		inet_sock->inet_num - Local port
//	步骤：
//		1.安全性检查
//			1.1 地址长度是否足够
//			1.2 地址类型是否正确
//			1.3 端口是否已经被占用
//		2.设置inet_sock结构的源地址和源端口
3.1 int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
{
//inet使用sockaddr_in
struct sockaddr_in *addr = (struct sockaddr_in *)uaddr;
struct sock *sk = sock->sk;
//inet使用inet_sock
struct inet_sock *inet = inet_sk(sk);
struct net *net = sock_net(sk);
unsigned short snum;
int chk_addr_ret;
int err;

//调用sock提供的bind
if (sk->sk_prot->bind) {
err = sk->sk_prot->bind(sk, uaddr, addr_len);
goto out;
}
err = -EINVAL;
//地址长度
if (addr_len < sizeof(struct sockaddr_in))
goto out;

//兼容性检查
if (addr->sin_family != AF_INET) {
err = -EAFNOSUPPORT;
if (addr->sin_family != AF_UNSPEC ||
addr->sin_addr.s_addr != htonl(INADDR_ANY))
goto out;
}

//检查地址类型
chk_addr_ret = inet_addr_type(net, addr->sin_addr.s_addr);
err = -EADDRNOTAVAIL;
if (!sysctl_ip_nonlocal_bind &&
!(inet->freebind || inet->transparent) &&
addr->sin_addr.s_addr != htonl(INADDR_ANY) &&
chk_addr_ret != RTN_LOCAL &&
chk_addr_ret != RTN_MULTICAST &&
chk_addr_ret != RTN_BROADCAST)
goto out;

//端口号检查
snum = ntohs(addr->sin_port);
err = -EACCES;
if (snum && snum < PROT_SOCK &&
!ns_capable(net->user_ns, CAP_NET_BIND_SERVICE))
goto out;

lock_sock(sk);

err = -EINVAL;
//二次绑定
if (sk->sk_state != TCP_CLOSE || inet->inet_num)
goto out_release_sock;

//绑定地址
inet->inet_rcv_saddr = inet->inet_saddr = addr->sin_addr.s_addr;

//检查端口是否已经被绑定
if (sk->sk_prot->get_port(sk, snum)) {
inet->inet_saddr = inet->inet_rcv_saddr = 0;
err = -EADDRINUSE;
goto out_release_sock;
}

//绑定端口
inet->inet_sport = htons(inet->inet_num);
inet->inet_daddr = 0;
inet->inet_dport = 0;
sk_dst_reset(sk);
err = 0;
out_release_sock:
release_sock(sk);
out:
return err;
}

//	发送数据
//		统计流量，绑定端口，由prot完成数据发送
3.2 int inet_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
size_t size)
{
struct sock *sk = sock->sk;

//统计sock的流量
sock_rps_record_flow(sk);

//绑定port
if (!inet_sk(sk)->inet_num && !sk->sk_prot->no_autobind &&
inet_autobind(sk))
return -EAGAIN;

//通过prot->sendmsg发送数据
return sk->sk_prot->sendmsg(iocb, sk, msg, size);
}

//	接收数据
//		统计流量，由prot完成数据接收
3.3 int inet_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
size_t size, int flags)
{
struct sock *sk = sock->sk;
int addr_len = 0;
int err;

//统计sock流量
sock_rps_record_flow(sk);

//通过prot->recvmsg接收数据
err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
flags & ~MSG_DONTWAIT, &addr_len);
if (err >= 0)
msg->msg_namelen = addr_len;
return err;
}

//	建立连接
//	步骤：
//		1.常规检查
//			1.1 如果未绑定端口，先随机分配一个端口并绑定
//		2.由struct sock->sk_prot->connect建立连接
3.4 int inet_dgram_connect(struct socket *sock, struct sockaddr *uaddr,
int addr_len, int flags)
{
struct sock *sk = sock->sk;
//未绑定端口，先绑定
if (!inet_sk(sk)->inet_num && inet_autobind(sk))
return -EAGAIN;
return sk->sk_prot->connect(sk, uaddr, addr_len);
}

//	关闭sock
//	步骤：
//		1.如果struct sock正在连接建立的过程中(TCP_SYN_SENT)，调用disconnect关闭连接
//		2.否则，由shutdown关闭连接
//		3.通知sock的拥有者，sock状态发生了改变
3.5 int inet_shutdown(struct socket *sock, int how)
{
struct sock *sk = sock->sk;
int err = 0;

lock_sock(sk);
//SS_CONNECTING在TCP中使用
if (sock->state == SS_CONNECTING) {
if ((1 << sk->sk_state) &
(TCPF_SYN_SENT | TCPF_SYN_RECV | TCPF_CLOSE))
sock->state = SS_DISCONNECTING;
else
sock->state = SS_CONNECTED;
}

switch (sk->sk_state) {
case TCP_CLOSE:
err = -ENOTCONN;
//由具体的sock完成关闭
default:
sk->sk_shutdown |= how;
if (sk->sk_prot->shutdown)
sk->sk_prot->shutdown(sk, how);
break;

case TCP_SYN_SENT:
//已经发送了syn，则通过disconnect关闭连接
err = sk->sk_prot->disconnect(sk, O_NONBLOCK);
sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
break;
}

//通知sock的拥有者，sock状态改变
sk->sk_state_change(sk);
release_sock(sk);
return err;
}

//	通用的数据报poll调用
3.6 unsigned int datagram_poll(struct file *file, struct socket *sock,
poll_table *wait)
{
struct sock *sk = sock->sk;
unsigned int mask;

//在sock上等待数据
sock_poll_wait(file, sk_sleep(sk), wait);
mask = 0;

//有接收到的数据
if (!skb_queue_empty(&sk->sk_receive_queue))
mask |= POLLIN | POLLRDNORM;

//有可写内存
if (sock_writeable(sk))
mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
else
set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);

//返回标志结合，指示poll的结果
return mask;
}

//	发送page
//	步骤：
//		1. 检查是否分配了端口
//			1.1 如果没有分配，则内核为其选择一个端口
//		2. 如果sock提供了sendpage，则调用
//		3. 否则，映射page到msghdr结构，通过sk->sk_prot->sendmsg发送
//	注：
//		对于不支持sendpage的sock，填充page数据到msghdr
3.7 ssize_t inet_sendpage(struct socket *sock, struct page *page, int offset,
size_t size, int flags)
{
struct sock *sk = sock->sk;

sock_rps_record_flow(sk);

//没有指定端口号，内核随机选择一个端口
if (!inet_sk(sk)->inet_num && !sk->sk_prot->no_autobind &&
inet_autobind(sk))
return -EAGAIN;
//如果sock提供了sendpage，则调用
if (sk->sk_prot->sendpage)
return sk->sk_prot->sendpage(sk, page, offset, size, flags);
//否则将page映射到msghdr中
return sock_no_sendpage(sock, page, offset, size, flags);
}

//	映射page到核心地址空间，填充msghdr结构
3.8 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
{
ssize_t res;
struct msghdr msg = {.msg_flags = flags};
struct kvec iov;
//映射page结构到核心地址空间
char *kaddr = kmap(page);
iov.iov_base = kaddr + offset;
iov.iov_len = size;
//发送msghdr
res = kernel_sendmsg(sock, &msg, &iov, 1, size);
//解映射
kunmap(page);
return res;
}

//	发送msghdr
//	步骤：
//		1.初始化kiocb，用于sock的同步处理
//		2.通过sock->sk_prot->sendmsg发送msghdr
//		3.如果底层为异步发送，则等待数据发送完成
3.9 int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
{
struct kiocb iocb;
struct sock_iocb siocb;
int ret;
//初始化sock同步控制块
init_sync_kiocb(&iocb, NULL);
iocb.private = &siocb;
//通过sk->sk_prot->sendmsg发送msghdr
ret = __sock_sendmsg(&iocb, sock, msg, size);
//如果底层发送为异步，则等待发送的完成
if (-EIOCBQUEUED == ret)
ret = wait_on_sync_kiocb(&iocb);
return ret;
}