+ res = recv (fd, buf, bufsize, MSG_PEEK);
+ while (res == -1 && errno == EINTR);
+ return res;
+}
+
+static void
+sock_close (int fd)
+{
+ close (fd);
+ DEBUGP (("Closed fd %d\n", fd));
+}
+#undef read
+#undef write
+#undef close
+\f
+/* Reading and writing from the network. We build around the socket
+ (file descriptor) API, but support "extended" operations for things
+ that are not mere file descriptors under the hood, such as SSL
+ sockets.
+
+ That way the user code can call fd_read(fd, ...) and we'll run read
+ or SSL_read or whatever is necessary. */
+
+static struct hash_table *transport_map;
+static unsigned int transport_map_modified_tick;
+
+struct transport_info {
+ struct transport_implementation *imp;
+ void *ctx;
+};
+
+/* Register the transport layer operations that will be used when
+ reading, writing, and polling FD.
+
+ This should be used for transport layers like SSL that piggyback on
+ sockets. FD should otherwise be a real socket, on which you can
+ call getpeername, etc. */
+
+void
+fd_register_transport (int fd, struct transport_implementation *imp, void *ctx)
+{
+ struct transport_info *info;
+
+ /* The file descriptor must be non-negative to be registered.
+ Negative values are ignored by fd_close(), and -1 cannot be used as
+ hash key. */
+ assert (fd >= 0);
+
+ info = xnew (struct transport_info);
+ info->imp = imp;
+ info->ctx = ctx;
+ if (!transport_map)
+ transport_map = hash_table_new (0, NULL, NULL);
+ hash_table_put (transport_map, (void *)(intptr_t) fd, info);
+ ++transport_map_modified_tick;
+}
+
+/* Return context of the transport registered with
+ fd_register_transport. This assumes fd_register_transport was
+ previously called on FD. */
+
+void *
+fd_transport_context (int fd)
+{
+ struct transport_info *info = hash_table_get (transport_map, (void *)(intptr_t) fd);
+ return info->ctx;
+}
+
+/* When fd_read/fd_write are called multiple times in a loop, they should
+ remember the INFO pointer instead of fetching it every time. It is
+ not enough to compare FD to LAST_FD because FD might have been
+ closed and reopened. modified_tick ensures that changes to
+ transport_map will not be unnoticed.
+
+ This is a macro because we want the static storage variables to be
+ per-function. */
+
+#define LAZY_RETRIEVE_INFO(info) do { \
+ static struct transport_info *last_info; \
+ static int last_fd = -1; \
+ static unsigned int last_tick; \
+ if (!transport_map) \
+ info = NULL; \
+ else if (last_fd == fd && last_tick == transport_map_modified_tick) \
+ info = last_info; \
+ else \
+ { \
+ info = hash_table_get (transport_map, (void *)(intptr_t) fd); \
+ last_fd = fd; \
+ last_info = info; \
+ last_tick = transport_map_modified_tick; \
+ } \
+} while (0)
+
+static bool
+poll_internal (int fd, struct transport_info *info, int wf, double timeout)
+{
+ if (timeout == -1)
+ timeout = opt.read_timeout;
+ if (timeout)