diff mbox

[v5,2/2] net: add the support for -netdev socket, listen

Message ID 1339080860-16036-1-git-send-email-zwu.kernel@gmail.com
State New
Headers show

Commit Message

Zhiyong Wu June 7, 2012, 2:54 p.m. UTC 
From: Zhi Yong Wu <wuzhy@linux.vnet.ibm.com>

The -net socket,listen option does not work with the newer -netdev
syntax:
 http://lists.gnu.org/archive/html/qemu-devel/2011-11/msg01508.html

This patch makes it work now.

For the case where one vlan has multiple listenning sockets,
the patch will also provide the support.

Supported syntax:
 1.) -net socket,listen=127.0.0.1:1234,vlan=0
 2.) -net socket,listen=127.0.0.1:1234,vlan=0 -net socket,listen=127.0.0.1:1235,vlan=0
 3.) -netdev socket,listen=127.0.0.1:1234,id=socket0

Changelog from v4:
 Adopted the suggestion from stefan [stefan]

 Drop the NetSocketListenState struct and add a listen_fd field
to NetSocketState.  When a -netdev socket,listen= instance is created
there will be a NetSocketState with fd=-1 and a valid listen_fd.  The
net_socket_accept() handler waits for listen_fd to become readable and
then accepts the connection.  When this state transition happens, we no
longer monitor listen_fd for incoming connections...until the client
disconnects again.

Suggested-by: Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
Signed-off-by: Zhi Yong Wu <wuzhy@linux.vnet.ibm.com>
---
 net/socket.c |   58 +++++++++++++++++++++++++++++++---------------------------
 1 files changed, 31 insertions(+), 27 deletions(-)

Comments

Stefan Hajnoczi June 8, 2012, 10:31 a.m. UTC | #1 
On Thu, Jun 7, 2012 at 3:54 PM,  <zwu.kernel@gmail.com> wrote:
> @@ -86,7 +82,16 @@ static void net_socket_send(void *opaque)
>         /* end of connection */
>     eoc:
>         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
> +        qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);

What happens when this is not a listen socket?  I suggest setting
listen_fd to -1 during creation and not calling qemu_set_fd_handler()
when listen_fd is -1 here.  If listen_fd is 0 then we'll register
net_socket_accept when standard input becomes ready!

>         closesocket(s->fd);
> +
> +        s->fd = 0;

-1 should be used since 0 is a valid file descriptor (standard input).

Stefan
Zhiyong Wu June 8, 2012, 2:15 p.m. UTC | #2 
On Fri, Jun 8, 2012 at 6:31 PM, Stefan Hajnoczi <stefanha@gmail.com> wrote:
> On Thu, Jun 7, 2012 at 3:54 PM,  <zwu.kernel@gmail.com> wrote:
>> @@ -86,7 +82,16 @@ static void net_socket_send(void *opaque)
>>         /* end of connection */
>>     eoc:
>>         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
>> +        qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
>
> What happens when this is not a listen socket?  I suggest setting
> listen_fd to -1 during creation and not calling qemu_set_fd_handler()
listen_fd isn't -1 here, and is one valid value when this function is executed.
> when listen_fd is -1 here.  If listen_fd is 0 then we'll register
> net_socket_accept when standard input becomes ready!
>
>>         closesocket(s->fd);
>> +
>> +        s->fd = 0;
>
> -1 should be used since 0 is a valid file descriptor (standard input).
OK. done, but In fact, some other places default fd to zero.
>
> Stefan
>
Stefan Hajnoczi June 8, 2012, 2:20 p.m. UTC | #3 
On Fri, Jun 8, 2012 at 3:15 PM, Zhi Yong Wu <zwu.kernel@gmail.com> wrote:
> On Fri, Jun 8, 2012 at 6:31 PM, Stefan Hajnoczi <stefanha@gmail.com> wrote:
>> On Thu, Jun 7, 2012 at 3:54 PM,  <zwu.kernel@gmail.com> wrote:
>>> @@ -86,7 +82,16 @@ static void net_socket_send(void *opaque)
>>>         /* end of connection */
>>>     eoc:
>>>         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
>>> +        qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
>>
>> What happens when this is not a listen socket?  I suggest setting
>> listen_fd to -1 during creation and not calling qemu_set_fd_handler()
> listen_fd isn't -1 here, and is one valid value when this function is executed.
>> when listen_fd is -1 here.  If listen_fd is 0 then we'll register
>> net_socket_accept when standard input becomes ready!
>>
>>>         closesocket(s->fd);
>>> +
>>> +        s->fd = 0;
>>
>> -1 should be used since 0 is a valid file descriptor (standard input).
> OK. done, but In fact, some other places default fd to zero.

