+/**
+ * Get CONN_ID from file descriptor associated to a subprocess structure.
+ *
+ * @param fd File descriptor.
+ * @returns CONN_ID or NONE (-1).
+ */
+GLOBAL CONN_ID
+Conn_GetFromProc(int fd)
+{
+ int i;
+
+ assert(fd > 0);
+ for (i = 0; i < Pool_Size; i++) {
+ if ((My_Connections[i].sock != NONE)
+ && (Proc_GetPipeFd(&My_Connections[i].proc_stat) == fd))
+ return i;
+ }
+ return NONE;
+} /* Conn_GetFromProc */
+
+/**
+ * Throttle a connection because of excessive usage.
+ *
+ * @param Reason The reason, see THROTTLE_xxx constants.
+ * @param Idx The connection index.
+ * @param Client The client of this connection.
+ * @param Seconds The time to delay this connection.
+ */
+static void
+Throttle_Connection(const CONN_ID Idx, CLIENT *Client, const int Reason,
+ unsigned int Value)
+{
+ assert(Idx > NONE);
+ assert(Client != NULL);
+
+ /* Never throttle servers or services, only interrupt processing */
+ if (Client_Type(Client) == CLIENT_SERVER
+ || Client_Type(Client) == CLIENT_UNKNOWNSERVER
+ || Client_Type(Client) == CLIENT_SERVICE)
+ return;
+
+ /* Don't throttle clients with user mode 'F' set */
+ if (Client_HasMode(Client, 'F'))
+ return;
+
+ LogDebug("Throttling connection %d: code %d, value %d!", Idx,
+ Reason, Value);
+ Conn_SetPenalty(Idx, 1);
+}
+
+#ifndef STRICT_RFC
+
+GLOBAL long
+Conn_GetAuthPing(CONN_ID Idx)
+{
+ assert (Idx != NONE);
+ return My_Connections[Idx].auth_ping;
+} /* Conn_GetAuthPing */
+
+GLOBAL void
+Conn_SetAuthPing(CONN_ID Idx, long ID)
+{
+ assert (Idx != NONE);
+ My_Connections[Idx].auth_ping = ID;
+} /* Conn_SetAuthPing */
+
+#endif /* STRICT_RFC */
+
+#ifdef SSL_SUPPORT
+
+/**
+ * IO callback for new SSL-enabled client and server connections.
+ *
+ * @param sock Socket descriptor.
+ * @param what IO specification (IO_WANTREAD/IO_WANTWRITE/...).
+ */
+static void
+cb_clientserver_ssl(int sock, UNUSED short what)
+{
+ CONN_ID idx = Socket2Index(sock);
+
+ assert(idx >= 0);
+
+ if (idx < 0) {
+ io_close(sock);
+ return;
+ }
+
+ switch (ConnSSL_Accept(&My_Connections[idx])) {
+ case 1:
+ break; /* OK */
+ case 0:
+ return; /* EAGAIN: callback will be invoked again by IO layer */
+ default:
+ Conn_Close(idx,
+ "SSL accept error, closing socket", "SSL accept error",
+ false);
+ return;
+ }
+
+ io_event_setcb(sock, cb_clientserver); /* SSL handshake completed */
+}
+
+/**
+ * IO callback for listening SSL sockets: handle new connections. This callback
+ * gets called when a new SSL-enabled connection should be accepted.
+ *
+ * @param sock Socket descriptor.
+ * @param irrelevant (ignored IO specification)
+ */
+static void
+cb_listen_ssl(int sock, short irrelevant)
+{
+ int fd;
+
+ (void) irrelevant;
+ fd = New_Connection(sock, true);
+ if (fd < 0)
+ return;
+ io_event_setcb(My_Connections[fd].sock, cb_clientserver_ssl);
+}
+
+/**
+ * IO callback for new outgoing SSL-enabled server connections.
+ *
+ * @param sock Socket descriptor.
+ * @param unused (ignored IO specification)
+ */
+static void
+cb_connserver_login_ssl(int sock, short unused)
+{
+ CONN_ID idx = Socket2Index(sock);
+
+ assert(idx >= 0);
+ if (idx < 0) {
+ io_close(sock);
+ return;
+ }
+ (void) unused;
+ switch (ConnSSL_Connect( &My_Connections[idx])) {
+ case 1: break;
+ case 0: LogDebug("ConnSSL_Connect: not ready");
+ return;
+ case -1:
+ Log(LOG_ERR, "SSL connection on socket %d failed!", sock);
+ Conn_Close(idx, "Can't connect", NULL, false);
+ return;
+ }
+
+ Log( LOG_INFO, "SSL connection %d with \"%s:%d\" established.", idx,
+ My_Connections[idx].host, Conf_Server[Conf_GetServer( idx )].port );
+
+ server_login(idx);
+}
+
+
+/**
+ * Check if SSL library needs to read SSL-protocol related data.
+ *
+ * SSL/TLS connections require extra treatment:
+ * When either CONN_SSL_WANT_WRITE or CONN_SSL_WANT_READ is set, we
+ * need to take care of that first, before checking read/write buffers.
+ * For instance, while we might have data in our write buffer, the
+ * TLS/SSL protocol might need to read internal data first for TLS/SSL
+ * writes to succeed.
+ *
+ * If this function returns true, such a condition is met and we have
+ * to reverse the condition (check for read even if we've data to write,
+ * do not check for read but writeability even if write-buffer is empty).
+ *
+ * @param c Connection to check.
+ * @returns true if SSL-library has to read protocol data.
+ */
+static bool
+SSL_WantRead(const CONNECTION *c)
+{
+ if (Conn_OPTION_ISSET(c, CONN_SSL_WANT_READ)) {
+ io_event_add(c->sock, IO_WANTREAD);
+ return true;
+ }
+ return false;
+}
+
+/**
+ * Check if SSL library needs to write SSL-protocol related data.
+ *
+ * Please see description of SSL_WantRead() for full description!
+ *
+ * @param c Connection to check.
+ * @returns true if SSL-library has to write protocol data.
+ */
+static bool
+SSL_WantWrite(const CONNECTION *c)
+{
+ if (Conn_OPTION_ISSET(c, CONN_SSL_WANT_WRITE)) {
+ io_event_add(c->sock, IO_WANTWRITE);
+ return true;
+ }
+ return false;
+}
+
+/**
+ * Get information about used SSL cipher.
+ *
+ * @param Idx Connection index number.
+ * @param buf Buffer for returned information text.
+ * @param len Size of return buffer "buf".
+ * @returns true on success, false otherwise.
+ */
+GLOBAL bool
+Conn_GetCipherInfo(CONN_ID Idx, char *buf, size_t len)
+{
+ if (Idx < 0)
+ return false;
+ assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
+ return ConnSSL_GetCipherInfo(&My_Connections[Idx], buf, len);
+}
+
+/**
+ * Check if a connection is SSL-enabled or not.
+ *
+ * @param Idx Connection index number.
+ * @return true if connection is SSL-enabled, false otherwise.
+ */
+GLOBAL bool
+Conn_UsesSSL(CONN_ID Idx)
+{
+ if (Idx < 0)
+ return false;
+ assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
+ return Conn_OPTION_ISSET(&My_Connections[Idx], CONN_SSL);
+}
+
+GLOBAL char *
+Conn_GetCertFp(CONN_ID Idx)
+{
+ if (Idx < 0)
+ return NULL;
+ assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
+ return ConnSSL_GetCertFp(&My_Connections[Idx]);
+}
+
+GLOBAL bool
+Conn_SetCertFp(CONN_ID Idx, const char *fingerprint)
+{
+ if (Idx < 0)
+ return false;
+ assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
+ return ConnSSL_SetCertFp(&My_Connections[Idx], fingerprint);
+}
+
+#else /* SSL_SUPPORT */
+
+GLOBAL bool
+Conn_UsesSSL(UNUSED CONN_ID Idx)
+{
+ return false;
+}
+
+GLOBAL char *
+Conn_GetCertFp(UNUSED CONN_ID Idx)
+{
+ return NULL;