/* * SUCS NET3: * * Generic datagram handling routines. These are generic for all protocols. Possibly a generic IP version on top * of these would make sense. Not tonight however 8-). * This is used because UDP, RAW, PACKET, DDP, IPX, AX.25 and NetROM layer all have identical poll code and mostly * identical recvmsg() code. So we share it here. The poll was shared before but buried in udp.c so I moved it. * * Authors: Alan Cox <alan@redhat.com>. (datagram_poll() from old udp.c code) * * Fixes: * Alan Cox : NULL return from skb_peek_copy() understood * Alan Cox : Rewrote skb_read_datagram to avoid the skb_peek_copy stuff. * Alan Cox : Added support for SOCK_SEQPACKET. IPX can no longer use the SO_TYPE hack but * AX.25 now works right, and SPX is feasible. * Alan Cox : Fixed write poll of non IP protocol crash. * Florian La Roche: Changed for my new skbuff handling. * Darryl Miles : Fixed non-blocking SOCK_SEQPACKET. * Linus Torvalds : BSD semantic fixes. * Alan Cox : Datagram iovec handling * Darryl Miles : Fixed non-blocking SOCK_STREAM. * Alan Cox : POSIXisms * Pete Wyckoff : Unconnected accept() fix. * */ #include <linux/types.h> #include <linux/kernel.h> #include <asm/uaccess.h> #include <asm/system.h> #include <linux/mm.h> #include <linux/interrupt.h> #include <linux/in.h> #include <linux/errno.h> #include <linux/sched.h> #include <linux/inet.h> #include <linux/netdevice.h> #include <linux/poll.h> #include <net/ip.h> #include <net/protocol.h> #include <net/route.h> #include <net/tcp.h> #include <net/udp.h> #include <linux/skbuff.h> #include <net/sock.h> /* * Is a socket 'connection oriented' ? */ 53 static inline int connection_based(struct sock *sk) { 55 return (sk->type==SOCK_SEQPACKET || sk->type==SOCK_STREAM); } /* * Wait for a packet.. */ 63 static int wait_for_packet(struct sock * sk, int *err, long *timeo_p) { int error; DECLARE_WAITQUEUE(wait, current); 69 __set_current_state(TASK_INTERRUPTIBLE); add_wait_queue_exclusive(sk->sleep, &wait); /* Socket errors? */ error = sock_error(sk); 74 if (error) 75 goto out; 77 if (!skb_queue_empty(&sk->receive_queue)) 78 goto ready; /* Socket shut down? */ 81 if (sk->shutdown & RCV_SHUTDOWN) 82 goto out; /* Sequenced packets can come disconnected. If so we report the problem */ error = -ENOTCONN; 86 if(connection_based(sk) && !(sk->state==TCP_ESTABLISHED || sk->state==TCP_LISTEN)) 87 goto out; /* handle signals */ 90 if (signal_pending(current)) 91 goto interrupted; *timeo_p = schedule_timeout(*timeo_p); ready: current->state = TASK_RUNNING; remove_wait_queue(sk->sleep, &wait); 98 return 0; interrupted: error = sock_intr_errno(*timeo_p); out: current->state = TASK_RUNNING; remove_wait_queue(sk->sleep, &wait); *err = error; 106 return error; } /* * Get a datagram skbuff, understands the peeking, nonblocking wakeups and possible * races. This replaces identical code in packet,raw and udp, as well as the IPX * AX.25 and Appletalk. It also finally fixes the long standing peek and read * race for datagram sockets. If you alter this routine remember it must be * re-entrant. * * This function will lock the socket if a skb is returned, so the caller * needs to unlock the socket in that case (usually by calling skb_free_datagram) * * * It does not lock socket since today. This function is * * free of race conditions. This measure should/can improve * * significantly datagram socket latencies at high loads, * * when data copying to user space takes lots of time. * * (BTW I've just killed the last cli() in IP/IPv6/core/netlink/packet * * 8) Great win.) * * --ANK (980729) * * The order of the tests when we find no data waiting are specified * quite explicitly by POSIX 1003.1g, don't change them without having * the standard around please. */ 132 struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock, int *err) { int error; struct sk_buff *skb; long timeo; /* Caller is allowed not to check sk->err before skb_recv_datagram() */ error = sock_error(sk); 140 if (error) 141 goto no_packet; timeo = sock_rcvtimeo(sk, noblock); 145 do { /* Again only user level code calls this function, so nothing interrupt level will suddenly eat the receive_queue. Look at current nfs client by the way... However, this function was corrent in any case. 8) */ 152 if (flags & MSG_PEEK) { unsigned long cpu_flags; 156 spin_lock_irqsave(&sk->receive_queue.lock, cpu_flags); skb = skb_peek(&sk->receive_queue); 158 if(skb!=NULL) atomic_inc(&skb->users); 160 spin_unlock_irqrestore(&sk->receive_queue.lock, cpu_flags); 161 } else skb = skb_dequeue(&sk->receive_queue); 164 if (skb) 165 return skb; /* User doesn't want to wait */ error = -EAGAIN; 169 if (!timeo) 170 goto no_packet; 172 } while (wait_for_packet(sk, err, &timeo) == 0); 174 return NULL; no_packet: *err = error; 178 return NULL; } 181 void skb_free_datagram(struct sock * sk, struct sk_buff *skb) { kfree_skb(skb); } /* * Copy a datagram to a linear buffer. */ 190 int skb_copy_datagram(struct sk_buff *skb, int offset, char *to, int size) { int err = -EFAULT; 194 if (!copy_to_user(to, skb->h.raw + offset, size)) err = 0; 196 return err; } /* * Copy a datagram to an iovec. * Note: the iovec is modified during the copy. */ 205 int skb_copy_datagram_iovec(struct sk_buff *skb, int offset, struct iovec *to, int size) { 208 return memcpy_toiovec(to, skb->h.raw + offset, size); } /* * Datagram poll: Again totally generic. This also handles * sequenced packet sockets providing the socket receive queue * is only ever holding data ready to receive. * * Note: when you _don't_ use this routine for this protocol, * and you use a different write policy from sock_writeable() * then please supply your own write_space callback. */ 221 unsigned int datagram_poll(struct file * file, struct socket *sock, poll_table *wait) { struct sock *sk = sock->sk; unsigned int mask; poll_wait(file, sk->sleep, wait); mask = 0; /* exceptional events? */ 230 if (sk->err || !skb_queue_empty(&sk->error_queue)) mask |= POLLERR; 232 if (sk->shutdown == SHUTDOWN_MASK) mask |= POLLHUP; /* readable? */ 236 if (!skb_queue_empty(&sk->receive_queue) || (sk->shutdown&RCV_SHUTDOWN)) mask |= POLLIN | POLLRDNORM; /* Connection-based need to check for termination and startup */ 240 if (connection_based(sk)) { 241 if (sk->state==TCP_CLOSE) mask |= POLLHUP; /* connection hasn't started yet? */ 244 if (sk->state == TCP_SYN_SENT) 245 return mask; } /* writable? */ 249 if (sock_writeable(sk)) mask |= POLLOUT | POLLWRNORM | POLLWRBAND; 251 else set_bit(SOCK_ASYNC_NOSPACE, &sk->socket->flags); 254 return mask; }