Extend database backends to support fetching by key fingerprint

[onak.git] / keyd.c

diff --git a/keyd.c b/keyd.c
index e43115d48bdda7cb26f81628f563e4324f937698..a89f0e1f37aade33ecf00d4f171f92d191bf1dee 100644 (file)
--- a/keyd.c
+++ b/keyd.c
@@ -43,6 +43,9 @@
 #include "parsekey.h"
 #include "version.h"
 
+/* Maximum number of clients we're prepared to accept at once */
+#define MAX_CLIENTS 16
+
 static struct keyd_stats *stats;
 
 void daemonize(void)
@@ -124,7 +127,7 @@ int sock_init(const char *sockname)
 
        fd = socket(PF_UNIX, SOCK_STREAM, 0);
        if (fd != -1) {
-               ret = fcntl(fd, F_SETFD, 1);
+               ret = fcntl(fd, F_SETFD, FD_CLOEXEC);
        }
 
        if (ret != -1) {
@@ -148,6 +151,7 @@ int sock_do(int fd)
        ssize_t  count = 0;
        int      ret = 0;
        uint64_t keyid = 0;
+       uint8_t  fp[MAX_FINGERPRINT_LEN];
        char     *search = NULL;
        struct openpgp_publickey *key = NULL;
        struct openpgp_packet_list *packets = NULL;
@@ -180,7 +184,7 @@ int sock_do(int fd)
                        write(fd, &cmd, sizeof(cmd));
                        write(fd, &keyd_version, sizeof(keyd_version));
                        break;
-               case KEYD_CMD_GET:
+               case KEYD_CMD_GET_ID:
                        cmd = KEYD_REPLY_OK;
                        write(fd, &cmd, sizeof(cmd));
                        bytes = read(fd, &keyid, sizeof(keyid));
@@ -194,7 +198,8 @@ int sock_do(int fd)
                                                ", result: %d",
                                                keyid,
                                                config.dbbackend->
-                                               fetch_key(keyid, &key, false));
+                                               fetch_key_id(keyid,
+                                                       &key, false));
                                if (key != NULL) {
                                        storebuf.size = 8192;
                                        storebuf.buffer = malloc(8192);
@@ -226,7 +231,56 @@ int sock_do(int fd)
                                }
                        }
                        break;
-               case KEYD_CMD_GETTEXT:
+               case KEYD_CMD_GET_FP:
+                       cmd = KEYD_REPLY_OK;
+                       write(fd, &cmd, sizeof(cmd));
+                       read(fd, &bytes, 1);
+                       if (bytes > MAX_FINGERPRINT_LEN) {
+                               ret = 1;
+                       } else {
+                               read(fd, fp, bytes);
+                       }
+                       storebuf.offset = 0;
+                       if (ret == 0) {
+                               logthing(LOGTHING_INFO,
+                                               "Fetching by fingerprint"
+                                               ", result: %d",
+                                               config.dbbackend->
+                                               fetch_key_fp(fp, bytes,
+                                                       &key, false));
+                               if (key != NULL) {
+                                       storebuf.size = 8192;
+                                       storebuf.buffer = malloc(8192);
+
+                                       flatten_publickey(key,
+                                                       &packets,
+                                                       &list_end);
+                                       write_openpgp_stream(buffer_putchar,
+                                                       &storebuf,
+                                                       packets);
+                                       logthing(LOGTHING_TRACE,
+                                                       "Sending %d bytes.",
+                                                       storebuf.offset);
+                                       write(fd, &storebuf.offset,
+                                               sizeof(storebuf.offset));
+                                       write(fd, storebuf.buffer,
+                                               storebuf.offset);
+
+                                       free(storebuf.buffer);
+                                       storebuf.buffer = NULL;
+                                       storebuf.size = storebuf.offset = 0;
+                                       free_packet_list(packets);
+                                       packets = list_end = NULL;
+                                       free_publickey(key);
+                                       key = NULL;
+                               } else {
+                                       write(fd, &storebuf.offset,
+                                               sizeof(storebuf.offset));
+                               }
+                       }
+                       break;
+
+               case KEYD_CMD_GET_TEXT:
                        cmd = KEYD_REPLY_OK;
                        write(fd, &cmd, sizeof(cmd));
                        bytes = read(fd, &count, sizeof(count));
