CLEANUP: fix inconsistency between fd->iocb, proto->accept and accept()

There's quite some inconsistency in the internal API. listener_accept()
which is the main accept() function returns void but is declared as int
in the include file. It's assigned to proto->accept() for all stream
protocols where an int is expected but the result is never checked (nor
is it documented by the way). This proto->accept() is in turn assigned
to fd->iocb() which is supposed to return an int composed of FD_WAIT_*
flags, but which is never checked either.

So let's fix all this mess :
  - nobody checks accept()'s return
  - nobody checks iocb()'s return
  - nobody sets a return value

=> let's mark all these functions void and keep the current ones intact.

Additionally we now include listener.h from listener.c to ensure we won't
silently hide this incoherency in the future.

Note that this patch could/should be backported to 1.6 and even 1.5 to
simplify debugging sessions.

include/proto/connection.h

@@ -35,9 +35,9 @@ extern struct pool_head *pool2_connection;
 int init_connection();
 
 /* I/O callback for fd-based connections. It calls the read/write handlers
- * provided by the connection's sock_ops. Returns 0.
+ * provided by the connection's sock_ops.
  */
-int conn_fd_handler(int fd);
+void conn_fd_handler(int fd);
 
 /* receive a PROXY protocol header over a connection */
 int conn_recv_proxy(struct connection *conn, int flag);

include/proto/listener.h

@@ -105,7 +105,7 @@ void delete_listener(struct listener *listener);
  * to an accept. It tries to accept as many connections as possible, and for each
  * calls the listener's accept handler (generally the frontend's accept handler).
  */
-int listener_accept(int fd);
+void listener_accept(int fd);
 
 /*
  * Registers the bind keyword list <kwl> as a list of valid keywords for next

include/proto/proto_udp.h

@@ -22,6 +22,6 @@
 #ifndef _PROTO_PROTO_UDP_H
 #define _PROTO_PROTO_UDP_H
 
-int dgram_fd_handler(int);
+void dgram_fd_handler(int);
 
 #endif // _PROTO_PROTO_UDP_H

include/types/fd.h

@@ -78,7 +78,7 @@ enum fd_states {
 
 /* info about one given fd */
 struct fdtab {
-	int (*iocb)(int fd);                 /* I/O handler, returns FD_WAIT_* */
+	void (*iocb)(int fd);                /* I/O handler */
 	void *owner;                         /* the connection or listener associated with this fd, NULL if closed */
 	unsigned int  cache;                 /* position+1 in the FD cache. 0=not in cache. */
 	unsigned char state;                 /* FD state for read and write directions (2*3 bits) */

include/types/protocol.h

@@ -50,7 +50,7 @@ struct protocol {
 	sa_family_t sock_family;			/* socket family, for sockaddr */
 	socklen_t sock_addrlen;				/* socket address length, used by bind() */
 	int l3_addrlen;					/* layer3 address length, used by hashes */
-	int (*accept)(int fd);				/* generic accept function */
+	void (*accept)(int fd);				/* generic accept function */
 	int (*bind)(struct listener *l, char *errmsg, int errlen); /* bind a listener */
 	int (*bind_all)(struct protocol *proto, char *errmsg, int errlen); /* bind all unbound listeners */
 	int (*unbind_all)(struct protocol *proto);	/* unbind all bound listeners */

src/connection.c

@@ -36,15 +36,15 @@ int init_connection()
 }
 
 /* I/O callback for fd-based connections. It calls the read/write handlers
- * provided by the connection's sock_ops, which must be valid. It returns 0.
+ * provided by the connection's sock_ops, which must be valid.
  */
-int conn_fd_handler(int fd)
+void conn_fd_handler(int fd)
 {
 	struct connection *conn = fdtab[fd].owner;
 	unsigned int flags;
 
 	if (unlikely(!conn))
-		return 0;
+		return;
 
 	conn_refresh_polling_flags(conn);
 	flags = conn->flags & ~CO_FL_ERROR; /* ensure to call the wake handler upon error */
@@ -86,7 +86,7 @@ int conn_fd_handler(int fd)
 	 * we must not use it anymore and should immediately leave instead.
 	 */
 	if ((conn->flags & CO_FL_INIT_DATA) && conn->data->init(conn) < 0)
-		return 0;
+		return;
 
 	/* The data transfer starts here and stops on error and handshakes. Note
 	 * that we must absolutely test conn->xprt at each step in case it suddenly
@@ -133,7 +133,7 @@ int conn_fd_handler(int fd)
 	if ((conn->flags & CO_FL_WAKE_DATA) &&
 	    ((conn->flags ^ flags) & CO_FL_CONN_STATE) &&
 	    conn->data->wake(conn) < 0)
-		return 0;
+		return;
 
 	/* Last check, verify if the connection just established */
 	if (unlikely(!(conn->flags & (CO_FL_WAIT_L4_CONN | CO_FL_WAIT_L6_CONN | CO_FL_CONNECTED))))
@@ -144,7 +144,7 @@ int conn_fd_handler(int fd)
 
 	/* commit polling changes */
 	conn_cond_update_polling(conn);
-	return 0;
+	return;
 }
 
 /* Update polling on connection <c>'s file descriptor depending on its current

src/listener.c

@@ -32,6 +32,7 @@
 #include <proto/fd.h>
 #include <proto/freq_ctr.h>
 #include <proto/log.h>
+#include <proto/listener.h>
 #include <proto/sample.h>
 #include <proto/stream.h>
 #include <proto/task.h>

src/proto_udp.c

@@ -17,17 +17,17 @@
 #include <proto/fd.h>
 
 /* datagram handler callback */
-int dgram_fd_handler(int fd)
+void dgram_fd_handler(int fd)
 {
 	struct dgram_conn *dgram = fdtab[fd].owner;
 
 	if (unlikely(!dgram))
-		return 0;
+		return;
 
 	if (fd_recv_ready(fd))
 		dgram->data->recv(dgram);
 	else if (fd_send_ready(fd))
 		dgram->data->send(dgram);
 
-	return 0;
+	return;
 }