X-Git-Url: http://the.earth.li/gitweb/?a=blobdiff_plain;f=keyd.c;h=a89f0e1f37aade33ecf00d4f171f92d191bf1dee;hb=c04c1c60469823c01268187ec49102d1ff540806;hp=5d5b7ba8c883b68326361f7789bbb228e6ac1593;hpb=7a0ffbb5910bd782ef569b63ce665659e3564e72;p=onak.git

diff --git a/keyd.c b/keyd.c
index 5d5b7ba..a89f0e1 100644
--- a/keyd.c
+++ b/keyd.c
@@ -1,9 +1,20 @@
 /*
  * keyd.c - key retrieval daemon
  *
- * Jonathan McDowell <noodles@earth.li>
+ * Copyright 2004,2011 Jonathan McDowell <noodles@earth.li>
  *
- * Copyright 2004 Project Purple
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <errno.h>
@@ -32,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)
@@ -67,15 +81,17 @@ void iteratefunc(void *ctx, struct openpgp_publickey *key)
 	struct buffer_ctx           storebuf;
 	int                         ret = 0;
 	int                         *fd = (int *) ctx;
+	uint64_t                    keyid;
 
 	if (key != NULL) {
 		storebuf.offset = 0;
 		storebuf.size = 8192;
 		storebuf.buffer = malloc(8192);
 
+		get_keyid(key, &keyid);
 		logthing(LOGTHING_TRACE,
 				"Iterating over 0x%016" PRIX64 ".",
-				get_keyid(key));
+				keyid);
 
 		flatten_publickey(key,
 				&packets,
@@ -111,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) {
@@ -135,11 +151,13 @@ 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;
 	struct openpgp_packet_list *list_end = NULL;
 	struct buffer_ctx storebuf;
+	struct skshash hash;
 
 	/*
 	 * Get the command from the client.
@@ -166,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));
@@ -180,7 +198,56 @@ 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);
+
+					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_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);
@@ -212,7 +279,8 @@ int sock_do(int fd)
 				}
 			}
 			break;
-		case KEYD_CMD_GETTEXT:
+
+		case KEYD_CMD_GET_TEXT:
 			cmd = KEYD_REPLY_OK;
 			write(fd, &cmd, sizeof(cmd));
 			bytes = read(fd, &count, sizeof(count));
@@ -258,6 +326,7 @@ int sock_do(int fd)
 					write(fd, &storebuf.offset,
 						sizeof(storebuf.offset));
 				}
+				free(search);
 			}
 			break;
 		case KEYD_CMD_STORE:
@@ -357,6 +426,53 @@ int sock_do(int fd)
 			write(fd, stats,
 				sizeof(*stats));
 			break;
+		case KEYD_CMD_GET_SKSHASH:
+			cmd = KEYD_REPLY_OK;
+			write(fd, &cmd, sizeof(cmd));
+			bytes = read(fd, hash.hash, sizeof(hash.hash));
+			if (bytes != sizeof(hash.hash)) {
+				ret = 1;
+			}
+			storebuf.offset = 0;
+			if (ret == 0) {
+				logthing(LOGTHING_INFO,
+						"Fetching by hash"
+						", result: %d",
+						config.dbbackend->
+						fetch_key_skshash(&hash,
+							&key));
+				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;
+
 		default:
 			logthing(LOGTHING_ERROR, "Got unknown command: %d",
 					cmd);
@@ -384,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)
@@ -411,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;
@@ -461,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);