/*
* 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>
#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)
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,
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) {
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.
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));
", 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);
}
}
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));
write(fd, &storebuf.offset,
sizeof(storebuf.offset));
}
+ free(search);
}
break;
case KEYD_CMD_STORE:
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);
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)
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;
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);
projects / onak.git / blobdiff