Zero-length write() does not generate a datagram on connected socket

RFC In review Stephen Hemminger 6 participants 8 messages Sep 24, 2007 – Sep 28, 2007 2 messages not in the archive

Subsystems (3)

Networking Network drivers Sockets

lore

Share & tools

lore

A message that is not in the archive (sent off-list or not yet received): [email protected]/

A message that is not in the archive (sent off-list or not yet received): [email protected]

Stephen Hemminger

author

2007-09-24 22:35 UTC #2 lore raw

RFC 1/1 Zero-length write() does not generate a datagram on connected socket

The bug http://bugzilla.kernel.org/show_bug.cgi?id=5731
describes an issue where write() can't be used to generate a zero-length datagram (but send, and sendto do work).

I think the following is needed:

net/socket.c +5 -2

@@ -777,8 +777,11 @@ static ssize_t sock_aio_write(struct kio
 	if (pos != 0)
 		return -ESPIPE;
 
-	if (iocb->ki_left == 0)	/* Match SYS5 behaviour */
-		return 0;
+	if (unlikely(iocb->ki_left == 0)) {
+		struct socket *sock = iocb->ki_filp->private_data;
+		if (sock->type == SOCK_STREAM)
+			return 0;
+	}
 
 	x = alloc_sock_iocb(iocb, &siocb);
 	if (!x)

Herbert Xu

2007-09-26 03:18 UTC #3 lore raw

Quoted 9 lines · Stephen Hemminger

The bug http://bugzilla.kernel.org/show_bug.cgi?id=5731
describes an issue where write() can't be used to generate a zero-length datagram (but send, and sendto do work).
I think the following is needed:

net/socket.c 2007-09-24 15:31:25.000000000 -0700 static ssize_t sock_aio_write(struct kio · line 784

Quoted 10 lines

net/socket.c 2007-09-24 15:31:25.000000000 -0700 renamed from net/socket.c 2007-08-20 09:54:28.000000000 -0700 +5 -2

@@ -777,8 +777,11 @@ static ssize_t sock_aio_write(struct kio
       if (pos != 0)
               return -ESPIPE;
 
-       if (iocb->ki_left == 0) /* Match SYS5 behaviour */
-               return 0;
+       if (unlikely(iocb->ki_left == 0)) {
+               struct socket *sock = iocb->ki_filp->private_data;
+               if (sock->type == SOCK_STREAM)
+                       return 0;
+       }

I'm not sure whether all STREAM protocols treat zero-length sends as no-ops. What about SCTP?

Put it another way, do we really need to keep the short-circuit for SOCK_STREAM?

Cheers,

Signature · 4 lines

Visit Openswan at http://www.openswan.org/
Email: Herbert Xu ~{PmV>HI~} <[email protected]>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt

Stephen Hemminger

author

2007-09-26 05:37 UTC #4 lore raw

Quoted 24 lines · On Wed, 26 Sep 2007 11:18:39 +0800 Herbert Xu <[email protected]>…

Quoted 9 lines · Stephen Hemminger
The bug http://bugzilla.kernel.org/show_bug.cgi?id=5731
describes an issue where write() can't be used to generate a zero-length datagram (but send, and sendto do work).
I think the following is needed:
net/socket.c 2007-09-24 15:31:25.000000000 -0700 static ssize_t sock_aio_write(struct kio · line 784
Quoted 10 lines
net/socket.c 2007-09-24 15:31:25.000000000 -0700 renamed from net/socket.c 2007-08-20 09:54:28.000000000 -0700 +5 -2
@@ -777,8 +777,11 @@ static ssize_t sock_aio_write(struct kio
       if (pos != 0)
               return -ESPIPE;
 
-       if (iocb->ki_left == 0) /* Match SYS5 behaviour */
-               return 0;
+       if (unlikely(iocb->ki_left == 0)) {
+               struct socket *sock = iocb->ki_filp->private_data;
+               if (sock->type == SOCK_STREAM)
+                       return 0;
+       }
I'm not sure whether all STREAM protocols treat zero-length sends as no-ops. What about SCTP?

Quoted 4 lines

Put it another way, do we really need to keep the short-circuit for SOCK_STREAM?
Cheers,

Stream is defined as sequence of bytes. So short circuit makes sense If the application wants message boundaries it needs to use SOCK_SEQPACKET. I was paranoid about possible breakage in TCP or SCTP. But since send(s, buf, 0, 0) already filters through, I guess it doesn't matter.

Signature · 1 line

Stephen Hemminger <[email protected]>

Rick Jones

2007-09-26 17:17 UTC #5 lore raw

In reply to Herbert Xu

Quoted 14 lines · Herbert Xu

Quoted 12 lines · Stephen Hemminger
The bug http://bugzilla.kernel.org/show_bug.cgi?id=5731
describes an issue where write() can't be used to generate a zero-length datagram (but send, and sendto do work).
I think the following is needed:
net/socket.c 2007-09-24 15:31:25.000000000 -0700 renamed from net/socket.c 2007-08-20 09:54:28.000000000 -0700 +0 -0
@@ -777,8 +777,11 @@ static ssize_t sock_aio_write(struct kio
      if (pos != 0)
              return -ESPIPE;
 

Quoted 11 lines

net/socket.c 2007-09-24 15:31:25.000000000 -0700 static ssize_t sock_aio_write(struct kio · line 784
Quoted 7 lines
net/socket.c 2007-09-24 15:31:25.000000000 -0700 renamed from net/socket.c 2007-08-20 09:54:28.000000000 -0700 +5 -2
-       if (iocb->ki_left == 0) /* Match SYS5 behaviour */
-               return 0;
+       if (unlikely(iocb->ki_left == 0)) {
+               struct socket *sock = iocb->ki_filp->private_data;
+               if (sock->type == SOCK_STREAM)
+                       return 0;
+       }
I'm not sure whether all STREAM protocols treat zero-length sends as no-ops. What about SCTP?

I asked Vlad that very question, since SCTP can preserve message boundaries. He tells me that a zero-length message is not part of SCTP.

rick jones

Vlad Yasevich

2007-09-26 18:47 UTC #6 lore raw

In reply to Herbert Xu

Quoted 13 lines · Herbert Xu

Quoted 12 lines · Stephen Hemminger
The bug http://bugzilla.kernel.org/show_bug.cgi?id=5731
describes an issue where write() can't be used to generate a zero-length datagram (but send, and sendto do work).
I think the following is needed:
net/socket.c 2007-09-24 15:31:25.000000000 -0700 renamed from net/socket.c 2007-08-20 09:54:28.000000000 -0700 +0 -0
@@ -777,8 +777,11 @@ static ssize_t sock_aio_write(struct kio
       if (pos != 0)
               return -ESPIPE;
 

Quoted 10 lines

net/socket.c 2007-09-24 15:31:25.000000000 -0700 static ssize_t sock_aio_write(struct kio · line 784
Quoted 7 lines
net/socket.c 2007-09-24 15:31:25.000000000 -0700 renamed from net/socket.c 2007-08-20 09:54:28.000000000 -0700 +5 -2
-       if (iocb->ki_left == 0) /* Match SYS5 behaviour */
-               return 0;
+       if (unlikely(iocb->ki_left == 0)) {
+               struct socket *sock = iocb->ki_filp->private_data;
+               if (sock->type == SOCK_STREAM)
+                       return 0;
+       }
I'm not sure whether all STREAM protocols treat zero-length sends as no-ops. What about SCTP?

0 byte writes are not allowed in SCTP. A no-op is fine, otherwise SCTP would return an error.

-vlad

Quoted 5 lines

Put it another way, do we really need to keep the short-circuit for SOCK_STREAM?
Cheers,

David Miller

maintainer

2007-09-27 20:53 UTC #7 lore raw

In reply to Stephen Hemminger

From: Stephen Hemminger <[email protected]>
Date: Mon, 24 Sep 2007 15:34:35 -0700

Quoted 12 lines

The bug http://bugzilla.kernel.org/show_bug.cgi?id=5731
describes an issue where write() can't be used to generate a zero-length datagram (but send, and sendto do work).
I think the following is needed:
net/socket.c +0 -0
@@ -777,8 +777,11 @@ static ssize_t sock_aio_write(struct kio
 	if (pos != 0)
 		return -ESPIPE;
 

net/socket.c static ssize_t sock_aio_write(struct kio · line 787

Quoted 10 lines

net/socket.c +5 -2

-	if (iocb->ki_left == 0)	/* Match SYS5 behaviour */
-		return 0;
+	if (unlikely(iocb->ki_left == 0)) {
+		struct socket *sock = iocb->ki_filp->private_data;
+		if (sock->type == SOCK_STREAM)
+			return 0;
+	}
 
 	x = alloc_sock_iocb(iocb, &siocb);
 	if (!x)

We should simply remove the check completely.

There is no need to add special code for different types of protocols and sockets.

As is hinted in the bugzilla, the exact same thing can happen with a suitably constructed sendto() or sendmsg() call. write() on a socket is a sendmsg() with a NULL msg_control and a single entry iovec, plain and simple.

It's how BSD and many other systems behave, and I double checked Steven's Volume 2 just to make sure.

So I'm going to check in the following to fix this bugzilla. There is a similarly ugly test for len==0 in sys_read() on sockets. If someone would do some research on the validity of that thing I'd really appreciate it :-)

net/socket.c +0 -3

index 7d44453..b09eb90 100644
@@ -777,9 +777,6 @@ static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov,
 	if (pos != 0)
 		return -ESPIPE;
 
-	if (iocb->ki_left == 0)	/* Match SYS5 behaviour */
-		return 0;
-
 	x = alloc_sock_iocb(iocb, &siocb);
 	if (!x)
 		return -ENOMEM;

Stephen Hemminger

author

2007-09-27 22:41 UTC #8 lore raw

Quoted 36 lines · On Thu, 27 Sep 2007 13:53:34 -0700 (PDT) David Miller <[email protected]>…

From: Stephen Hemminger <[email protected]>
Date: Mon, 24 Sep 2007 15:34:35 -0700
Quoted 12 lines
The bug http://bugzilla.kernel.org/show_bug.cgi?id=5731
describes an issue where write() can't be used to generate a zero-length datagram (but send, and sendto do work).
I think the following is needed:
net/socket.c +0 -0
@@ -777,8 +777,11 @@ static ssize_t sock_aio_write(struct kio
 	if (pos != 0)
 		return -ESPIPE;
 
net/socket.c static ssize_t sock_aio_write(struct kio · line 787
Quoted 10 lines
net/socket.c +5 -2
-	if (iocb->ki_left == 0)	/* Match SYS5 behaviour */
-		return 0;
+	if (unlikely(iocb->ki_left == 0)) {
+		struct socket *sock = iocb->ki_filp->private_data;
+		if (sock->type == SOCK_STREAM)
+			return 0;
+	}
 
 	x = alloc_sock_iocb(iocb, &siocb);
 	if (!x)
We should simply remove the check completely.
There is no need to add special code for different types of protocols and sockets.
As is hinted in the bugzilla, the exact same thing can happen with a suitably constructed sendto() or sendmsg() call. write() on a socket is a sendmsg() with a NULL msg_control and a single entry iovec, plain and simple.

Quoted 7 lines

It's how BSD and many other systems behave, and I double checked Steven's Volume 2 just to make sure.
So I'm going to check in the following to fix this bugzilla. There is a similarly ugly test for len==0 in sys_read() on sockets. If someone would do some research on the validity of that thing I'd really appreciate it :-)

Read of zero length should be a no-op for SOCK_STREAM but for SOCK_DATAGRAM or SOCK_SEQPACKET it might be useful as a remote wait for event.

Signature · 1 line

Stephen Hemminger <[email protected]>

Michael Kerrisk

2007-09-28 08:49 UTC #9 lore raw

Quoted 42 lines · Stephen Hemminger

Quoted 39 lines · On Thu, 27 Sep 2007 13:53:34 -0700 (PDT) David Miller <[email protected]>…
From: Stephen Hemminger <[email protected]>
Date: Mon, 24 Sep 2007 15:34:35 -0700
Quoted 12 lines
The bug http://bugzilla.kernel.org/show_bug.cgi?id=5731
describes an issue where write() can't be used to generate a zero-length datagram (but send, and sendto do work).
I think the following is needed:
net/socket.c 2007-09-24 15:31:25.000000000 -0700 renamed from net/socket.c 2007-08-20 09:54:28.000000000 -0700 +0 -0
@@ -777,8 +777,11 @@ static ssize_t sock_aio_write(struct kio
    if (pos != 0)
            return -ESPIPE;
 
net/socket.c 2007-09-24 15:31:25.000000000 -0700 static ssize_t sock_aio_write(struct kio · line 787
Quoted 10 lines
net/socket.c 2007-09-24 15:31:25.000000000 -0700 renamed from net/socket.c 2007-08-20 09:54:28.000000000 -0700 +5 -2
-   if (iocb->ki_left == 0) /* Match SYS5 behaviour */
-           return 0;
+   if (unlikely(iocb->ki_left == 0)) {
+           struct socket *sock = iocb->ki_filp->private_data;
+           if (sock->type == SOCK_STREAM)
+                   return 0;
+   }
 
    x = alloc_sock_iocb(iocb, &siocb);
    if (!x)
We should simply remove the check completely.
There is no need to add special code for different types of protocols and sockets.
As is hinted in the bugzilla, the exact same thing can happen with a suitably constructed sendto() or sendmsg() call. write() on a socket is a sendmsg() with a NULL msg_control and a single entry iovec, plain and simple.
It's how BSD and many other systems behave, and I double checked Steven's Volume 2 just to make sure.

Quoted 8 lines

Quoted 4 lines
So I'm going to check in the following to fix this bugzilla. There is a similarly ugly test for len==0 in sys_read() on sockets. If someone would do some research on the validity of that thing I'd really appreciate it :-)
Read of zero length should be a no-op for SOCK_STREAM but for SOCK_DATAGRAM or SOCK_SEQPACKET it might be useful as a remote wait for event.

Hmm -- I hadn't checked the behavior for zero-length read() on other systems. i will try to do that soonish (probably only Minday or so).

Cheers,

Michael