2 * keyd.c - key retrieval daemon
4 * Copyright 2004,2011 Jonathan McDowell <noodles@earth.li>
6 * This program is free software: you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; version 2 of the License.
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc., 51
17 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
27 #include <sys/select.h>
28 #include <sys/socket.h>
29 #include <sys/types.h>
34 #include "charfuncs.h"
39 #include "keystructs.h"
42 #include "onak-conf.h"
46 /* Maximum number of clients we're prepared to accept at once */
47 #define MAX_CLIENTS 16
49 static struct keyd_stats *stats;
58 logthing(LOGTHING_CRITICAL,
59 "Failed to fork into background: %d (%s)",
64 logthing(LOGTHING_INFO, "Backgrounded as pid %d.", pid);
70 freopen("/dev/null", "r", stdin);
71 freopen("/dev/null", "w", stdout);
72 freopen("/dev/null", "w", stderr);
77 void iteratefunc(void *ctx, struct openpgp_publickey *key)
79 struct openpgp_packet_list *packets = NULL;
80 struct openpgp_packet_list *list_end = NULL;
81 struct buffer_ctx storebuf;
83 int *fd = (int *) ctx;
89 storebuf.buffer = malloc(8192);
91 get_keyid(key, &keyid);
92 logthing(LOGTHING_TRACE,
93 "Iterating over 0x%016" PRIX64 ".",
96 flatten_publickey(key,
99 write_openpgp_stream(buffer_putchar,
102 logthing(LOGTHING_TRACE,
105 ret = write(*fd, &storebuf.offset,
106 sizeof(storebuf.offset));
108 write(*fd, storebuf.buffer,
112 free(storebuf.buffer);
113 storebuf.buffer = NULL;
114 storebuf.size = storebuf.offset = 0;
115 free_packet_list(packets);
116 packets = list_end = NULL;
122 int sock_init(const char *sockname)
124 struct sockaddr_un sock;
128 fd = socket(PF_UNIX, SOCK_STREAM, 0);
130 ret = fcntl(fd, F_SETFD, FD_CLOEXEC);
134 sock.sun_family = AF_UNIX;
135 strncpy(sock.sun_path, sockname, sizeof(sock.sun_path) - 1);
137 ret = bind(fd, (struct sockaddr *) &sock, sizeof(sock));
149 uint32_t cmd = KEYD_CMD_UNKNOWN;
154 uint8_t fp[MAX_FINGERPRINT_LEN];
156 struct openpgp_publickey *key = NULL;
157 struct openpgp_packet_list *packets = NULL;
158 struct openpgp_packet_list *list_end = NULL;
159 struct buffer_ctx storebuf;
163 * Get the command from the client.
165 bytes = read(fd, &cmd, sizeof(cmd));
167 logthing(LOGTHING_DEBUG, "Read %d bytes, command: %d", bytes, cmd);
169 if (bytes != sizeof(cmd)) {
174 if (cmd < KEYD_CMD_LAST) {
175 stats->command_stats[cmd]++;
177 stats->command_stats[KEYD_CMD_UNKNOWN]++;
180 case KEYD_CMD_VERSION:
182 write(fd, &cmd, sizeof(cmd));
183 cmd = sizeof(keyd_version);
184 write(fd, &cmd, sizeof(cmd));
185 write(fd, &keyd_version, sizeof(keyd_version));
187 case KEYD_CMD_GET_ID:
189 write(fd, &cmd, sizeof(cmd));
190 bytes = read(fd, &keyid, sizeof(keyid));
191 if (bytes != sizeof(keyid)) {
196 logthing(LOGTHING_INFO,
197 "Fetching 0x%" PRIX64
204 storebuf.size = 8192;
205 storebuf.buffer = malloc(8192);
207 flatten_publickey(key,
210 write_openpgp_stream(buffer_putchar,
213 logthing(LOGTHING_TRACE,
216 write(fd, &storebuf.offset,
217 sizeof(storebuf.offset));
218 write(fd, storebuf.buffer,
221 free(storebuf.buffer);
222 storebuf.buffer = NULL;
223 storebuf.size = storebuf.offset = 0;
224 free_packet_list(packets);
225 packets = list_end = NULL;
229 write(fd, &storebuf.offset,
230 sizeof(storebuf.offset));
234 case KEYD_CMD_GET_FP:
236 write(fd, &cmd, sizeof(cmd));
238 if (bytes > MAX_FINGERPRINT_LEN) {
245 logthing(LOGTHING_INFO,
246 "Fetching by fingerprint"
249 fetch_key_fp(fp, bytes,
252 storebuf.size = 8192;
253 storebuf.buffer = malloc(8192);
255 flatten_publickey(key,
258 write_openpgp_stream(buffer_putchar,
261 logthing(LOGTHING_TRACE,
264 write(fd, &storebuf.offset,
265 sizeof(storebuf.offset));
266 write(fd, storebuf.buffer,
269 free(storebuf.buffer);
270 storebuf.buffer = NULL;
271 storebuf.size = storebuf.offset = 0;
272 free_packet_list(packets);
273 packets = list_end = NULL;
277 write(fd, &storebuf.offset,
278 sizeof(storebuf.offset));
283 case KEYD_CMD_GET_TEXT:
285 write(fd, &cmd, sizeof(cmd));
286 bytes = read(fd, &count, sizeof(count));
287 if (bytes != sizeof(count)) {
292 search = malloc(count+1);
293 read(fd, search, count);
295 logthing(LOGTHING_INFO,
296 "Fetching %s, result: %d",
299 fetch_key_text(search, &key));
301 storebuf.size = 8192;
302 storebuf.buffer = malloc(8192);
304 flatten_publickey(key,
307 write_openpgp_stream(buffer_putchar,
310 logthing(LOGTHING_TRACE,
313 write(fd, &storebuf.offset,
314 sizeof(storebuf.offset));
315 write(fd, storebuf.buffer,
318 free(storebuf.buffer);
319 storebuf.buffer = NULL;
320 storebuf.size = storebuf.offset = 0;
321 free_packet_list(packets);
322 packets = list_end = NULL;
326 write(fd, &storebuf.offset,
327 sizeof(storebuf.offset));
334 write(fd, &cmd, sizeof(cmd));
336 bytes = read(fd, &storebuf.size,
337 sizeof(storebuf.size));
338 logthing(LOGTHING_TRACE, "Reading %d bytes.",
340 if (bytes != sizeof(storebuf.size)) {
343 if (ret == 0 && storebuf.size > 0) {
344 storebuf.buffer = malloc(storebuf.size);
346 while (bytes >= 0 && count < storebuf.size) {
348 &storebuf.buffer[count],
349 storebuf.size - count);
350 logthing(LOGTHING_TRACE,
355 read_openpgp_stream(buffer_fetchchar,
359 parse_keys(packets, &key);
360 config.dbbackend->store_key(key, false, false);
361 free_packet_list(packets);
365 free(storebuf.buffer);
366 storebuf.buffer = NULL;
367 storebuf.size = storebuf.offset = 0;
370 case KEYD_CMD_DELETE:
372 write(fd, &cmd, sizeof(cmd));
373 bytes = read(fd, &keyid, sizeof(keyid));
374 if (bytes != sizeof(keyid)) {
378 logthing(LOGTHING_INFO,
379 "Deleting 0x%" PRIX64
382 config.dbbackend->delete_key(
386 case KEYD_CMD_GETFULLKEYID:
388 write(fd, &cmd, sizeof(cmd));
389 bytes = read(fd, &keyid, sizeof(keyid));
390 if (bytes != sizeof(keyid)) {
394 keyid = config.dbbackend->getfullkeyid(keyid);
396 write(fd, &cmd, sizeof(cmd));
397 write(fd, &keyid, sizeof(keyid));
400 case KEYD_CMD_KEYITER:
402 write(fd, &cmd, sizeof(cmd));
403 config.dbbackend->iterate_keys(iteratefunc,
406 write(fd, &bytes, sizeof(bytes));
410 write(fd, &cmd, sizeof(cmd));
415 write(fd, &cmd, sizeof(cmd));
416 logthing(LOGTHING_NOTICE,
417 "Exiting due to quit request.");
423 write(fd, &cmd, sizeof(cmd));
424 cmd = sizeof(*stats);
425 write(fd, &cmd, sizeof(cmd));
429 case KEYD_CMD_GET_SKSHASH:
431 write(fd, &cmd, sizeof(cmd));
432 bytes = read(fd, hash.hash, sizeof(hash.hash));
433 if (bytes != sizeof(hash.hash)) {
438 logthing(LOGTHING_INFO,
442 fetch_key_skshash(&hash,
445 storebuf.size = 8192;
446 storebuf.buffer = malloc(8192);
448 flatten_publickey(key,
451 write_openpgp_stream(buffer_putchar,
454 logthing(LOGTHING_TRACE,
457 write(fd, &storebuf.offset,
458 sizeof(storebuf.offset));
459 write(fd, storebuf.buffer,
462 free(storebuf.buffer);
463 storebuf.buffer = NULL;
464 storebuf.size = storebuf.offset = 0;
465 free_packet_list(packets);
466 packets = list_end = NULL;
470 write(fd, &storebuf.offset,
471 sizeof(storebuf.offset));
477 logthing(LOGTHING_ERROR, "Got unknown command: %d",
479 cmd = KEYD_REPLY_UNKNOWN_CMD;
480 write(fd, &cmd, sizeof(cmd));
487 int sock_close(int fd)
489 shutdown(fd, SHUT_RDWR);
493 int sock_accept(int fd)
495 struct sockaddr_un sock;
500 socklen = sizeof(sock);
501 srv = accept(fd, (struct sockaddr *) &sock, &socklen);
503 ret = fcntl(srv, F_SETFD, FD_CLOEXEC);
513 static void usage(void)
515 puts("keyd " ONAK_VERSION " - backend key serving daemon for the "
516 "onak PGP keyserver.\n");
518 puts("\tkeyd [options]\n");
519 puts("\tOptions:\n:");
520 puts("-c <file> - use <file> as the config file");
521 puts("-f - run in the foreground");
522 puts("-h - show this help text");
526 int main(int argc, char *argv[])
528 int fd = -1, maxfd, i, clients[MAX_CLIENTS];
531 char *configfile = NULL;
532 bool foreground = false;
535 while ((optchar = getopt(argc, argv, "c:fh")) != -1 ) {
538 configfile = strdup(optarg);
550 readconfig(configfile);
553 initlogthing("keyd", config.logfile);
554 config.use_keyd = false;
561 signal(SIGPIPE, SIG_IGN);
564 stats = calloc(1, sizeof(*stats));
566 logthing(LOGTHING_ERROR,
567 "Couldn't allocate memory for stats structure.");
570 stats->started = time(NULL);
572 snprintf(sockname, 1023, "%s/%s", config.db_dir, KEYD_SOCKET);
573 fd = sock_init(sockname);
579 memset(clients, -1, sizeof (clients));
581 config.dbbackend->initdb(false);
583 logthing(LOGTHING_NOTICE, "Accepting connections.");
584 while (!cleanup() && select(maxfd + 1, &rfds, NULL, NULL, NULL) != -1) {
586 * Deal with existing clients first; if we're at our
587 * connection limit then processing them might free
588 * things up and let us accept the next client below.
590 for (i = 0; i < MAX_CLIENTS; i++) {
591 if (clients[i] != -1 &&
592 FD_ISSET(clients[i], &rfds)) {
593 logthing(LOGTHING_DEBUG,
594 "Handling connection for client %d.", i);
595 if (sock_do(clients[i])) {
596 sock_close(clients[i]);
598 logthing(LOGTHING_DEBUG,
599 "Closed connection for client %d.", i);
604 * Check if we have a new incoming connection to accept.
606 if (FD_ISSET(fd, &rfds)) {
607 for (i = 0; i < MAX_CLIENTS; i++) {
608 if (clients[i] == -1) {
612 if (i < MAX_CLIENTS) {
613 logthing(LOGTHING_INFO,
614 "Accepted connection %d.", i);
615 clients[i] = sock_accept(fd);
621 for (i = 0; i < MAX_CLIENTS; i++) {
622 if (clients[i] != -1) {
623 FD_SET(clients[i], &rfds);
624 maxfd = (maxfd > clients[i]) ?
629 config.dbbackend->cleanupdb();
639 return(EXIT_SUCCESS);