阅读528 返回首页    go 阿里云 go 技术社区[云栖]

网络子系统81_inet协议族-SOCK_RAW（二）

//	struct sock->sk_prot字段
//		struct proto为插口层到传输层的接口
4.1 struct proto raw_prot = {
	.name		   = "RAW",
	.owner		   = THIS_MODULE,
	.close		   = raw_close,
	.destroy	   = raw_destroy,
	.connect	   = ip4_datagram_connect,
	.disconnect	   = udp_disconnect,
	.ioctl		   = raw_ioctl,
	.init		   = raw_init,
	.setsockopt	   = raw_setsockopt,
	.getsockopt	   = raw_getsockopt,
	.sendmsg	   = raw_sendmsg,
	.recvmsg	   = raw_recvmsg,
	.bind		   = raw_bind,
	.backlog_rcv   = raw_rcv_skb,
	.release_cb	   = ip4_datagram_release_cb,
	.hash		   = raw_hash_sk,
	.unhash		   = raw_unhash_sk,
	.obj_size	   = sizeof(struct raw_sock),
	.h.raw_hash	   = &raw_v4_hashinfo,
};


//	raw sock绑定地址到socket
4.1 static int raw_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
{
	struct inet_sock *inet = inet_sk(sk);
	struct sockaddr_in *addr = (struct sockaddr_in *) uaddr;
	int ret = -EINVAL;
	int chk_addr_ret;

	//sk->sk_state!=TCP_CLOSE说明连接已经建立
	if (sk->sk_state != TCP_CLOSE || addr_len < sizeof(struct sockaddr_in))
		goto out;
	//检查绑定的地址类型是否合法
	chk_addr_ret = inet_addr_type(sock_net(sk), addr->sin_addr.s_addr);
	ret = -EADDRNOTAVAIL;
	//合法的绑定地址类型：本地地址，多播地址，广播地址
	if (addr->sin_addr.s_addr && chk_addr_ret != RTN_LOCAL &&
	    chk_addr_ret != RTN_MULTICAST && chk_addr_ret != RTN_BROADCAST)
		goto out;

	//多播，广播地址，源地址使用接口设备的地址
	inet->inet_rcv_saddr = inet->inet_saddr = addr->sin_addr.s_addr;
	if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
		inet->inet_saddr = 0;  
	sk_dst_reset(sk);
	ret = 0;
out:	return ret;
}




//	建立连接
//	步骤：
//		1.建立路由信息
//		2.更新sock->sk_state=TCP_ESTABLISHED表示建立了连接
4.2 int ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
{
	struct inet_sock *inet = inet_sk(sk);
	struct sockaddr_in *usin = (struct sockaddr_in *) uaddr;
	struct flowi4 *fl4;
	struct rtable *rt;
	__be32 saddr;
	int oif;
	int err;

	//重置inet的路由信息
	sk_dst_reset(sk);

	lock_sock(sk);
	//sock绑定的设备(可通过setsockopt建立)
	oif = sk->sk_bound_dev_if;
	saddr = inet->inet_saddr;
	fl4 = &inet->cork.fl.u.ip4;
	//建立路由信息
	rt = ip_route_connect(fl4, usin->sin_addr.s_addr, saddr,
			      RT_CONN_FLAGS(sk), oif,
			      sk->sk_protocol,
			      inet->inet_sport, usin->sin_port, sk, true);

	...

	inet->inet_daddr = fl4->daddr;
	inet->inet_dport = usin->sin_port;
	//更新sk->sk_state表示建立了连接
	sk->sk_state = TCP_ESTABLISHED;
	inet->inet_id = jiffies;
	//设置sock路由缓存
	sk_dst_set(sk, &rt->dst);
	err = 0;
out:
	release_sock(sk);
	return err;
}



