UDP Socket Creation The socketcall system call. All standard library functions that operate upon sockets (e.g., socket(), bind(), listen(), accept())  share the single system call, sys_socketcall. This front end is defined in net/socket.c.

 The parameter,  call, that is passed to the sys_socketcall front end is an integer that identifies the specific operation to  be performed. The possible values for call are defined in include/linux/net.h: 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define SYS_SOCKET SYS_BIND SYS_CONNECT SYS_LISTEN SYS_ACCEPT SYS_GETSOCKNAME SYS_GETPEERNAME SYS_SOCKETPAIR SYS_SEND SYS_RECV SYS_SENDTO SYS_RECVFROM SYS_SHUTDOWN SYS_SETSOCKOPT SYS_GETSOCKOPT SYS_SENDMSG SYS_RECVMSG 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* /* sys_socket(2) sys_bind(2) sys_connect(2) sys_listen(2) sys_accept(2) sys_getsockname(2) sys_getpeername(2) sys_socketpair(2) sys_send(2) sys_recv(2) sys_sendto(2) sys_recvfrom(2) sys_shutdown(2) sys_setsockopt(2) sys_getsockopt(2) sys_sendmsg(2) sys_recvmsg(2) */ */ */ */ */ */ */ */ */ */ */ */ */ */ */ */ */

1

