Very Computer

Earlier this week I posted a question concerning a server process that had
to be connected to twice by the client to get read()s and write()s going
properly. Andrerw Gierth was kind enough to respond with a couple of
suggestions that ultimately led me to find out what was wrong, but now I want
to know why!

Here is what happens:
the client  connect()s with the server,
the server accept()s the client,
the server does a read( client_sock...) returns 0 && errno = 0,
the server does a write to the client,
the server goes into another read( client_sock, ... ) returns 0 && errno = EBADFthe server returns to accept() loop,
I SIGQUIT the client,
Immediately re-invoke the client, and connect successfully until the client
        ends the session.

This behaviour is the same when I telnet to the host and port. First time
nada, second time the read()s and write()s go as expected.

To correct this behaviour I changed the line of code that had my accept()
statement:
OLD-> if ( client = accept( server_sock, ...  ) == -1 )
         take care of error;
      else
             continue on fork() child to handle session...

NEW->  client = accept( server_sock, ... );
           if ( client == -1 )
                  take care of error
       else
          continue on, fork() child to handle session...

Why doesn't it work the first time in the composite if() statement? I have
had one answer so far that suspected this was an artifact of compiler
optimization. The platforms this code has run on are DEC Alphas, and a
Pentium and 486x running different flavors of Solaris 2.x.

Thanks,
KFW
-

-
sig schmig

 Kevin> Earlier this week I posted a question concerning a server
 Kevin> process that had to be connected to twice by the client to get
 Kevin> read()s and write()s going properly. Andrerw Gierth was kind
 Kevin> enough to respond with a couple of suggestions that ultimately
 Kevin> led me to find out what was wrong, but now I want to know why!

And here I am again...

 Kevin> [snip]

 Kevin> To correct this behaviour I changed the line of code that had my
 Kevin> accept() statement:

 OLD-> if ( client = accept( server_sock, ...  ) == -1 )
            ^                                  ^
            \- need brackets around this bit --/

This is the error known as the 'precedence screw'. The assignment operators
have very low precedence, so the above expression is equivalent to:

            client = (accept(...) == -1)

which will set client to 1 if the accept fails, and 0 if it succeeded.

You were finding that the *second* connection worked because:

First accept:
  accept returns a new socket
  client gets set to 0 (standard input)
  read fails
  you close descriptor 0
Second accept:
  accept returns 0 as the new socket (first available FD)
  client gets set to 0
  everything works...

Hope this clarifies things...

--

"Ceterum censeo Microsoftam delendam esse" - Alain Knaff in nanam