Where?  Maybe those places need to be fixed too.  The danger with fd=0
is that we call functions like read()/write()/close() on standard
input by mistake.

Stefan
Zhiyong Wu June 8, 2012, 2:34 p.m. UTC | #4 
On Fri, Jun 8, 2012 at 10:20 PM, Stefan Hajnoczi <stefanha@gmail.com> wrote:
> On Fri, Jun 8, 2012 at 3:15 PM, Zhi Yong Wu <zwu.kernel@gmail.com> wrote:
>> On Fri, Jun 8, 2012 at 6:31 PM, Stefan Hajnoczi <stefanha@gmail.com> wrote:
>>> On Thu, Jun 7, 2012 at 3:54 PM,  <zwu.kernel@gmail.com> wrote:
>>>> @@ -86,7 +82,16 @@ static void net_socket_send(void *opaque)
>>>>         /* end of connection */
>>>>     eoc:
>>>>         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
>>>> +        qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
>>>
>>> What happens when this is not a listen socket?  I suggest setting
>>> listen_fd to -1 during creation and not calling qemu_set_fd_handler()
>> listen_fd isn't -1 here, and is one valid value when this function is executed.
>>> when listen_fd is -1 here.  If listen_fd is 0 then we'll register
>>> net_socket_accept when standard input becomes ready!
>>>
>>>>         closesocket(s->fd);
>>>> +
>>>> +        s->fd = 0;
>>>
>>> -1 should be used since 0 is a valid file descriptor (standard input).
>> OK. done, but In fact, some other places default fd to zero.
>
> Where?  Maybe those places need to be fixed too.  The danger with fd=0
In qemu_new_net_client(), you can see "vc = g_malloc0(info->size);".
If it will create one socket net client, it will default fd to zero.

> is that we call functions like read()/write()/close() on standard
> input by mistake.
>
> Stefan
Zhiyong Wu June 8, 2012, 2:46 p.m. UTC | #5 
On Fri, Jun 8, 2012 at 10:20 PM, Stefan Hajnoczi <stefanha@gmail.com> wrote:
> On Fri, Jun 8, 2012 at 3:15 PM, Zhi Yong Wu <zwu.kernel@gmail.com> wrote:
>> On Fri, Jun 8, 2012 at 6:31 PM, Stefan Hajnoczi <stefanha@gmail.com> wrote:
>>> On Thu, Jun 7, 2012 at 3:54 PM,  <zwu.kernel@gmail.com> wrote:
>>>> @@ -86,7 +82,16 @@ static void net_socket_send(void *opaque)
>>>>         /* end of connection */
>>>>     eoc:
>>>>         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
>>>> +        qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
>>>
>>> What happens when this is not a listen socket?  I suggest setting
>>> listen_fd to -1 during creation and not calling qemu_set_fd_handler()
>> listen_fd isn't -1 here, and is one valid value when this function is executed.
>>> when listen_fd is -1 here.  If listen_fd is 0 then we'll register
>>> net_socket_accept when standard input becomes ready!
>>>
>>>>         closesocket(s->fd);
>>>> +
>>>> +        s->fd = 0;
>>>
>>> -1 should be used since 0 is a valid file descriptor (standard input).
>> OK. done, but In fact, some other places default fd to zero.
>
> Where?  Maybe those places need to be fixed too.  The danger with fd=0
> is that we call functions like read()/write()/close() on standard
> input by mistake.
When net_socket_accept() is registered, fd/listen_fd has been not zero
in our codes. So that case you said will not happen for our codes.
>
> Stefan
Zhiyong Wu June 8, 2012, 2:54 p.m. UTC | #6 
On Fri, Jun 8, 2012 at 6:31 PM, Stefan Hajnoczi <stefanha@gmail.com> wrote:
> On Thu, Jun 7, 2012 at 3:54 PM,  <zwu.kernel@gmail.com> wrote:
>> @@ -86,7 +82,16 @@ static void net_socket_send(void *opaque)
>>         /* end of connection */
>>     eoc:
>>         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
>> +        qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
>
> What happens when this is not a listen socket?  I suggest setting
> listen_fd to -1 during creation and not calling qemu_set_fd_handler()
> when listen_fd is -1 here.  If listen_fd is 0 then we'll register
> net_socket_accept when standard input becomes ready!
>
>>         closesocket(s->fd);
>> +
>> +        s->fd = 0;
>
> -1 should be used since 0 is a valid file descriptor (standard input).
I think that s->fd = 0 doesn't cause every issue. When it is zero,
this fd hasn't been registered with every handler. You can see that
"qemu_set_fd_handler(s->fd, NULL, NULL, NULL);" before "s->fd = 0".