@@ -272,6 +326,7 @@ int sock_do(int fd)
                                        write(fd, &storebuf.offset,
                                                sizeof(storebuf.offset));
                                }
+                               free(search);
                        }
                        break;
                case KEYD_CMD_STORE:
@@ -371,7 +426,7 @@ int sock_do(int fd)
                        write(fd, stats,
                                sizeof(*stats));
                        break;
-               case KEYD_CMD_GETSKSHASH:
+               case KEYD_CMD_GET_SKSHASH:
                        cmd = KEYD_REPLY_OK;
                        write(fd, &cmd, sizeof(cmd));
                        bytes = read(fd, hash.hash, sizeof(hash.hash));
@@ -445,16 +500,14 @@ int sock_accept(int fd)
        socklen = sizeof(sock);
        srv = accept(fd, (struct sockaddr *) &sock, &socklen);
        if (srv != -1) {
-               ret = fcntl(srv, F_SETFD, 1);
+               ret = fcntl(srv, F_SETFD, FD_CLOEXEC);
        }
 
        if (ret != -1) {
                stats->connects++;
-               while (!sock_do(srv)) ;
-               sock_close(srv);
        }
 
-       return 1;
+       return (srv);
 }
 
 static void usage(void)
@@ -472,7 +525,7 @@ static void usage(void)
 
 int main(int argc, char *argv[])
 {
-       int fd = -1;
+       int fd = -1, maxfd, i, clients[MAX_CLIENTS];
        fd_set rfds;
        char sockname[1024];
        char *configfile = NULL;
@@ -522,14 +575,56 @@ int main(int argc, char *argv[])
        if (fd != -1) {
                FD_ZERO(&rfds);
                FD_SET(fd, &rfds);
+               maxfd = fd;
+               memset(clients, -1, sizeof (clients));
 
                config.dbbackend->initdb(false);
 
                logthing(LOGTHING_NOTICE, "Accepting connections.");
-               while (!cleanup() && select(fd + 1, &rfds, NULL, NULL, NULL) != -1) {
-                       logthing(LOGTHING_INFO, "Accepted connection.");
-                       sock_accept(fd);
+               while (!cleanup() && select(maxfd + 1, &rfds, NULL, NULL, NULL) != -1) {
+                       /*
+                        * Deal with existing clients first; if we're at our
+                        * connection limit then processing them might free
+                        * things up and let us accept the next client below.
+                        */
+                       for (i = 0; i < MAX_CLIENTS; i++) {
+                               if (clients[i] != -1 &&
+                                               FD_ISSET(clients[i], &rfds)) {
+                                       logthing(LOGTHING_DEBUG,
+                                               "Handling connection for client %d.", i);
+                                       if (sock_do(clients[i])) {
+                                               sock_close(clients[i]);
+                                               clients[i] = -1;
+                                               logthing(LOGTHING_DEBUG,
+                                                       "Closed connection for client %d.", i);
+                                       }
+                               }
+                       }
+                       /*
+                        * Check if we have a new incoming connection to accept.
+                        */
+                       if (FD_ISSET(fd, &rfds)) {
+                               for (i = 0; i < MAX_CLIENTS; i++) {
+                                       if (clients[i] == -1) {
+                                               break;
+                                       }
+                               }
+                               if (i < MAX_CLIENTS) {
+                                       logthing(LOGTHING_INFO,
+                                               "Accepted connection %d.", i);
+                                       clients[i] = sock_accept(fd);
+                               }
+                       }
+                       FD_ZERO(&rfds);
                        FD_SET(fd, &rfds);
+                       maxfd = fd;
+                       for (i = 0; i < MAX_CLIENTS; i++) {
+                               if (clients[i] != -1) {
+                                       FD_SET(clients[i], &rfds);
+                                       maxfd = (maxfd > clients[i]) ?
+                                                       maxfd : clients[i];
+                               }
+                       }
                }
                config.dbbackend->cleanupdb();
                sock_close(fd);