The sys_socketcall() interface.  The sys_socketcall function is passed one of the function call identifiers (SYS_SOCKET..,  SYS_RECVMSG) in the call  parameter.  It is also passed a pointer to the table of argument pointers  via the parameter args. 1971 asmlinkage long sys_socketcall(int call, unsigned long __user *args) 1972 { 1973 unsigned long a[6]; // <--- local copy of args 1974 unsigned long a0,a1; 1975 int err;

It first checks whether the specific socket function call identifier is a valid one. 1977 1978 1979 if(call < 1 || call>SYS_RECVMSG) return -EINVAL;

2

Passing arguments through sys_socketcall() An array containing the number of argument passed to each of the calls, nargs[18],  is defined in  net/socket.c. There is one element for each of the 17 socket functions.  The value of nargs[j] is the  number of arguments required by function j.  The macro AL(x) converts the number of arguments to  the size of the argument list by multiplying by the size of a long integer.  For example, the bind  function has index j = 2 and has 3 arguments and thus the value of nargs[2] is 12.     int bind(int sockfd, struct sockaddr *addr, socklen_t addrlen); The entry for bind is shown in emphasized typeface in the table below. 1530 /* Argument list sizes for sys_socketcall */ 1531 #define AL(x) ((x) * sizeof(unsigned long)) 1532 static unsigned char nargs[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3), AL(3),AL(3),AL(4),AL(4),AL(4),AL(6), AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)}; 1535 #undef AL The sys_socketcall() function next copies the arguments from user­space to the local array a[] in  kernel­space using the size of argument list specified in the nargs[] array.   Auditing is a feature new  to kernel 2.6 and is associated with Security Enhance Linux (SEL).

1980 1981 1982 1983 1984 1985 1986 1987

/* copy_from_user should be SMP safe. */ if (copy_from_user(a, args, nargs[call])) return -EFAULT; err = audit_socketcall(nargs[call]/ sizeof(unsigned long), a); if (err) return err;

3

All socket functions have at least two arguments.  The first two are stored in a0 and a1. 1988 1989 a0=a[0]; a1=a[1];

Invoking the call­specific handler A switch statement  then calls to the required socket service function identified by the socket  function call identifier.  A few of these are shown here: 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2046 2047 2048 2049 2050 switch(call) { case SYS_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; case SYS_LISTEN: err = sys_listen(a0,a1); : default: err = -EINVAL; break; } return err;

4

Generic Socket Creation A user program creates a socket via the socket() function call: 

int socket (int family, int type, int protocol);
• •

The family parameter specifies a protocol family such as PF_INET.  The type parameter is normally SOCK_STREAM (TCP) or SOCK_DGRAM(UDP), but can  also be SOCK_COP after your protocol is inserted.   The protocol field is normally set to zero (IPROTO_IP)  for PF_INET sockets, but should be  set to  IPROTO_COP for COP sockets.  

If the default protocol,  IPROTO_IP is selected,  the socket type alone is used in identifying the  proper inet_protosw structure.   Thus there is necessarily only ONE choice:  TCP for  SOCK_STREAM; and UDP for SOCK_DGRAM. If the socket type is SOCK_RAW,  then the protocol  IPPROTO_RAW should also be specified and  the application is expected to provide full IP and transport layer headers.  Sockets of this type require  root privilege.  Values of IPPROTO_ are enums in include/linux/in.h and are in the Linux cross  reference.    A COP socket is created as follows.   The return value is an fd_array[] index if non­negative or an  error code if negative.

sd = socket(PF_INET, SOCK_COP, IPPROTO_COP);

5

int protocol) 1240 { 1241 int retval.  1239 asmlinkage long sys_socket(int family.The sys_socket function The application function socket() produces a call to the  sys_socket function which performs two  major steps: • • Creates the struct socket. if (retval < 0) goto out_release. int type. 1244 1245 1246 1247 retval = sock_create(family. protocol. // socket addr returned here. &sock).c .  the prefix sock_ indicates that a variable or function pertains to a struct socket   while the prefix sk_ indicates it pertains to a struct sock. type. 6 . and the struct sock. and links them together Maps the struct socket into the file system space As indicated before.  it must be mapped into the file space so that it can be  accessed via the fd which is returned in retval. if (retval < 0) goto out.   1248 1249 1250 1251 retval = sock_map_fd(sock). Mapping the socket into the file space If the socket was created successfully. 1243 The real work of socket creation is driven by the sock_create() function which also resides in  socket. 1242 struct socket *sock.

1258 return retval.Return from sys_socket() The value returned retval is the index of the struct file associated with the sock in the fd table. */ 1254 return retval. 1255 1256 out_release: 1257 sock_release(sock). 1252 out: 1253 /* It may be already another descriptor 8) Not kernel problem. 1259 } 7 .

1128 1129 /* 1130 * Check protocol is in range 1131 */ 1132 if (family < 0 || family >= NPROTO) 1133 return -EAFNOSUPPORT. 1134 if (type < 0 || type >= SOCK_MAX) 1135 return -EINVAL. type.The sock_create() function The socket layer functions are found in net/socket. int type.   1229 int sock_create(int family. 1232 } The first step is to verify that both the family (PF_INET) and the type (SOCK_DGRAM) are in  range.  This test does not ensure that they are actually valid. int protocol.   1124 static int __sock_create(int family. struct socket **res.   This function just calls  __sock_create()   indicating that this is not an internal kernel requestion. res. int protocol. int kern) 1125 { 1126 int err. 0).c. 1136 8 . 1127 struct socket *sock. struct socket **res) 1230 { 1231 return __sock_create(family. protocol. int type.

if (!warned) { warned = 1. } 9 . printk(KERN_INFO "%s uses obsolete (PF_INET.Exactly one warning that the type SOCK_PACKET  is deprecated is also generated if that type is  specified. */ if (family == PF_INET && type == SOCK_PACKET) { static int warned.   1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 /* Compatibility. } family = PF_PACKET. This uglymoron is moved from INET layer to here to avoid deadlock in module load. current->comm).SOCK_PACKET)\n".

1157 * */ 1162 if (net_families[family]==NULL) 1163 { 1164 request_module("net-pf-%d". Linux supports the dynamic loading of complete protocol stacks (families) as modules. if  #define PF_NEWPROTO 9 is requested then the module name requested will be net­pf­9. it attempts to  dynamically load it using the request_module() function.  Since the PF_INET is always registers  itself at boot time.  this code is not relevant to creating sockets of type PF_INET. kern). protocol. 1151 1152 1153 1154 err = security_socket_create(family. } 10 . type.  This error should never occur during creation of a UDP socket.   If  sock_create()  finds the requested protocol family pointer in net_families[] to be null. goto out.  For example.6. 1165 } 1166 #endif After the attempt to load the protocol completes.  This function tries to locate and load the  module using the alias entries in /etc/modules.family).Dynamic loading of entire  protocol family The security socket create is also related to new SEL "features" in kernel 2. 1155#if defined(CONFIG_KMOD) 1156 /* Attempt to load a protocol module if the find failed.  1168 1169 1170 1171 1172 1173 net_family_read_lock(). if (err) return err. if the protocol family remains unregistered then a  fatal error is recognized.conf and in the folder /lib/modules/'kernel­version'. if (net_families[family] == NULL) { err = -EAFNOSUPPORT.

107 struct socket { 108 socket_state 109 unsigned long 110 const struct proto_ops 111 struct fasync_struct 112 struct file 113 struct sock 114 wait_queue_head_t 115 short 116 }. 685 }. *ops. file: 11 . A pointer to the proto_ops structure that has been retrieved from the ip_protosw structure. SOCK_DGRAM. 684 struct inode vfs_inode. defined in include/linux/net.    The struct socket and the inode are embedded in the struct socket_alloc. type: proto_ops: state. flags. wait. Use to access file_ops function pointer table for read/write calls. *fasync_list.  The ops field provides the binding  from the thin socket layer to the PF_ layer. type. etc.The struct socket The importance of the struct socket. *file. SOCK_STREAM.  682 struct socket_alloc { 683 struct socket socket. *sk.  The sock_inode_cache of  socket_alloc structures was created during the call to sock_init.h  has diminished over time as the  more important data structures have moved to the struct sock.

etc */ 12 . err = -ENFILE..  1188 1189 sock->type = type. } When  sock_alloc() returns the new socket structure address to sock_create(). but its the closest posix thing */ goto out. /* SOCK_STREAM.  This leads to a  torturous path the eventually leads back to the function sock_alloc_inode() which also resides in  socket. /* Not exactly a match.  the socket type  (SOCK_DGRAM for UDP) is stored in the structure.c  1179 1180 1181 1182 1183 1184 1185 1186 1187 if (!(sock = sock_alloc())) { if (net_ratelimit()) printk(KERN_WARNING "socket: no more sockets\n").Allocation of the struct socket Next sock_create() invokes sock_alloc() to create the socket and inode structures.

if (!try_module_get(net_families[family]->owner)) goto out_release.  For  PF_INET this function is inet_create() which was previously encountered in the inet_init() function. This is the call to inet_create()  1198 1199 1200 1201 if ((err = net_families[family]->create(sock. goto out_module_put.Protocol family dependent initialization  It is not necessary to store the PF because that is implicit in the create function that is used. } 13 . protocol)) < 0) { sock->ops = NULL.  Failure to provide a create function will cause a kernel oops here!   Failure of the family dependent create function to fill in the ops pointer is also fatal. 1194 1195 1196 1197 err = -EAFNOSUPPORT.

*res = sock.Return from sock_create The  sock_create() function stores the socket pointer in the location provided by sys_socket() and  then returns err to sys_socket(). out_module_put: module_put(net_families[family]->owner). out_release: sock_release(sock). } 14 . protocol. type. kern). family. return err. out: net_family_read_unlock(). goto out. security_socket_post_create(sock.   1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 module_put(net_families[family]->owner).

c evenutally  allocates a struct socket_alloc. get_cpu_var(sockets_in_use)++. 520 if (!inode) 521 return NULL.  514 static struct socket *sock_alloc(void) 515 { 516 struct inode * inode.  Among these is a pointer to the inode allocator. inode->i_mode = S_IFSOCK|S_IRWXUGO.Socket allocation details The sock_alloc() function defined in net/socket. return sock. 517 struct socket * sock.  The superblock contains a pointer to a table  of  super block operations.  The  struct socket and the inode are embedded in the struct socket_alloc. 15 . 522 The SOCKET_I and SOCK_INODE macros recover the socket pointer from the inode pointer and  vice versa.   The sock_mnt pointer is a gobal variable in socket. inode->i_uid = current->fsuid. put_cpu_var(sockets_in_use).c that was set up to point to the super block of the  socket virtual filesystem when the system was mounted. 518 519 inode = new_inode(sock_mnt->mnt_sb). inode->i_gid = current->fsgid. 523 524 525 526 527 528 529 530 531 532 } sock = SOCKET_I(inode).

The socket_alloc structure is a linux "container". 685 }. sock_mnt = kern_mount(&sock_fs_type). 690 } 691 692 static inline struct inode *SOCK_INODE(struct socket *socket) 693 { 694 return &container_of(socket. struct socket_alloc. vfs_inode)->socket.  2226 2227 2228 init_inodecache().  682 struct socket_alloc { 683 struct socket socket. 695 } 16 . struct socket_alloc. 684 struct inode vfs_inode. socket)->vfs_inode. Macros are provided to convert a pointer to one element to a pointer to the other.   A cache of these structure was created by the sock_init function seen earlier in the netinit section.The struct socket_alloc cache  Both socket and inode structures are imbedded in the struct socket_alloc. 687 static inline struct socket *SOCKET_I(struct inode *inode) 688 { 689 return &container_of(inode. register_filesystem(&sock_fs_type).  The sock_mnt variable is a global variable that points to the super block of the sock_fs.

member){ \ 296 const typeof( ((type *)0)->member ) *__mptr = (ptr).288 /** 289 * container_of .offsetof(type. 297 (type *)( (char *)__mptr .cast a member of a structure out to the containing structure 290 * @ptr: the pointer to the member. 293 * 294 */ 295 #define container_of(ptr. 291 * @type: the type of the container struct this is embedded in. type.}) 298 \ 17 . 292 * @member: the name of the member within the struct.member) ).

i_hash. 18 .  Its primary purpose is to bind the fd space to the struct socket. *generic_ip. i_list. 559 #ifdef __NEED_I_SIZE_ORDERED 560 seqcount_t 561 #endif 562 }. i_sb_list.  497 struct inode { 498 struct hlist_node 499 struct list_head 500 struct list_head 501 struct list_head 502 unsigned long 503 atomic_t 504 umode_t 505 unsigned int 554 atomic_t 555 void 556 union { 557 void 558 } u.The inode structure The union at the end of the inode structure used to contain instances of a variety of fs type dependent  structures including the struct socket. i_mode. i_writecount. i_dentry. *i_security. i_ino. i_nlink. i_size_seqcount.  Now little if anything within the inode is used in network  processing. i_count.

565} 19 . 553 554 inode = alloc_inode(sb). 561 inode->i_state = 0. 550 struct inode * inode. 562 spin_unlock(&inode_lock). &inode_in_use). 559 list_add(&inode->i_sb_list. 558 list_add(&inode->i_list. 555 if (inode) { 556 spin_lock(&inode_lock). &sb->s_inodes).  Memory resident generic inode structures can be  allocated by the slab allocator from an inode cache created at boot time or provided from special  cache created by the vfs itself.   The new_inode() functions ensures that inode allocation succeded then proceeds to enqueue in on the  inode_in_use list and initialize several fields.Inode allocation The new_inode() function is defined in fs/inode. 551 552 spin_lock_prefetch(&inode_lock).c.  547 struct inode *new_inode(struct super_block *sb) 548 { 549 static unsigned long last_ino.nr_inodes++. 557 inodes_stat.  The inode numbers are sequentially assigned using the  static variable last_ino. 560 inode->i_ino = ++last_ino. 563 } 564 return inode.

106 static const struct file_operations empty_fops. 20 .The alloc_inode() function. 108 109 if (sb->s_op->alloc_inode) 110 inode = sb->s_op->alloc_inode(sb).   100 static kmem_cache_t * inode_cachep __read_mostly. 335 }. 101 102 static struct inode *alloc_inode(struct super_block *sb) 103 { 104 static const struct address_space_operations empty_aops. 105 static struct inode_operations empty_iops.  it allocates an inode from the generic inode_cache.  331 static struct super_operations sockfs_ops = { 332 alloc_inode = sock_alloc_inode.c.  If the super_block's s_op structure doesn't contain  a pointer to  an an inode allocator. 333 destroy_inode =sock_destroy_inode.   The alloc_inode() macro is defined in fs/inode. 334 statfs = simple_statfs. 107 struct inode *inode. SLAB_KERNEL).   In the case of a socket such a pointer does exist and the actual allocation is performed by  sock_alloc_inode(). 111 else 112 inode = (struct inode *) kmem_cache_alloc( inode_cachep.

atomic_set(&inode->i_writecount. inode->i_generation = 0. inode->i_size = 0. inode->i_flags = 0. inode->i_op = &empty_iops. 1). atomic_set(&inode->i_count. inode->i_nlink = 1. inode->i_sb = sb. } return inode. inode->i_bytes = 0. 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 : : 168 169 170} if (inode) { struct address_space * const mapping = &inode->i_data. inode->i_blocks = 0. inode->i_fop = &empty_fops. 0). 21 . inode->i_blkbits = sb->s_blocksize_bits.If allocation succeeds a considerable amount of generic initialization follows.

flags = 0. ei->socket. 289 if (!ei) 290 return NULL. SLAB_KERNEL). 293 294 295 296 297 298 299 300 301 302 } ei->socket. return &ei->vfs_inode.sk = NULL.ops = NULL. ei->socket.fasync_list = NULL. 292 This function is also responsible for initializing the struct socket to a consistent state. 22 . ei->socket.    285 static struct inode *sock_alloc_inode(struct super_block *sb) 286 { 287 struct socket_alloc *ei.flags = 0. ei->socket. 288 ei = (struct socket_alloc *) kmem_cache_alloc(sock_inode_cachep.file = NULL. ei->socket.  Actual allocation of socket and inode structures from the sock_inode_cache is performed here.state = SS_UNCONNECTED.The sock_alloc_inode() function.wait). ei->socket. 291 init_waitqueue_head(&ei->socket.

   The IP related fields are now moved to the inet_sock and transport dependent  fields live in the a transport dependent extension such as tcp_sock.    Therefore pointers to any of the three may be freely cast to any other.  It used to be the case that the struct sock  contained a mix of somewhat generic stuff along with IP  dependent stuff.  The inet_sock   contains an instance of the struct sock as its first element.  To minimize the confusion a standard naming convention is  used. The  struct socket and struct sock are two related and easy­to­confuse structures that are widely used  within the TCP/IP implementation.        sock  always refer to the generic struct socket  sk  always refer to the protocol dependent structure struct sock.Protocol family dependent initialization  The  mission of IPV4 dependent socket creation is to create and initialize the struct inet_sock.   23 .     Each transport sock must contain an instance of an inet_sock as its first element.

111#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) 112 struct ipv6_pinfo *pinet6. This is  usually the same as  rcv_saddr if rcv_saddr != 0. 120 __s16 uc_ttl.The struct inet_sock The IPV4 struct inet_ sock is defined in include/net/sock. 119 __u32 saddr.   24 . 124 __u16 id.h. 125 __u8 tos. 121 __u16 cmsg_flags. 118 __u16 num. 123 __u16 sport.  This must be the destination  IP address that is carried by incoming packet to be matched or the wildcard 0.     All fields except num must be in network   byte order. 116 __u32 rcv_saddr. daddr   rcv_saddr dport num sport saddr IP address of the remote endpoint of a connected socket Local IP address to which this socket is bound. 122 struct ip_options *opt. */ 115 __u32 daddr. Remote port address for a connected socket Local port address in host byte order to which this socket is bound (or  protocol number for raw sockets Local port to which socket is bound in network byte order Local IP address which outgoing packets will carry as source address. 113#endif 114 /* Socket demultiplex comparisons on incoming packets. 117 __u16 dport.  The elements shown in blue must be  used by your COP protocol for managing connections. 108 struct inet_sock { 109 /* sk and pinet6 must be the first two members of inet_sock */ 110 struct sock sk.

  The queuing mechanism is a bit unusual here.Sock stuctures   The struct sock_common is apparently intended to house elements that are common to either all  transport protocols or all protocol families.  the 64K port space is divided into 128 hash queues and the struct socks are  mapped to a hash queue by local port number.   The skc_bind_node is not used in raw or UDP sockets. skc_state.  For the raw struct proto the hash key  is the low order 5 bits of the protocol number. skc_refcnt.  Your protocol must  provide a table. 111 struct sock_common { 112 unsigned short 113 volatile unsigned char 114 unsigned char 115 int 116 struct hlist_node 117 struct hlist_node 118 atomic_t 119 unsigned int 120 struct proto 121 }. the skc_node is used to link all the sk's associated with a given struct proto. skc_reuse. skc_bound_dev_if. *skc_prot. to link all struct socks   that are bound to a single port. skc_node.   In contrast.  Other fields are dependent upon system configuration and include areas that are private to specific protocols. skc_bind_node.   struct hlist_head cop_hash[COP_HTABLE_SIZE] hashed list headers and the  helper function will  use the skc_node structure to link the struct sock into your queue. For raw sockets. skc_family. 25 . for UDP.  A  pointer to the hashing function is contained in the struct proto.   The hlist_node elements are used to link the struct sock  into hash queues. skc_hash.   It is are used by TCP.    These  queues underly the mechanism by which incoming packets are matched to a particular struct sock.

*sk_sleep. *sk_dst_cache.skc_bound_dev_if 192 #define sk_node __sk_common. so please just 185 * don't add nothing before this first member (__sk_common) 186 */ 187 struct sock_common __sk_common. 188 #define sk_family __sk_common.skc_prot 197 198 199 200 201 202 203 204 205 206 207 unsigned char unsigned char unsigned short int socket_lock_t wait_queue_head_t struct dst_entry struct xfrm_policy rwlock_t sk_shutdown : 2. sk_dst_lock.The struct sock Elements of this large structure are critical to network operation.skc_reuse 191 #define sk_bound_dev_if __sk_common.skc_hash 196 #define sk_prot __sk_common. 26 .4 kernel the elements did  not possess the sk_ prefix so a lot of code had to be changed on the way to 2.skc_state 190 #define sk_reuse __sk_common.skc_node 193 #define sk_bind_node __sk_common.skc_family 189 #define sk_state __sk_common. // routing data *sk_policy[2].   In the 2. sk_no_check : 2. 182 struct sock { 183 /* 184 * Now struct inet_timewait_sock also uses sock_common.6.skc_refcnt 195 #define sk_hash __sk_common. sk_rcvbuf. sk_protocol.  but very few of them must be  directly manipulated by a correctly written transport protocol. // buffer quota sk_lock.   The first group is a collection of  aliases designed to ease migration to the use of the sock_common. sk_userlocks : 4. // 6 is TCP sk_type.skc_bind_node 194 #define sk_refcnt __sk_common.

sk_rcvlowat. sk_receive_queue. sk_lingertime. Therefore we special case it's implementation. // output queue sk_async_wait_queue. sk_wmem_queued. sk_sndbuf. // bytes allocated sk_wmem_alloc. 223 /* 224 * The backlog queue is special. 230 struct sk_buff *tail. // buffer quota sk_route_caps. The backlog queue plays a big role in TCP input processing but UDP/COP  do not use one. 27 . it is always used with 225 * the per-socket spinlock held and requires low latency 226 * access. sk_gso_type. sk_allocation.208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 atomic_t atomic_t atomic_t struct sk_buff_head struct sk_buff_head struct sk_buff_head int int gfp_t int int int int unsigned long unsigned long sk_rmem_alloc. // input queue sk_write_queue. 231 } sk_backlog. sk_flags. 227 */ 228 struct { 229 struct sk_buff *head. sk_forward_alloc. sk_omem_alloc.

*sk_sndmsg_page. (*sk_state_change)(struct sock *sk). sk_ack_backlog. (*sk_destruct)(struct sock *sk). sk_write_pending. struct sk_buff *skb). sk_priority. (*sk_write_space)(struct sock *sk). sk_err.232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 } 262 struct sk_buff_head struct proto rwlock_t int unsigned short unsigned short __u32 struct ucred long long struct sk_filter void struct timer_list struct timeval struct socket void struct page struct sk_buff __u32 int void void void void void int void . *sk_protinfo. sk_rcvtimeo. (*sk_backlog_rcv)(struct sock *sk. *sk_user_data. sk_sndtimeo. sk_callback_lock. int bytes). *sk_filter. sk_peercred. sk_max_ack_backlog. 28 . sk_err_soft. (*sk_error_report)(struct sock *sk). sk_error_queue. (*sk_data_ready)(struct sock *sk. sk_sndmsg_off. *sk_send_head. sk_stamp. sk_timer. *sk_prot_creator. *sk_security. *sk_socket.

229 struct inet_sock *inet. 237 29 .    The answer variables are set in the initial lookup and frequently referenced throughout.c. 234 int err.   Its primary function is to create  and initialize the  struct sock. It is passed a pointer to the generic  struct socket and the either the IP specific transport protocol number passed to sys_socket or  (typically in the case of UDP and TCP)  the wild­card value of 0. 228 struct inet_protosw *answer.IP dependent socket creation with inet_create() The inet_create() function resides in linux/net/ipv4/af_inet. 233 int try_loading_module = 0. 231 unsigned char answer_flags.  224static int inet_create(struct socket *sock. 232 char answer_no_check. 230 struct proto *answer_prot. 235 236 sock->state = SS_UNCONNECTED. 227 struct list_head *p. int protocol) 225{ 226 struct sock *sk.

 (SOCK_DGRAM for UDP). 240 lookup_protocol: 241 err = -ESOCKTNOSUPPORT. struct inet_protosw.    Its also possible that IPPROTO_IP may also be the protocol type specified in the struct   inet_protosw. 242 rcu_read_lock().  and in line number 249 a protocol match is found. */ 247 if (protocol == answer->protocol) { 248 if (protocol != IPPROTO_IP) 249 break. 243 list_for_each_rcu(p. 261 } 262 30 . 260 answer = NULL. 245 246 /* Check the non-wild match.    238 /* Look for the requested type/protocol pair.The protocol matching procedure In the protocol lookup loop.  In that case the match will occur at line 256. 258 } 259 err = -EPROTONOSUPPORT.  In line 253 protocol is set to the default protocol namely IPPROTO_UDP for the SOCK_DGRAM  socket type. &inetsw[sock->type]) { 244 answer = list_entry(p. the list of all the inet_protosw structures (normally only 1) associated  with socket type. 255 } 256 if (IPPROTO_IP == answer->protocol) 257 break. */ 252 if (IPPROTO_IP == protocol) { 253 protocol = answer->protocol. */ 239 answer = NULL.  is searched.   The input protocol is typically 0 (IPPROTO_IP). 250 } else { 251 /* Check for the two wild cases. list). 254 break.

if (answer->capability > 0 && !capable(answer->capability)) goto out_rcu_unlock. 31 . e. sock->type).6 the capability to demand load specific transport protocols was also added. its necessary to go back to  lookup_protocol to see if the actual socket type and protocol registered by the module actually  match. PF_INET.  263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 if (unlikely(answer == NULL)) { if (try_loading_module < 2) { rcu_read_unlock().  This is where  unpriviledged apps trying to open raw sockets get snagged. goto lookup_protocol.  It should be  possible to load NTP this way but it will not be a requirement.Dynamic loading of transport protocol modules In kernel 2. net-pf-2-proto-132 * (net-pf-PF_INET-proto-IPPROTO_SCTP) */ else request_module("net-pf-%d-proto-%d". 285 286 287 288 err = -EPERM. protocol.  If a module is loaded. PF_INET. /* * Be more specific. /* * Fall back to generic. protocol). } else goto out_rcu_unlock. net-pf-2-proto-132-type-1 * (net-pf-PF_INET-proto-IPPROTO_SCTP-type-SOCK_STREAM) */ if (++try_loading_module == 1) request_module("net-pf-%d-proto-%d-type-%d". } Verify that required capability is possessed by the process trying to create the socket.g.   Apparently the try_loading_module   variable determines the naming strategy . e.g.

     289 sock->ops = answer->ops. 978 connect: inet_dgram_connect. 990 mmap: sock_no_mmap.  This  contains pointers to the high level (somewhat transport independent) entry points to the AF_INET  protocol stack. sock­>ops  points to the inet_dgram_ops structure which is  defined in net/ipv4/af_inet. 984 listen: sock_no_listen. 992 }. 983 ioctl: inet_ioctl. 981 getname: inet_getname. 987 getsockopt: inet_getsockopt. 980 accept: sock_no_accept. For sockets of type SOCK_DGRAM. 988 sendmsg: inet_sendmsg. 977 bind: inet_bind. 991 sendpage: sock_no_sendpage. 290 answer_prot = answer->prot. 979 socketpair: sock_no_socketpair. 975 976 release: inet_release. 985 shutdown: inet_shutdown. 32 . 982 poll: datagram_poll. Here the struct proto_ops pointer is copied from the inet_protosw structure to the struct socket.c   973 struct proto_ops inet_dgram_ops = { 974 family: PF_INET.   Storing of the struct proto pointer answer_prot must be  deferred because the struct   sock is not yet allocated. 986 setsockopt: inet_setsockopt.Setting the struct proto_ops. 989 recvmsg: inet_recvmsg.

BUG_TRAP(answer_prot->slab != NULL). sk = sk_alloc(PF_INET.    291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 answer_no_check = answer->no_check.  The value of no_check for UDP is UDP_CSUM_DEFAULT and the value of flags is  INET_PROTOSW_PERMANENT. err = 0. inet->is_icsk = INET_PROTOSW_ICSK & answer_flags. if (sk == NULL) goto out. answer_prot. err = -ENOBUFS. The inet_sk()macro simply casts a struct sock pointer to a struct inet_sock pointer. GFP_KERNEL. if (INET_PROTOSW_REUSE & answer_flags) sk->sk_reuse = 1. sk->sk_no_check = answer_no_check. 307 308 309 inet = inet_sk(sk).. rcu_read_unlock().  This is a useful  macro for you to use. You can also build a cop_sk(). 1). 33 . answer_flags = answer->flags.

  Later in this section we will see  that for non­raw sockets it does indeed contain a the local port number. 34 . 0.The overloaded sk­>num field Here we see that sk­>num is set to the protocol number for sockets of type raw.   The comments in  the structure definition say that this field is the local port number. else inet->pmtudisc = IP_PMTUDISC_WANT. PF_INET. -1. protocol. 1. sk->sk_destruct sk->sk_family sk->sk_protocol sk->sk_backlog_rcv inet->uc_ttl inet->mc_loop inet->mc_ttl inet->mc_index inet->mc_list = = = = = = = = = inet_sock_destruct. NULL. 1. } if (ipv4_config.  323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 sock_init_data(sock. sk_refcnt_debug_inc(sk). if (IPPROTO_RAW == protocol) inet->hdrincl = 1. inet->id = 0. sk).c initializes the struct sock and links it with  the struct socket. sk->sk_prot->backlog_rcv.no_pmtu_disc) inet->pmtudisc = IP_PMTUDISC_DONT. The sock_init_data() function defined in net/core/sock.   The sk pointer in the struct socket points to a struct sock.  310 311 312 313 314 315 316 317 318 319 320 321 322 if (SOCK_RAW == sock->type) { inet->num = protocol.

The value of sk­>num  as stated earlier is overloaded. } 35 .  Normally port numbers are  assigned only at bind/connect time.Linking raw sockets into a hash queue.    For non­raw sockets inet­>num != 0  is a very unusual circumstance.  For UDP/TCP sockets  created as SOCK_DGRAM or SOCK_STREAM  sk­>num is  the local  port number and will be 0   here.  338 339 340 341 342 343 344 345 346 347 348 if (inet->num) { /* It assumes that any protocol which allows * the user to assign a number at socket * creation time automatically * shares. it is mandatory that the protocol provide a hash function.    Sockets of type SOCK_DGRAM or SOCK_STREAM are hashed at bind time. /* Add to protocol hash chains. */ sk->sk_prot->hash(sk).  Thus. */ inet->sport = htons(inet->num).  For raw sockets it was set to the protocol  number.

Invoking the transport protocol initialization procedure Since the udp_prot structure  doesn't provide an init function the following code block does nothing  in the case of a UDP socket.   The sk_common_release(sk) function will be called  by your cop_close() function to free the struct sock. 351 if (err) 352 sk_common_release(sk). 359} 36 . 353 } 354 out: 355 return err.  349 if (sk->sk_prot->init) { 350 err = sk->sk_prot->init(sk). 356 out_rcu_unlock: 357 rcu_read_unlock().    Your COP module must provide an init function.  For now it should  just issue a printk() verifying that it was called. 358 goto out.

if (!try_module_get(prot->owner)) goto out_free.  The sk­>prot field is set to  the struct proto pointer from the answer pointer to struct inet_protosw.Allocation of the struct sock The sk_alloc() function resides in net/core/sock. 840 struct sock *sk_alloc(int family. priority).c and allocates the requested structure from the  cache created during the call to proto_register(). 0. 841 struct proto *prot. 848 else 849 sk = kmalloc(prot->obj_size. sk->sk_family = family. 845 846 if (slab != NULL) 847 sk = kmem_cache_alloc(slab. 844 kmem_cache_t *slab = prot->slab. int zero_it) 842 { 843 struct sock *sk = NULL.  851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 if (sk) { if (zero_it) { memset(sk. gfp_t priority. priority). family. priority)) goto out_free. prot->obj_size). 850 The struct proto contains the entry points into the true transport protocol. 37 .   Here the item allocated has sizeof(struct copsock). } if (security_sk_alloc(sk. /* * See comment in struct sock definition to understand * why we need sk_prot_creator -acme */ sk->sk_prot = sk->sk_prot_creator = prot. sock_lock_init(sk). } return sk.

871 out_free: 872 if (slab != NULL) 873 kmem_cache_free(slab. sk). 874 else 875 kfree(sk). 876 return NULL. 877} 38 .

1490 1491 1492 1493 sk->sk_allocation sk->sk_rcvbuf sk->sk_sndbuf sk->sk_state = = = = GFP_KERNEL. skb_queue_head_init(&sk->sk_write_queue). sysctl_wmem_default. Set back pointer to struct socket. 1484#endif 1485 1486 sk->sk_send_head = NULL. struct sock *sk) 1478 { Initialize buffer queues for packets awaiting local delivery or  transmission  1479 1480 1481 skb_queue_head_init(&sk->sk_receive_queue).Initialization of the struct_sock 1477 void sock_init_data(struct socket *sock. sock_set_flag(sk. 1482#ifdef CONFIG_NET_DMA 1483 skb_queue_head_init(&sk->sk_async_wait_queue). SOCK_ZAPPED).  1494 1495 1496 1497 sk->sk_socket = sock. 1487 1488 init_timer(&sk->sk_timer). 1489 Initialize buffer space allocation flags and space quotas. sysctl_rmem_default. 39 . TCP_CLOSE. skb_queue_head_init(&sk->sk_error_queue).

1). MAX_SCHEDULE_TIMEOUT. af_callback_keys + sk->sk_family). 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 } sk->sk_state_change sk->sk_data_ready sk->sk_write_space sk->sk_error_report sk->sk_destruct sk->sk_sndmsg_page sk->sk_sndmsg_off sk->sk_peercred. = -1L. &sock->wait. sock_def_readable.   1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 if(sock) { sk->sk_type sk->sk_sleep sock->sk } else sk->sk_sleep = = = = sock->type. sk. rwlock_init(&sk->sk_dst_lock).pid sk->sk_peercred. NULL. -1. 0.    The forward pointer in  the struct socket is set to point  to the struct sock in line 1502.   Note for PF_INET all of these are  generics that live in the socket layer. lockdep_set_class(&sk->sk_callback_lock. 0. -1. Function pointers for managing sleep/wakeup transitions.gid sk->sk_write_pending sk->sk_rcvlowat sk->sk_rcvtimeo sk->sk_sndtimeo sk->sk_stamp. rwlock_init(&sk->sk_callback_lock). NULL. 40 . 0.tv_sec sk->sk_stamp.For UDP the sock pointer will point to the struct socket just allocated. MAX_SCHEDULE_TIMEOUT. sock_def_wakeup. sock_def_write_space. atomic_set(&sk->sk_refcnt. sock_def_destruct. sock_def_error_report. 1.tv_usec = = = = = = = = = = = = = = = -1L.  The waitqueue pointer of the  struct sock refers to the waitqueue structure embeded in the struct socket.uid sk->sk_peercred.

Data structures used  in mapping the socket structure into the file space Access to a struct socket is via a chain of data structures: struct task_struct struct files_struct fd_array struct file  struct dentry struct inode struct socket 41 .

unsigned long flags.The task_struct  File descriptors are small integers used in Linux to identify open files via the files_struct pointer in  the  task_struct of the process. 0 runnable. /* per process flags. >0 stopped */ struct thread_info *thread_info. 883/* namespace */ /* -1 unrunnable. 42 . 769 770 771 772 : 881/* open file information */ 882 struct files_struct *files.  767 struct task_struct { 768 volatile long state. atomic_t usage. defined below */ unsigned long ptrace.

 The value returned by the open and socket system calls is an index into this table.The files_struct The files_struct contains the following fields.   The field of interest to us is the pointer to the FD  array. 53 struct fdtable *fdt. 59 int next_fd. 43 . 54 struct fdtable fdtab. 63 }. 62 struct file * fd_array[NR_OPEN_DEFAULT]. 55 /* 56 * written part on a separate cache line in SMP 57 */ 58 spinlock_t file_lock ____cacheline_aligned_in_smp. 60 struct embedded_fd_set close_on_exec_init. 61 struct embedded_fd_set open_fds_init.  48 struct files_struct { 49 /* 50 * read mostly part 51 */ 52 atomic_t count.

fu_rcuhead. 671 struct file { 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 */ union { struct list_head struct rcu_head fu_list.   The f_op table is used in vectoring generic file  operations such as read and write to their handler in the socket system. struct file_ra_state f_ra. unsigned long void f_version. unsigned int f_uid. f_gid. struct dentry *f_dentry.  Important linkage elements are the  dentry pointer and the file_operations pointer. } f_u. atomic_t f_count. /* needed for tty driver. and maybe others */ void *private_data. struct fown_struct f_owner. mode_t f_mode.The struct file   The kernel manages each open file or socket via the struct file. loff_t f_pos. *f_security. struct vfsmount *f_vfsmnt. unsigned int f_flags. const struct file_operations *f_op. 44 .

84 unsigned int d_flags.   We know that the inode and the socket structures are  allocated together as a single entity. /* lookup hash list */ struct dentry *d_parent. 88 89 90 91 92 93 94 /* protected by d_lock */ /* per dentry lock */ /* Where the name belongs to /* * The next three fields are touched by __d_lookup. * Place them here * so they all fit in a cache line. 85 spinlock_t d_lock.The struct dentry  The kernel cache the directory entries of for recently used files and all sockets in the dcache. 86 struct inode *d_inode. */ struct hlist_node d_hash. /* parent directory */ struct qstr d_name. 45 .  82 struct dentry { 83 atomic_t d_count.  The  struct dentry provides access to the inode.

  425 426 int fd = sock_alloc_fd(&newfile).The mapping mechanism Mapping a file structure associated with the socket into the fd space of the current process is  performed by sock_map_fd(). newfile). dentry. defined in net/socket. } return fd. } The call to fd_install() actually stores the struct file pointer in the fd array. and inode.  435 436 437 438} fd_install(fd. The call to sock_alloc_fd() obtains the index of a free spot in the fd_array and acquires an new struct   file. put_unused_fd(fd). The call to sock_attach_fd() does the work of linking file. if (unlikely(err < 0)) { put_filp(newfile). return err.  427 428 429 430 431 432 433 434 if (likely(fd >= 0)) { int err = sock_attach_fd(sock.    422 int sock_map_fd(struct socket *sock) 423 { 424 struct file *newfile.c. newfile). 46 .

 If one day we will need it.  Note that another  thread may close the file descriptor before we return from this function. return -ENFILE. } } else *filep = NULL. but do we take care of internal coherence. On success  it returns the file descriptor and the file struct implicitly stored in sock­>file. We cannot solve it inside the kernel.'' 376 static 377 { 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392} int sock_alloc_fd(struct file **filep) int fd. *filep = file.  In any case returned fd may be not valid! This race condition is inavoidable with  shared fd spaces. if (likely(fd >= 0)) { struct file *file = get_empty_filp(). this function will increment reference  count on file by 1. if (unlikely(!file)) { put_unused_fd(fd). return fd.  The following comment taken from the function describes some complicating factors:  ``This function creates a file structure and maps it to the fd space of the current process. 47 .The sock_alloc_fd() function. fd = get_unused_fd().  We do not refer to socket  after the mapping is complete.

     403 404 405 406 407 408 409 410 411 file->f_dentry = d_alloc(sock_mnt->mnt_sb->s_root.  The name of this pseudo file is the ASCII encoding of its inode   number. &this). The f_dentry is pointer to the newly created dcache directory  entry.  points the the struct file at the struct dentry. d_add(file->f_dentry. this.     399 400 401 402 this. file->f_dentry->d_op = &sockfs_dentry_operations.name = name. 397 char name[32].The sock_attach_fd() function This function creates a name for the pseudo file associated with the socket.len = sprintf(name. file->f_vfsmnt = mntget(sock_mnt).  allocates a directory  entro for the file. write() and friends are mapped to  socket operations. The d_alloc() function copies the contents of this into the allocated storage. this.hash = SOCK_INODE(sock)->i_ino.  The f_op entry provides the mechansim by which read(). 48 . SOCK_INODE(sock)->i_ino).  and asks d_add() to link the inode to  the dentry. an efficient way of storing a string and it's meta  data (len. struct file *file) 395 { 396 struct qstr this. "[%lu]". if (unlikely(!file->f_dentry)) return -ENOMEM.   Note that this operation  is being performed on the socket VFS . 398 The variable this is of type struct qstr (quickstring). file->f_mapping = file->f_dentry->d_inode->i_mapping.    394 static int sock_attach_fd(struct socket *sock. hash) for quick retrieval. SOCK_INODE(sock)).

sendpage = sock_sendpage. file->private_data = sock. 135#endif 136 .aio_write = sock_aio_write.fasync = sock_fasync. /* special open code to disallow open via /proc */ 138 .open = sock_no_open. file->f_flags = O_RDWR. 137 .unlocked_ioctl = sock_ioctl. 412 413 414 415 416 417 418 419 420 } sock->file = file.aio_read = sock_aio_read. file->f_pos = 0. 141 .llseek = no_llseek. 126 static struct file_operations socket_file_ops = { 127 . file->f_op = SOCK_INODE(sock)->i_fop = &socket_file_ops. file->f_mode = FMODE_READ | FMODE_WRITE. The socket_file_ops structure provides the bindings that vector standard file system operations to  handlers in the socket file system. 49 .splice_write = generic_splice_sendpage.release = sock_close. 143 .compat_ioctl = compat_sock_ioctl. 132 . 139 . 140 . 128 .owner = THIS_MODULE. return 0.writev = sock_writev. 130 . 129 .readv = sock_readv.poll = sock_poll.mmap = sock_mmap. 131 . 142 .Binding the standard system I/O calls to the socket The socket_file_ops structure contains the bindings that map "regular" file system calls in to the  socket layer. 133#ifdef CONFIG_COMPAT 134 . 144}.

*/ int get_unused_fd(void) { struct files_struct * files = current->files. this test will limit the total number of files that can be opened.. 741 goto repeat. by  finding the next available bit that can be set as an used fd. repeat: fd = find_next_zero_bit(files->open_fds.rlim_cur) 734 goto out. 736 /* Do we need to expand the fdset array? */ 737 if (fd >= files->max_fdset) { 738 error = expand_fdset(files.c . find_next_zero_bit() defined in include/asm/bitops. error.. 732 */ 733 if (fd >= current->rlim[RLIMIT_NOFILE]. For clone tasks sharing a files structure. The fdset can only hold 1024 descriptors initially.h finds the next available fd from the fdset. 744 } 50 . files->next_fd). write_lock(&files->file_lock). it is necessary to see if  the number of open files exceeds the maximum.B. 729 /* 730 * N. fd). and mark it busy. files->max_fdset. int fd. 739 if (!error) { 740 error = -EMFILE.  but if that limit is reached it may be increased.4 version. 742 } 743 goto out. error = -EMFILE.  When it returns.Allocating a free fd The get_unused_fd() function is defined in fs/open. 713 714 715 716 717 718 719 721 722 724 725 /* * Find an empty file descriptor entry. This is the kernel 2.

The fd array can only hold 32 (NR_OPEN_DEFAULT) file pointers initially. 759 FD_CLR(fd. 761 #if 1 762 /* Sanity check */ 763 if (files->fd[fd] != NULL) { 764 printk(KERN_WARNING "get_unused_fd:slot %d not NULL!\n". 765 files->fd[fd] = NULL.  746 /* 747 * Check whether we need to expand the fd array. 760 files->next_fd = fd + 1. 748 */ 749 if (fd >= files->max_fds) { 750 error = expand_fd_array(files. 758 FD_SET(fd. files->open_fds). files->close_on_exec). 766 } 767 #endif 768 error = fd. 770 out: 771 write_unlock(&files->file_lock). 772 return error.  but it may also be  expanded. fd). 753 goto repeat. 751 if (!error) { 752 error = -EMFILE. 773 } 51 . 754 } 755 goto out.fd). 756 } The FD_SET and FD_CLR macros set or clear the bit indexed by fd in the specified arrays.

The fd_install() function The fd_install() function is defined in include/linux/file. At any such point. 1070 fdt = files_fdtable(files). we are vulnerable to a dup2() race installing a file in the array before us. We need to detect this and fput() the struct file we are about to overwrite in this case.'' The code indicates that the latter comment is actually in effect here. The comment: ``The VFS is full of places where we drop the files lock between setting the open_fds bitmap and installing the file pointer in the file array. 1071 BUG_ON(fdt->fd[fd] != NULL).'' seems to be in conflict with the following statement: ``It should never happen .   Potential race conditions exist here and are described in a contridictory way in comments  at the beginning of the function.if we allow dup2() do it. 1069 spin_lock(&files->file_lock). it sets the new file structure in the  fd_array. _really_ bad things will follow. 1073 spin_unlock(&files->file_lock). 1068 struct fdtable *fdt. file).h.  If the target slot in the files­>fd   array is occupied at the time of the call a system crash will be requested by BUG(). 1074 } 1075 52 . struct file * file) 1066 { 1067 struct files_struct *files = current->files. 1064 1065 void fastcall fd_install(unsigned int fd. 1072 rcu_assign_pointer(fdt->fd[fd].