>
> Stefan
>
Stefan Hajnoczi June 8, 2012, 3:59 p.m. UTC | #7 
On Fri, Jun 8, 2012 at 3:54 PM, Zhi Yong Wu <zwu.kernel@gmail.com> wrote:
> On Fri, Jun 8, 2012 at 6:31 PM, Stefan Hajnoczi <stefanha@gmail.com> wrote:
>> On Thu, Jun 7, 2012 at 3:54 PM,  <zwu.kernel@gmail.com> wrote:
>>> @@ -86,7 +82,16 @@ static void net_socket_send(void *opaque)
>>>         /* end of connection */
>>>     eoc:
>>>         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
>>> +        qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
>>
>> What happens when this is not a listen socket?  I suggest setting
>> listen_fd to -1 during creation and not calling qemu_set_fd_handler()
>> when listen_fd is -1 here.  If listen_fd is 0 then we'll register
>> net_socket_accept when standard input becomes ready!
>>
>>>         closesocket(s->fd);
>>> +
>>> +        s->fd = 0;
>>
>> -1 should be used since 0 is a valid file descriptor (standard input).
> I think that s->fd = 0 doesn't cause every issue. When it is zero,
> this fd hasn't been registered with every handler. You can see that
> "qemu_set_fd_handler(s->fd, NULL, NULL, NULL);" before "s->fd = 0".

If s->fd = 0 because we are still listening and net_socket_cleanup()
is called we will close() standard input.

Stefan
Zhiyong Wu June 9, 2012, 2:09 a.m. UTC | #8 
On Fri, Jun 8, 2012 at 11:59 PM, Stefan Hajnoczi <stefanha@gmail.com> wrote:
> On Fri, Jun 8, 2012 at 3:54 PM, Zhi Yong Wu <zwu.kernel@gmail.com> wrote:
>> On Fri, Jun 8, 2012 at 6:31 PM, Stefan Hajnoczi <stefanha@gmail.com> wrote:
>>> On Thu, Jun 7, 2012 at 3:54 PM,  <zwu.kernel@gmail.com> wrote:
>>>> @@ -86,7 +82,16 @@ static void net_socket_send(void *opaque)
>>>>         /* end of connection */
>>>>     eoc:
>>>>         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
>>>> +        qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
>>>
>>> What happens when this is not a listen socket?  I suggest setting
>>> listen_fd to -1 during creation and not calling qemu_set_fd_handler()
>>> when listen_fd is -1 here.  If listen_fd is 0 then we'll register
>>> net_socket_accept when standard input becomes ready!
>>>
>>>>         closesocket(s->fd);
>>>> +
>>>> +        s->fd = 0;
>>>
>>> -1 should be used since 0 is a valid file descriptor (standard input).
>> I think that s->fd = 0 doesn't cause every issue. When it is zero,
>> this fd hasn't been registered with every handler. You can see that
>> "qemu_set_fd_handler(s->fd, NULL, NULL, NULL);" before "s->fd = 0".
>
> If s->fd = 0 because we are still listening and net_socket_cleanup()
OK, done. any other issue?
> is called we will close() standard input.
>
> Stefan
Stefan Hajnoczi June 11, 2012, 9:01 a.m. UTC | #9 
On Sat, Jun 09, 2012 at 10:09:44AM +0800, Zhi Yong Wu wrote:
> On Fri, Jun 8, 2012 at 11:59 PM, Stefan Hajnoczi <stefanha@gmail.com> wrote:
> > On Fri, Jun 8, 2012 at 3:54 PM, Zhi Yong Wu <zwu.kernel@gmail.com> wrote:
> >> On Fri, Jun 8, 2012 at 6:31 PM, Stefan Hajnoczi <stefanha@gmail.com> wrote:
> >>> On Thu, Jun 7, 2012 at 3:54 PM,  <zwu.kernel@gmail.com> wrote:
> >>>> @@ -86,7 +82,16 @@ static void net_socket_send(void *opaque)
> >>>>         /* end of connection */
> >>>>     eoc:
> >>>>         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
> >>>> +        qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
> >>>
> >>> What happens when this is not a listen socket?  I suggest setting
> >>> listen_fd to -1 during creation and not calling qemu_set_fd_handler()
> >>> when listen_fd is -1 here.  If listen_fd is 0 then we'll register
> >>> net_socket_accept when standard input becomes ready!
> >>>
> >>>>         closesocket(s->fd);
> >>>> +
> >>>> +        s->fd = 0;
> >>>
> >>> -1 should be used since 0 is a valid file descriptor (standard input).
> >> I think that s->fd = 0 doesn't cause every issue. When it is zero,
> >> this fd hasn't been registered with every handler. You can see that
> >> "qemu_set_fd_handler(s->fd, NULL, NULL, NULL);" before "s->fd = 0".
> >
> > If s->fd = 0 because we are still listening and net_socket_cleanup()
> OK, done. any other issue?