//	发送数据
//	步骤：
//		1.获取目的地址
//			1.1 通过msghdr或inet_sock
//		2.初始化flow4结构体
//		3.通过flow4查找路由表，获取路由信息
//		4.将数据报添加到sk->sk_write_queue
//		5.没有设置MSG_MORE，通知ip层进程数据传输	
4.3 static int raw_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
		       size_t len)
{
	struct inet_sock *inet = inet_sk(sk);
	struct ipcm_cookie ipc;
	struct rtable *rt = NULL;
	struct flowi4 fl4;
	int free = 0;
	__be32 daddr;
	__be32 saddr;
	u8  tos;
	int err;
	struct ip_options_data opt_copy;

	...

	ipc.addr = inet->inet_saddr;
	ipc.opt = NULL;
	ipc.tx_flags = 0;
	//使用bound的出口设备
	ipc.oif = sk->sk_bound_dev_if;


	saddr = ipc.addr;
	ipc.addr = daddr;

	tos = RT_CONN_FLAGS(sk);

	//初始化flowi4结构
	flowi4_init_output(&fl4, ipc.oif, sk->sk_mark, tos,
			   RT_SCOPE_UNIVERSE,
			   inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
			   inet_sk_flowi_flags(sk) | FLOWI_FLAG_CAN_SLEEP,
			   daddr, saddr, 0, 0);


	//查找路由表，获得路由信息
	rt = ip_route_output_flow(sock_net(sk), &fl4, sk);

	err = -EACCES;
	//路由结果为广播，但是套接字不允许发送广播报文，直接返回
	if (rt->rt_flags & RTCF_BROADCAST && !sock_flag(sk, SOCK_BROADCAST))
		goto done;

	//目的地址
	if (!ipc.addr)
		ipc.addr = fl4.daddr;
	lock_sock(sk);
	//添加数据报到sock->sk_write_queue
	err = ip_append_data(sk, &fl4, ip_generic_getfrag, msg->msg_iov, len, 0, &ipc, &rt, msg->msg_flags);
	//出现错误，丢弃所有已经pending的ip报文
	if (err)
		ip_flush_pending_frames(sk);
	//MSG_MORE表示接下来还有msg
	else if (!(msg->msg_flags & MSG_MORE)) {
		//将sk_write_queue上的数据发送出去
		err = ip_push_pending_frames(sk, &fl4);
		if (err == -ENOBUFS && !inet->recverr)
			err = 0;
		release_sock(sk);
	}
done:
	if (free)
		kfree(ipc.opt);
	//递减路由信息的引用计数
	ip_rt_put(rt);

out:
	if (err < 0)
		return err;
	return len;

}

//	接收数据
//	步骤：
//		1.接收数据报
//		2.将数据报拷贝到iovec中 	
4.4 static int raw_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
		       size_t len, int noblock, int flags, int *addr_len)
{
	struct inet_sock *inet = inet_sk(sk);
	size_t copied = 0;
	int err = -EOPNOTSUPP;

	struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
	struct sk_buff *skb;

	//接收数据报
	skb = skb_recv_datagram(sk, flags, noblock, &err);
	if (!skb)
		goto out;


	//将数据从skb拷贝到iovec
	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
	if (err)
		goto done;
	//拷贝skb中的源地址
	if (sin) {
		sin->sin_family = AF_INET;
		sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
		sin->sin_port = 0;
		memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
	}

done:
	skb_free_datagram(sk, skb);
out:
	if (err)
		return err;
	return copied;
}
//	接收数据报
//	步骤：
//		1.获取允许的阻塞时间
//		2.如果sock->sk_receive_queue有接收到的skb，返回skb
//		3.如果可阻塞等待，则阻塞，否则直接返回null
4.5 struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned int flags,
				    int *peeked, int *off, int *err)
{
	struct sk_buff *skb;
	long timeo;

	//计算等待到期时间
	timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);

	do {
		//取下sock->sk_receive_queue接收到的skb
		unsigned long cpu_flags;
		struct sk_buff_head *queue = &sk->sk_receive_queue;

		spin_lock_irqsave(&queue->lock, cpu_flags);
		skb_queue_walk(queue, skb) {
			__skb_unlink(skb, queue);
			spin_unlock_irqrestore(&queue->lock, cpu_flags);
			return skb;
		}
		spin_unlock_irqrestore(&queue->lock, cpu_flags);

		error = -EAGAIN;
		if (!timeo)
			goto no_packet;
	//等待数据到来
	} while (!wait_for_packet(sk, err, &timeo));

	return NULL;

no_packet:
	*err = error;
	return NULL;
}


//	在sock上等待数据到来
//		1. 创建wait块，指定wait_func
//		2. 将wait块添加到sock->sk_wq上
//		3. 通过schedule_timeout阻塞
//	注：
//		创建的wait块添加到sock->sk_wq用于在有事件发生时，唤醒阻塞线程，
//		但是阻塞是通过schedule_timeout执行，而非wait块
4.6 static int wait_for_packet(struct sock *sk, int *err, long *timeo_p)
{
	int error;
	
	//创建wait块
	DEFINE_WAIT_FUNC(wait, receiver_wake_function);

	//将wait块添加到sock->sk_wq上
	prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);

	...

	error = 0;
	//重调度
	*timeo_p = schedule_timeout(*timeo_p);
out:
	finish_wait(sk_sleep(sk), &wait);
	return error;
}

最后更新：2017-04-03 12:55:18

  上一篇：go 2012蓝桥杯【初赛试题】干支纪年
  下一篇：go (function(){}})(); and (function(){}());的区别？