下面通过学习linux 1.2.13源码进一步理解socket通信机制。对该版本源码的学习主要参考《Linux内核网络栈源代码情景分析》（曹桂平 编著）。
要理解socket的本质，就要理解当调用socket函数时，该函数到底创建了什么？返回了什么？
int socket(int family, int type, int protocol);
socket 函数为用户层函数，该函数对应的内核函数为sock_socket(socket.c文件），源码如下：
static int sock_socket(int family, int type, int protocol)
{
int i, fd;
struct socket *sock;
struct proto_ops *ops; /* Locate the correct protocol family. */
for (i = ; i < NPROTO; ++i)
{
if (pops[i] == NULL) continue;
if (pops[i]->family == family)
break;
} if (i == NPROTO)
{
return -EINVAL;
} ops = pops[i]; /*
* Check that this is a type that we know how to manipulate and
* the protocol makes sense here. The family can still reject the
* protocol later.
*/ if ((type != SOCK_STREAM && type != SOCK_DGRAM &&
type != SOCK_SEQPACKET && type != SOCK_RAW &&
type != SOCK_PACKET) || protocol < )
return(-EINVAL); /*
* Allocate the socket and allow the family to set things up. if
* the protocol is 0, the family is instructed to select an appropriate
* default.
*/ if (!(sock = sock_alloc()))
{
printk("NET: sock_socket: no more sockets\n");
return(-ENOSR); /* Was: EAGAIN, but we are out of
system resources! */
} sock->type = type;
sock->ops = ops;
if ((i = sock->ops->create(sock, protocol)) < )
{
sock_release(sock);
return(i);
} if ((fd = get_fd(SOCK_INODE(sock))) < )
{
sock_release(sock);
return(-EINVAL);
} return(fd);
}
sock_socket 函数完成如下工作：
（1）分配socket、sock结构，这两个结构在网络栈的不同层次表示一个套接字连接。
（2）分配inode、file结构用于普通文件操作。
（3）分配一个文件描述符并返回给应用程序作为以后的操作句柄。
sock_alloc 函数用于分配一个inode节点，并返回该节点的socket指针
struct socket *sock_alloc(void)
{
struct inode * inode;
struct socket * sock; inode = get_empty_inode();
if (!inode)
return NULL; inode->i_mode = S_IFSOCK;
inode->i_sock = ;
inode->i_uid = current->uid;
inode->i_gid = current->gid; sock = &inode->u.socket_i;
sock->state = SS_UNCONNECTED;
sock->flags = ;
sock->ops = NULL;
sock->data = NULL;
sock->conn = NULL;
sock->iconn = NULL;
sock->next = NULL;
sock->wait = &inode->i_wait;
sock->inode = inode; /* "backlink": we could use pointer arithmetic instead */
sock->fasync_list = NULL;
sockets_in_use++;
return sock;
}
inode的定义如下
/* include/fs.h */
struct inode {
dev_t i_dev;
unsigned long i_ino;
umode_t i_mode;
nlink_t i_nlink;
uid_t i_uid;
gid_t i_gid;
dev_t i_rdev;
off_t i_size;
time_t i_atime;
time_t i_mtime;
time_t i_ctime;
unsigned long i_blksize;
unsigned long i_blocks;
unsigned long i_version;
struct semaphore i_sem;
struct inode_operations * i_op;
struct super_block * i_sb;
struct wait_queue * i_wait;
struct file_lock * i_flock;
struct vm_area_struct * i_mmap;
struct inode * i_next, * i_prev;
struct inode * i_hash_next, * i_hash_prev;
struct inode * i_bound_to, * i_bound_by;
struct inode * i_mount;
unsigned short i_count;
unsigned short i_wcount;
unsigned short i_flags;
unsigned char i_lock;
unsigned char i_dirt;
unsigned char i_pipe;
unsigned char i_sock;
unsigned char i_seek;
unsigned char i_update;
union {
struct pipe_inode_info pipe_i;
struct minix_inode_info minix_i;
struct ext_inode_info ext_i;
struct ext2_inode_info ext2_i;
struct hpfs_inode_info hpfs_i;
struct msdos_inode_info msdos_i;
struct umsdos_inode_info umsdos_i;
struct iso_inode_info isofs_i;
struct nfs_inode_info nfs_i;
struct xiafs_inode_info xiafs_i;
struct sysv_inode_info sysv_i;
struct socket socket_i;
void * generic_ip;
} u;
};
inode 结构是文件系统的一个结构体，该结构体中的成员变量u指明了该inode结构具体的文件类型，当inode是用于socket通信时，u的值就为socket_i。sock_alloc 的作用就是创建inode结构体，然后返回socket_i的地址。至于具体如何分配inode涉及到文件系统方面的知识，这里暂不讨论。
当协议族为AF_INET时，ops->create 将调用inet_create(struct socket*sock, int protocol)函数。该函数将创建一个sock结构体并使得socket的data指针指向该sock结构体。
static int inet_create(struct socket *sock, int protocol)
{
struct sock *sk;
struct proto *prot;
int err; sk = (struct sock *) kmalloc(sizeof(*sk), GFP_KERNEL);
if (sk == NULL)
return(-ENOBUFS);
sk->num = ;
sk->reuse = ;
switch(sock->type)
{
case SOCK_STREAM:
case SOCK_SEQPACKET:
if (protocol && protocol != IPPROTO_TCP)
{
kfree_s((void *)sk, sizeof(*sk));
return(-EPROTONOSUPPORT);
}
protocol = IPPROTO_TCP;
sk->no_check = TCP_NO_CHECK;
prot = &tcp_prot;
break; case SOCK_DGRAM:
if (protocol && protocol != IPPROTO_UDP)
{
kfree_s((void *)sk, sizeof(*sk));
return(-EPROTONOSUPPORT);
}
protocol = IPPROTO_UDP;
sk->no_check = UDP_NO_CHECK;
prot=&udp_prot;
break; case SOCK_RAW:
if (!suser())
{
kfree_s((void *)sk, sizeof(*sk));
return(-EPERM);
}
if (!protocol)
{
kfree_s((void *)sk, sizeof(*sk));
return(-EPROTONOSUPPORT);
}
prot = &raw_prot;
sk->reuse = ;
sk->no_check = ; /*
* Doesn't matter no checksum is
* performed anyway.
*/
sk->num = protocol;
break; case SOCK_PACKET:
if (!suser())
{
kfree_s((void *)sk, sizeof(*sk));
return(-EPERM);
}
if (!protocol)
{
kfree_s((void *)sk, sizeof(*sk));
return(-EPROTONOSUPPORT);
}
prot = &packet_prot;
sk->reuse = ;
sk->no_check = ; /* Doesn't matter no checksum is
* performed anyway.
*/
sk->num = protocol;
break; default:
kfree_s((void *)sk, sizeof(*sk));
return(-ESOCKTNOSUPPORT);
}
sk->socket = sock;
#ifdef CONFIG_TCP_NAGLE_OFF
sk->nonagle = ;
#else
sk->nonagle = ;
#endif
sk->type = sock->type;
sk->stamp.tv_sec=;
sk->protocol = protocol;
......
sk->timer.function = &net_timer;
skb_queue_head_init(&sk->back_log);
sk->blog = ;
sock->data =(void *) sk; //socket 指向 sock
sk->dummy_th.doff = sizeof(sk->dummy_th)/;
......
if (sk->prot->init)
{
err = sk->prot->init(sk);
if (err != )
{
destroy_sock(sk);
return(err);
}
}
return();
}
最后调用get_fd 返回一个文件描述符给上层应用。
/* socket.c */
static int get_fd(struct inode *inode)
{
int fd;
struct file *file; /*
* Find a file descriptor suitable for return to the user.
*/ file = get_empty_filp(); // 获取一个闲置的file结构
if (!file)
return(-); for (fd = ; fd < NR_OPEN; ++fd)
if (!current->files->fd[fd])
break;
if (fd == NR_OPEN)
{
file->f_count = ;
return(-);
} FD_CLR(fd, ¤t->files->close_on_exec);
current->files->fd[fd] = file;
file->f_op = &socket_file_ops; // socket 文件操作
file->f_mode = ;
file->f_flags = O_RDWR;
file->f_count = ;
file->f_inode = inode;
if (inode)
inode->i_count++;
file->f_pos = ;
return(fd);
}
get_fd 用于为网络套接字分配一个文件描述符，分配描述符的同时需要一个file结构，每个file结构都需要一个inode结构对应。内核维护一个file结构数据，get_empty_filp 函数即通过检查该数组，获取一个闲置的成员。f_op 字段的赋值实现了网络操作的普通文件接口。如果调用write、read函数进行操作就会调用相应的sock_read 和 sock_write 函数。
如何根据文件描述如fd找到相应的sock？