I haven't seen your new code yet so I'm not sure.  Basically if you have
introduced -1 states for s->fd and s->listen_fd as well as checks before
calling qemu_set_fd_handler() or close(), then the code is fine.

Stefan
diff mbox

Patch

diff --git a/net/socket.c b/net/socket.c
index 7194345..27e8c4e 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -35,6 +35,7 @@ 
 
 typedef struct NetSocketState {
     VLANClientState nc;
+    int listen_fd;
     int fd;
     int state; /* 0 = getting length, 1 = getting data */
     unsigned int index;
@@ -43,12 +44,7 @@  typedef struct NetSocketState {
     struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
 } NetSocketState;
 
-typedef struct NetSocketListenState {
-    VLANState *vlan;
-    char *model;
-    char *name;
-    int fd;
-} NetSocketListenState;
+static void net_socket_accept(void *opaque);
 
 /* XXX: we consider we can send the whole packet without blocking */
 static ssize_t net_socket_receive(VLANClientState *nc, const uint8_t *buf, size_t size)
@@ -86,7 +82,16 @@  static void net_socket_send(void *opaque)
         /* end of connection */
     eoc:
         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
+        qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
         closesocket(s->fd);
+
+        s->fd = 0;
+        s->state = 0;
+        s->index = 0;
+        s->packet_len = 0;
+        memset(s->buf, 0, sizeof(s->buf));
+        memset(s->nc.info_str, 0, sizeof(s->nc.info_str));
+
         return;
     }
     buf = buf1;
@@ -377,27 +382,28 @@  static NetSocketState *net_socket_fd_init(VLANState *vlan,
 
 static void net_socket_accept(void *opaque)
 {
-    NetSocketListenState *s = opaque;
-    NetSocketState *s1;
+    NetSocketState *s = opaque;
     struct sockaddr_in saddr;
     socklen_t len;
     int fd;
 
     for(;;) {
         len = sizeof(saddr);
-        fd = qemu_accept(s->fd, (struct sockaddr *)&saddr, &len);
+        fd = qemu_accept(s->listen_fd, (struct sockaddr *)&saddr, &len);
         if (fd < 0 && errno != EINTR) {
             return;
         } else if (fd >= 0) {
+            qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
             break;
         }
     }
-    s1 = net_socket_fd_init(s->vlan, s->model, s->name, fd, 1);
-    if (s1) {
-        snprintf(s1->nc.info_str, sizeof(s1->nc.info_str),
-                 "socket: connection from %s:%d",
-                 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
-    }
+
+    s->fd = fd;
+    s->nc.link_down = false;
+    net_socket_connect(s);
+    snprintf(s->nc.info_str, sizeof(s->nc.info_str),
+             "socket: connection from %s:%d",
+             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 }
 
 static int net_socket_listen_init(VLANState *vlan,
@@ -405,19 +411,17 @@  static int net_socket_listen_init(VLANState *vlan,
                                   const char *name,
                                   const char *host_str)
 {
-    NetSocketListenState *s;
-    int fd, val, ret;
+    VLANClientState *nc;
+    NetSocketState *s;
     struct sockaddr_in saddr;
+    int fd, val, ret;
 
     if (parse_host_port(&saddr, host_str) < 0)
         return -1;
 
-    s = g_malloc0(sizeof(NetSocketListenState));
-
     fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
     if (fd < 0) {
         perror("socket");
-        g_free(s);
         return -1;
     }
     socket_set_nonblock(fd);
@@ -429,22 +433,22 @@  static int net_socket_listen_init(VLANState *vlan,
     ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
     if (ret < 0) {
         perror("bind");
-        g_free(s);
         closesocket(fd);
         return -1;
     }
     ret = listen(fd, 0);
     if (ret < 0) {
         perror("listen");
-        g_free(s);
         closesocket(fd);
         return -1;
     }
-    s->vlan = vlan;
-    s->model = g_strdup(model);
-    s->name = name ? g_strdup(name) : NULL;
-    s->fd = fd;
-    qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
+
+    nc = qemu_new_net_client(&net_socket_info, vlan, NULL, model, name);
+    s = DO_UPCAST(NetSocketState, nc, nc);
+    s->listen_fd = fd;
+    s->nc.link_down = true;
+
+    qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
     return 0;
 }