diff --git a/g10/call-keyboxd.c b/g10/call-keyboxd.c
index e09fa20e3..31bccefec 100644
--- a/g10/call-keyboxd.c
+++ b/g10/call-keyboxd.c
@@ -40,6 +40,7 @@
#include "../common/host2net.h"
#include "../common/exechelp.h"
#include "../common/status.h"
+#include "../kbx/kbx-client-util.h"
#include "keydb.h"
#include "keydb-private.h" /* For struct keydb_handle_s */
@@ -57,20 +58,8 @@ struct keyboxd_local_s
/* The active Assuan context. */
assuan_context_t ctx;
- /* This object is used if fd-passing is used to convey the
- * keyblocks. */
- struct {
- /* NULL or a stream used to receive data. */
- estream_t fp;
-
- /* Condition variable to sync the datastream with the command. */
- npth_mutex_t mutex;
- npth_cond_t cond;
-
- /* The found keyblock or the parsing error. */
- kbnode_t found_keyblock;
- gpg_error_t found_err;
- } datastream;
+ /* The client data helper context. */
+ kbx_client_data_t kcd;
/* I/O buffer with the last search result or NULL. Used if
* D-lines are used to convey the keyblocks. */
@@ -79,41 +68,14 @@ struct keyboxd_local_s
/* This flag set while an operation is running on this context. */
unsigned int is_active : 1;
- /* This flag is set to record that the standard per session init has
- * been done. */
- unsigned int per_session_init_done : 1;
-
/* Flag indicating that a search reset is required. */
unsigned int need_search_reset : 1;
};
-/* Local prototypes. */
-static void *datastream_thread (void *arg);
-
-static void
-lock_datastream (keyboxd_local_t kbl)
-{
- int rc = npth_mutex_lock (&kbl->datastream.mutex);
- if (rc)
- log_fatal ("%s: failed to acquire mutex: %s\n", __func__,
- gpg_strerror (gpg_error_from_errno (rc)));
-}
-
-
-static void
-unlock_datastream (keyboxd_local_t kbl)
-{
- int rc = npth_mutex_unlock (&kbl->datastream.mutex);
- if (rc)
- log_fatal ("%s: failed to release mutex: %s\n", __func__,
- gpg_strerror (gpg_error_from_errno (rc)));
-}
-
-
/* Deinitialize all session resources pertaining to the keyboxd. */
void
gpg_keyboxd_deinit_session_data (ctrl_t ctrl)
@@ -127,8 +89,8 @@ gpg_keyboxd_deinit_session_data (ctrl_t ctrl)
log_error ("oops: trying to cleanup an active keyboxd context\n");
else
{
- es_fclose (kbl->datastream.fp);
- kbl->datastream.fp = NULL;
+ kbx_client_data_release (kbl->kcd);
+ kbl->kcd = NULL;
assuan_release (kbl->ctx);
kbl->ctx = NULL;
}
@@ -189,73 +151,6 @@ create_new_context (ctrl_t ctrl, assuan_context_t *r_ctx)
-/* Setup the pipe used for receiving data from the keyboxd. Store the
- * info on KBL. */
-static gpg_error_t
-prepare_data_pipe (keyboxd_local_t kbl)
-{
- gpg_error_t err;
- int rc;
- int inpipe[2];
- estream_t infp;
- npth_t thread;
- npth_attr_t tattr;
-
- err = gnupg_create_inbound_pipe (inpipe, &infp, 0);
- if (err)
- {
- log_error ("error creating inbound pipe: %s\n", gpg_strerror (err));
- return err; /* That should not happen. */
- }
-
- err = assuan_sendfd (kbl->ctx, INT2FD (inpipe[1]));
- if (err)
- {
- log_error ("sending sending fd %d to keyboxd: %s <%s>\n",
- inpipe[1], gpg_strerror (err), gpg_strsource (err));
- es_fclose (infp);
- close (inpipe[1]);
- return 0; /* Server may not support fd-passing. */
- }
-
- err = assuan_transact (kbl->ctx, "OUTPUT FD",
- NULL, NULL, NULL, NULL, NULL, NULL);
- if (err)
- {
- log_info ("keyboxd does not accept our fd: %s <%s>\n",
- gpg_strerror (err), gpg_strsource (err));
- es_fclose (infp);
- return 0;
- }
-
- kbl->datastream.fp = infp;
- kbl->datastream.found_keyblock = NULL;
- kbl->datastream.found_err = 0;
-
- rc = npth_attr_init (&tattr);
- if (rc)
- {
- err = gpg_error_from_errno (rc);
- log_error ("error preparing thread for keyboxd: %s\n",gpg_strerror (err));
- es_fclose (infp);
- kbl->datastream.fp = NULL;
- return err;
- }
- npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
- rc = npth_create (&thread, &tattr, datastream_thread, kbl);
- if (rc)
- {
- err = gpg_error_from_errno (rc);
- log_error ("error spawning thread for keyboxd: %s\n", gpg_strerror (err));
- npth_attr_destroy (&tattr);
- es_fclose (infp);
- kbl->datastream.fp = NULL;
- return err;
- }
-
- return 0;
-}
-
/* Get a context for accessing keyboxd. If no context is available a
* new one is created and if necessary keyboxd is started. R_KBL
@@ -264,7 +159,6 @@ static gpg_error_t
open_context (ctrl_t ctrl, keyboxd_local_t *r_kbl)
{
gpg_error_t err;
- int rc;
keyboxd_local_t kbl;
*r_kbl = NULL;
@@ -277,15 +171,6 @@ open_context (ctrl_t ctrl, keyboxd_local_t *r_kbl)
/* Found an inactive keyboxd session - return that. */
log_assert (!kbl->is_active);
- /* But first do the per session init if not yet done. */
- if (!kbl->per_session_init_done)
- {
- err = prepare_data_pipe (kbl);
- if (err)
- return err;
- kbl->per_session_init_done = 1;
- }
-
kbl->is_active = 1;
kbl->need_search_reset = 1;
@@ -298,29 +183,17 @@ open_context (ctrl_t ctrl, keyboxd_local_t *r_kbl)
if (!kbl)
return gpg_error_from_syserror ();
- rc = npth_mutex_init (&kbl->datastream.mutex, NULL);
- if (rc)
+ err = create_new_context (ctrl, &kbl->ctx);
+ if (err)
{
- err = gpg_error_from_errno (rc);
- log_error ("error initializing mutex: %s\n", gpg_strerror (err));
- xfree (kbl);
- return err;
- }
- rc = npth_cond_init (&kbl->datastream.cond, NULL);
- if (rc)
- {
- err = gpg_error_from_errno (rc);
- log_error ("error initializing condition: %s\n", gpg_strerror (err));
- npth_mutex_destroy (&kbl->datastream.mutex);
xfree (kbl);
return err;
}
- err = create_new_context (ctrl, &kbl->ctx);
+ err = kbx_client_data_new (&kbl->kcd, kbl->ctx);
if (err)
{
- npth_cond_destroy (&kbl->datastream.cond);
- npth_mutex_destroy (&kbl->datastream.mutex);
+ assuan_release (kbl->ctx);
xfree (kbl);
return err;
}
@@ -427,224 +300,6 @@ keydb_lock (KEYDB_HANDLE hd)
}
-
-/* FIXME: This helper is duplicates code of partse_keyblock_image. */
-static gpg_error_t
-keydb_get_keyblock_do_parse (iobuf_t iobuf, int pk_no, int uid_no,
- kbnode_t *r_keyblock)
-{
- gpg_error_t err;
- struct parse_packet_ctx_s parsectx;
- PACKET *pkt;
- kbnode_t keyblock = NULL;
- kbnode_t node, *tail;
- int in_cert, save_mode;
- int pk_count, uid_count;
-
- *r_keyblock = NULL;
-
- pkt = xtrymalloc (sizeof *pkt);
- if (!pkt)
- return gpg_error_from_syserror ();
- init_packet (pkt);
- init_parse_packet (&parsectx, iobuf);
- save_mode = set_packet_list_mode (0);
- in_cert = 0;
- tail = NULL;
- pk_count = uid_count = 0;
- while ((err = parse_packet (&parsectx, pkt)) != -1)
- {
- if (gpg_err_code (err) == GPG_ERR_UNKNOWN_PACKET)
- {
- free_packet (pkt, &parsectx);
- init_packet (pkt);
- continue;
- }
- if (err)
- {
- es_fflush (es_stdout);
- log_error ("parse_keyblock_image: read error: %s\n",
- gpg_strerror (err));
- if (gpg_err_code (err) == GPG_ERR_INV_PACKET)
- {
- free_packet (pkt, &parsectx);
- init_packet (pkt);
- continue;
- }
- err = gpg_error (GPG_ERR_INV_KEYRING);
- break;
- }
-
- /* Filter allowed packets. */
- switch (pkt->pkttype)
- {
- case PKT_PUBLIC_KEY:
- case PKT_PUBLIC_SUBKEY:
- case PKT_SECRET_KEY:
- case PKT_SECRET_SUBKEY:
- case PKT_USER_ID:
- case PKT_ATTRIBUTE:
- case PKT_SIGNATURE:
- case PKT_RING_TRUST:
- break; /* Allowed per RFC. */
-
- default:
- log_info ("skipped packet of type %d in keybox\n", (int)pkt->pkttype);
- free_packet(pkt, &parsectx);
- init_packet(pkt);
- continue;
- }
-
- /* Other sanity checks. */
- if (!in_cert && pkt->pkttype != PKT_PUBLIC_KEY)
- {
- log_error ("parse_keyblock_image: first packet in a keybox blob "
- "is not a public key packet\n");
- err = gpg_error (GPG_ERR_INV_KEYRING);
- break;
- }
- if (in_cert && (pkt->pkttype == PKT_PUBLIC_KEY
- || pkt->pkttype == PKT_SECRET_KEY))
- {
- log_error ("parse_keyblock_image: "
- "multiple keyblocks in a keybox blob\n");
- err = gpg_error (GPG_ERR_INV_KEYRING);
- break;
- }
- in_cert = 1;
-
- node = new_kbnode (pkt);
-
- switch (pkt->pkttype)
- {
- case PKT_PUBLIC_KEY:
- case PKT_PUBLIC_SUBKEY:
- case PKT_SECRET_KEY:
- case PKT_SECRET_SUBKEY:
- if (++pk_count == pk_no)
- node->flag |= 1;
- break;
-
- case PKT_USER_ID:
- if (++uid_count == uid_no)
- node->flag |= 2;
- break;
-
- default:
- break;
- }
-
- if (!keyblock)
- keyblock = node;
- else
- *tail = node;
- tail = &node->next;
- pkt = xtrymalloc (sizeof *pkt);
- if (!pkt)
- {
- err = gpg_error_from_syserror ();
- break;
- }
- init_packet (pkt);
- }
- set_packet_list_mode (save_mode);
-
- if (err == -1 && keyblock)
- err = 0; /* Got the entire keyblock. */
-
- if (err)
- release_kbnode (keyblock);
- else
- {
- *r_keyblock = keyblock;
- }
- free_packet (pkt, &parsectx);
- deinit_parse_packet (&parsectx);
- xfree (pkt);
- return err;
-}
-
-
-/* The thread used to read from the data stream. This is running as
- * long as the connection and its datastream exists. */
-static void *
-datastream_thread (void *arg)
-{
- keyboxd_local_t kbl = arg;
- gpg_error_t err;
- int rc;
- unsigned char lenbuf[4];
- size_t nread, datalen;
- iobuf_t iobuf;
- int pk_no, uid_no;
- kbnode_t keyblock, tmpkeyblock;
-
-
- log_debug ("Datastream_thread started\n");
- while (kbl->datastream.fp)
- {
- /* log_debug ("Datastream_thread waiting ...\n"); */
- if (es_read (kbl->datastream.fp, lenbuf, 4, &nread))
- {
- err = gpg_error_from_syserror ();
- if (gpg_err_code (err) == GPG_ERR_EAGAIN)
- continue;
- log_error ("error reading data length from keyboxd: %s\n",
- gpg_strerror (err));
- gnupg_sleep (1);
- continue;
- }
- if (nread != 4)
- {
- err = gpg_error (GPG_ERR_EIO);
- log_error ("error reading data length from keyboxd: %s\n",
- "short read");
- continue;
- }
-
- datalen = buf32_to_size_t (lenbuf);
- /* log_debug ("keyboxd announced %zu bytes\n", datalen); */
-
- iobuf = iobuf_esopen (kbl->datastream.fp, "rb", 1, datalen);
- pk_no = uid_no = 0; /* FIXME: Get this from the keyboxd. */
- err = keydb_get_keyblock_do_parse (iobuf, pk_no, uid_no, &keyblock);
- iobuf_close (iobuf);
- if (!err)
- {
- /* log_debug ("parsing datastream succeeded\n"); */
-
- /* Thread-safe assignment to the result var: */
- tmpkeyblock = kbl->datastream.found_keyblock;
- kbl->datastream.found_keyblock = keyblock;
- release_kbnode (tmpkeyblock);
- }
- else
- {
- /* log_debug ("parsing datastream failed: %s <%s>\n", */
- /* gpg_strerror (err), gpg_strsource (err)); */
- tmpkeyblock = kbl->datastream.found_keyblock;
- kbl->datastream.found_keyblock = NULL;
- kbl->datastream.found_err = err;
- release_kbnode (tmpkeyblock);
- }
-
- /* Tell the main thread. */
- lock_datastream (kbl);
- rc = npth_cond_signal (&kbl->datastream.cond);
- if (rc)
- {
- err = gpg_error_from_errno (rc);
- log_error ("%s: signaling condition failed: %s\n",
- __func__, gpg_strerror (err));
- }
- unlock_datastream (kbl);
- }
- log_debug ("Datastream_thread finished\n");
-
- return NULL;
-}
-
-
/* Return the keyblock last found by keydb_search() in *RET_KB.
*
* On success, the function returns 0 and the caller must free *RET_KB
@@ -677,19 +332,13 @@ keydb_get_keyblock (KEYDB_HANDLE hd, kbnode_t *ret_kb)
if (hd->kbl->search_result)
{
pk_no = uid_no = 0; /*FIXME: Get this from the keyboxd. */
- err = keydb_get_keyblock_do_parse (hd->kbl->search_result,
- pk_no, uid_no, ret_kb);
+ err = keydb_parse_keyblock (hd->kbl->search_result, pk_no, uid_no,
+ ret_kb);
/* In contrast to the old code we close the iobuf here and thus
* this function may be called only once to get a keyblock. */
iobuf_close (hd->kbl->search_result);
hd->kbl->search_result = NULL;
}
- else if (hd->kbl->datastream.found_keyblock)
- {
- *ret_kb = hd->kbl->datastream.found_keyblock;
- hd->kbl->datastream.found_keyblock = NULL;
- err = 0;
- }
else
{
err = gpg_error (GPG_ERR_VALUE_NOT_FOUND);
@@ -976,7 +625,8 @@ keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
gpg_error_t err;
int i;
char line[ASSUAN_LINELENGTH];
-
+ char *buffer;
+ size_t len;
if (!hd)
return gpg_error (GPG_ERR_INV_ARG);
@@ -989,7 +639,7 @@ keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
if (DBG_LOOKUP)
{
- log_debug ("%s: %zd search descriptions:\n", __func__, ndesc);
+ log_debug ("%s: %zu search descriptions:\n", __func__, ndesc);
for (i = 0; i < ndesc; i ++)
{
char *t = keydb_search_desc_dump (&desc[i]);
@@ -1010,11 +660,6 @@ keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
iobuf_close (hd->kbl->search_result);
hd->kbl->search_result = NULL;
}
- if (hd->kbl->datastream.found_keyblock)
- {
- release_kbnode (hd->kbl->datastream.found_keyblock);
- hd->kbl->datastream.found_keyblock = NULL;
- }
/* Check whether this is a NEXT search. */
if (!hd->kbl->need_search_reset)
@@ -1129,72 +774,14 @@ keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
do_search:
hd->last_ubid_valid = 0;
- if (hd->kbl->datastream.fp)
+ err = kbx_client_data_cmd (hd->kbl->kcd, line, search_status_cb, hd);
+ if (!err && !(err = kbx_client_data_wait (hd->kbl->kcd, &buffer, &len)))
{
- /* log_debug ("Sending command '%s'\n", line); */
- err = assuan_transact (hd->kbl->ctx, line,
- NULL, NULL,
- NULL, NULL,
- search_status_cb, hd);
- if (err)
- {
- /* log_debug ("Finished command with error: %s\n", gpg_strerror (err)); */
- /* Fixme: On unexpected errors we need a way to cancel the
- * data stream. Probably it will be best to close and
- * reopen it. */
- }
- else
- {
- int rc;
-
- /* log_debug ("Finished command .. telling data stream\n"); */
- lock_datastream (hd->kbl);
- if (!hd->kbl->datastream.found_keyblock)
- {
- /* log_debug ("%s: waiting on datastream_cond ...\n", __func__); */
- rc = npth_cond_wait (&hd->kbl->datastream.cond,
- &hd->kbl->datastream.mutex);
- /* log_debug ("%s: waiting on datastream.cond done\n", __func__); */
- if (rc)
- {
- err = gpg_error_from_errno (rc);
- log_error ("%s: waiting on condition failed: %s\n",
- __func__, gpg_strerror (err));
- }
- }
- unlock_datastream (hd->kbl);
- }
- }
- else /* Slower D-line version if fd-passing was not successful. */
- {
- membuf_t data;
- void *buffer;
- size_t len;
-
- init_membuf (&data, 8192);
- err = assuan_transact (hd->kbl->ctx, line,
- put_membuf_cb, &data,
- NULL, NULL,
- search_status_cb, hd);
- if (err)
- {
- xfree (get_membuf (&data, &len));
- goto leave;
- }
-
- buffer = get_membuf (&data, &len);
- if (!buffer)
- {
- err = gpg_error_from_syserror ();
- goto leave;
- }
-
hd->kbl->search_result = iobuf_temp_with_content (buffer, len);
xfree (buffer);
- }
-
- /* if (hd->last_ubid_valid) */
- /* log_printhex (hd->last_ubid, 20, "found UBID:"); */
+ /* if (hd->last_ubid_valid) */
+ /* log_printhex (hd->last_ubid, 20, "found UBID:"); */
+ }
leave:
if (DBG_CLOCK)
diff --git a/g10/keydb-private.h b/g10/keydb-private.h
index fdc905edf..c54e73f69 100644
--- a/g10/keydb-private.h
+++ b/g10/keydb-private.h
@@ -154,6 +154,10 @@ struct keydb_handle_s
/*-- keydb.c --*/
+
+gpg_error_t keydb_parse_keyblock (iobuf_t iobuf, int pk_no, int uid_no,
+ kbnode_t *r_keyblock);
+
/* These are the functions call-keyboxd diverts to if the keyboxd is
* not used. */
diff --git a/g10/keydb.c b/g10/keydb.c
index 15291f307..ef56885bd 100644
--- a/g10/keydb.c
+++ b/g10/keydb.c
@@ -1136,8 +1136,9 @@ keydb_pop_found_state (KEYDB_HANDLE hd)
-static gpg_error_t
-parse_keyblock_image (iobuf_t iobuf, int pk_no, int uid_no,
+/* Parse the keyblock in IOBUF and return at R_KEYBLOCK. */
+gpg_error_t
+keydb_parse_keyblock (iobuf_t iobuf, int pk_no, int uid_no,
kbnode_t *r_keyblock)
{
gpg_error_t err;
@@ -1300,7 +1301,7 @@ internal_keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
}
else
{
- err = parse_keyblock_image (hd->keyblock_cache.iobuf,
+ err = keydb_parse_keyblock (hd->keyblock_cache.iobuf,
hd->keyblock_cache.pk_no,
hd->keyblock_cache.uid_no,
ret_kb);
@@ -1332,7 +1333,7 @@ internal_keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
&iobuf, &pk_no, &uid_no);
if (!err)
{
- err = parse_keyblock_image (iobuf, pk_no, uid_no, ret_kb);
+ err = keydb_parse_keyblock (iobuf, pk_no, uid_no, ret_kb);
if (!err && hd->keyblock_cache.state == KEYBLOCK_CACHE_PREPARED)
{
hd->keyblock_cache.state = KEYBLOCK_CACHE_FILLED;
diff --git a/kbx/Makefile.am b/kbx/Makefile.am
index 242e373a6..fe72860e9 100644
--- a/kbx/Makefile.am
+++ b/kbx/Makefile.am
@@ -57,9 +57,13 @@ common_sources = \
keybox-openpgp.c \
keybox-dump.c
+client_sources = \
+ kbx-client-util.h \
+ kbx-client-util.c
-libkeybox_a_SOURCES = $(common_sources)
-libkeybox509_a_SOURCES = $(common_sources)
+
+libkeybox_a_SOURCES = $(common_sources) $(client_sources)
+libkeybox509_a_SOURCES = $(common_sources) $(client_sources)
libkeybox_a_CFLAGS = $(AM_CFLAGS)
libkeybox509_a_CFLAGS = $(AM_CFLAGS) -DKEYBOX_WITH_X509=1
diff --git a/kbx/kbx-client-util.c b/kbx/kbx-client-util.c
new file mode 100644
index 000000000..ba356b3c5
--- /dev/null
+++ b/kbx/kbx-client-util.c
@@ -0,0 +1,450 @@
+/* kbx-client-util.c - Utility functions to implement a keyboxd client
+ * Copyright (C) 2020 g10 Code GmbH
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG 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; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG 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, see .
+ * SPDX-License-Identifier: GPL-3.0+
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "../common/util.h"
+#include "../common/membuf.h"
+#include "../common/i18n.h"
+#include "../common/asshelp.h"
+#include "../common/exechelp.h"
+#include "../common/sysutils.h"
+#include "../common/host2net.h"
+#include "kbx-client-util.h"
+
+
+#define MAX_DATABLOB_SIZE (16*1024*1024)
+
+
+
+/* This object is used to implement a client to the keyboxd. */
+struct kbx_client_data_s
+{
+ /* The used assuan context. */
+ assuan_context_t ctx;
+
+ /* A stream used to receive data. If this is NULL D-lines are used
+ * to receive the data. */
+ estream_t fp;
+
+ /* Condition variable to sync the datastream with the command. */
+ npth_mutex_t mutex;
+ npth_cond_t cond;
+
+ /* The data received from the keyboxd and an error code if there was
+ * a problem (in which case DATA is also set to NULL. This is only
+ * used if FP is not NULL. */
+ char *data;
+ size_t datalen;
+ gpg_error_t dataerr;
+
+ /* Helper variables in case D-lines are used (FP is NULL) */
+ char *dlinedata;
+ size_t dlinedatalen;
+ gpg_error_t dlineerr;
+};
+
+
+
+static void *datastream_thread (void *arg);
+
+
+
+static void
+lock_datastream (kbx_client_data_t kcd)
+{
+ int rc = npth_mutex_lock (&kcd->mutex);
+ if (rc)
+ log_fatal ("%s: failed to acquire mutex: %s\n", __func__,
+ gpg_strerror (gpg_error_from_errno (rc)));
+}
+
+
+static void
+unlock_datastream (kbx_client_data_t kcd)
+{
+ int rc = npth_mutex_unlock (&kcd->mutex);
+ if (rc)
+ log_fatal ("%s: failed to release mutex: %s\n", __func__,
+ gpg_strerror (gpg_error_from_errno (rc)));
+}
+
+
+
+/* Setup the pipe used for receiving data from the keyboxd. Store the
+ * info on KCD. */
+static gpg_error_t
+prepare_data_pipe (kbx_client_data_t kcd)
+{
+ gpg_error_t err;
+ int rc;
+ int inpipe[2];
+ estream_t infp;
+ npth_t thread;
+ npth_attr_t tattr;
+
+ kcd->fp = NULL;
+ kcd->data = NULL;
+ kcd->datalen = 0;
+ kcd->dataerr = 0;
+
+ err = gnupg_create_inbound_pipe (inpipe, &infp, 0);
+ if (err)
+ {
+ log_error ("error creating inbound pipe: %s\n", gpg_strerror (err));
+ return err; /* That should not happen. */
+ }
+
+ err = assuan_sendfd (kcd->ctx, INT2FD (inpipe[1]));
+ if (err)
+ {
+ log_error ("sending sending fd %d to keyboxd: %s <%s>\n",
+ inpipe[1], gpg_strerror (err), gpg_strsource (err));
+ es_fclose (infp);
+ gnupg_close_pipe (inpipe[1]);
+ return 0; /* Server may not support fd-passing. */
+ }
+
+ err = assuan_transact (kcd->ctx, "OUTPUT FD",
+ NULL, NULL, NULL, NULL, NULL, NULL);
+ if (err)
+ {
+ log_info ("keyboxd does not accept our fd: %s <%s>\n",
+ gpg_strerror (err), gpg_strsource (err));
+ es_fclose (infp);
+ return 0;
+ }
+
+ kcd->fp = infp;
+
+
+ rc = npth_attr_init (&tattr);
+ if (rc)
+ {
+ err = gpg_error_from_errno (rc);
+ log_error ("error preparing thread for keyboxd: %s\n",gpg_strerror (err));
+ es_fclose (infp);
+ kcd->fp = NULL;
+ return err;
+ }
+ npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
+ rc = npth_create (&thread, &tattr, datastream_thread, kcd);
+ if (rc)
+ {
+ err = gpg_error_from_errno (rc);
+ log_error ("error spawning thread for keyboxd: %s\n", gpg_strerror (err));
+ npth_attr_destroy (&tattr);
+ es_fclose (infp);
+ kcd->fp = NULL;
+ return err;
+ }
+
+ return 0;
+}
+
+
+/* The thread used to read from the data stream. This is running as
+ * long as the connection and its datastream exists. */
+static void *
+datastream_thread (void *arg)
+{
+ kbx_client_data_t kcd = arg;
+ gpg_error_t err;
+ int rc;
+ unsigned char lenbuf[4];
+ size_t nread, datalen;
+ int pk_no, uid_no;
+ char *data, *tmpdata;
+
+ /* log_debug ("%s: started\n", __func__); */
+ while (kcd->fp)
+ {
+ /* log_debug ("%s: waiting ...\n", __func__); */
+ if (es_read (kcd->fp, lenbuf, 4, &nread))
+ {
+ err = gpg_error_from_syserror ();
+ if (gpg_err_code (err) == GPG_ERR_EAGAIN)
+ continue;
+ log_error ("error reading data length from keyboxd: %s\n",
+ gpg_strerror (err));
+ gnupg_sleep (1);
+ continue;
+ }
+ if (nread != 4)
+ {
+ err = gpg_error (GPG_ERR_EIO);
+ log_error ("error reading data length from keyboxd: %s\n",
+ "short read");
+ continue;
+ }
+
+ datalen = buf32_to_size_t (lenbuf);
+ /* log_debug ("keyboxd announced %zu bytes\n", datalen); */
+ if (!datalen)
+ {
+ log_info ("ignoring empty blob received from keyboxd\n");
+ continue;
+ }
+
+ if (datalen > MAX_DATABLOB_SIZE)
+ {
+ err = gpg_error (GPG_ERR_TOO_LARGE);
+ /* Drop connection or what shall we do? */
+ }
+ else if (!(data = xtrymalloc (datalen+1)))
+ {
+ err = gpg_error_from_syserror ();
+ }
+ else if (es_read (kcd->fp, data, datalen, &nread))
+ {
+ err = gpg_error_from_syserror ();
+ }
+ else if (datalen != nread)
+ {
+ err = gpg_error (GPG_ERR_TOO_SHORT);
+ }
+ else
+ err = 0;
+
+ if (err)
+ {
+ log_error ("error reading data from keyboxd: %s <%s>\n",
+ gpg_strerror (err), gpg_strsource (err));
+ xfree (data);
+ data = NULL;
+ datalen = 0;
+ }
+ else
+ {
+ /* log_debug ("parsing datastream succeeded\n"); */
+ pk_no = uid_no = 0; /* FIXME: Get this from the keyboxd. */
+ }
+
+ /* Thread-safe assignment to the result var: */
+ tmpdata = kcd->data;
+ kcd->data = data;
+ kcd->datalen = datalen;
+ kcd->dataerr = err;
+ xfree (tmpdata);
+ data = NULL;
+
+ /* Tell the main thread. */
+ lock_datastream (kcd);
+ rc = npth_cond_signal (&kcd->cond);
+ if (rc)
+ {
+ err = gpg_error_from_errno (rc);
+ log_error ("%s: signaling condition failed: %s\n",
+ __func__, gpg_strerror (err));
+ }
+ unlock_datastream (kcd);
+ }
+ /* log_debug ("%s: finished\n", __func__); */
+
+ return NULL;
+}
+
+
+
+/* Create a new keyboxd client data object and return it at R_KCD.
+ * CTX is the assuan context to be used for connecting the
+ * keyboxd. */
+gpg_error_t
+kbx_client_data_new (kbx_client_data_t *r_kcd, assuan_context_t ctx)
+{
+ kbx_client_data_t kcd;
+ int rc;
+ gpg_error_t err;
+
+ kcd = xtrycalloc (1, sizeof *kcd);
+ if (!kcd)
+ return gpg_error_from_syserror ();
+
+ kcd->ctx = ctx;
+
+ rc = npth_mutex_init (&kcd->mutex, NULL);
+ if (rc)
+ {
+ err = gpg_error_from_errno (rc);
+ log_error ("error initializing mutex: %s\n", gpg_strerror (err));
+ xfree (kcd);
+ return err;
+ }
+ rc = npth_cond_init (&kcd->cond, NULL);
+ if (rc)
+ {
+ err = gpg_error_from_errno (rc);
+ log_error ("error initializing condition: %s\n", gpg_strerror (err));
+ npth_mutex_destroy (&kcd->mutex);
+ xfree (kcd);
+ return err;
+ }
+
+ err = prepare_data_pipe (kcd);
+ if (err)
+ {
+ npth_cond_destroy (&kcd->cond);
+ npth_mutex_destroy (&kcd->mutex);
+ xfree (kcd);
+ return err;
+ }
+
+ *r_kcd = kcd;
+ return 0;
+}
+
+
+void
+kbx_client_data_release (kbx_client_data_t kcd)
+{
+ estream_t fp;
+
+ if (!kcd)
+ return;
+ fp = kcd->fp;
+ kcd->fp = NULL;
+ es_fclose (fp); /* That close should let the thread run into an error. */
+ /* FIXME: Make thread killing explicit. Otherwise we run in a
+ * log_fatal due to the destroyed mutex. */
+ npth_cond_destroy (&kcd->cond);
+ npth_mutex_destroy (&kcd->mutex);
+ xfree (kcd);
+}
+
+
+/* Send the COMMAND down to the keyboxd associated with KCD.
+ * STATUS_CB and STATUS_CB_VALUE are the usual status callback as used
+ * by assuan_transact. After this function has returned success
+ * kbx_client_data_wait needs to be called to actually return the
+ * data. */
+gpg_error_t
+kbx_client_data_cmd (kbx_client_data_t kcd, const char *command,
+ gpg_error_t (*status_cb)(void *opaque, const char *line),
+ void *status_cb_value)
+{
+ gpg_error_t err;
+
+ xfree (kcd->dlinedata);
+ kcd->dlinedata = NULL;
+ kcd->dlinedatalen = 0;
+ kcd->dlineerr = 0;
+
+ if (kcd->fp)
+ {
+ /* log_debug ("%s: sending command '%s'\n", __func__, command); */
+ err = assuan_transact (kcd->ctx, command,
+ NULL, NULL,
+ NULL, NULL,
+ status_cb, status_cb_value);
+ if (err)
+ {
+ if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
+ log_debug ("%s: finished command with error: %s\n",
+ __func__, gpg_strerror (err));
+ /* Fixme: On unexpected errors we need a way to cancel the
+ * data stream. Probably it will be best to close and
+ * reopen it. */
+ }
+ }
+ else /* Slower D-line version if fd-passing is not available. */
+ {
+ membuf_t mb;
+ size_t len;
+
+ /* log_debug ("%s: sending command '%s' (no fd-passing)\n", */
+ /* __func__, command); */
+ init_membuf (&mb, 8192);
+ err = assuan_transact (kcd->ctx, command,
+ put_membuf_cb, &mb,
+ NULL, NULL,
+ status_cb, status_cb_value);
+ if (err)
+ {
+ if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
+ log_debug ("%s: finished command with error: %s\n",
+ __func__, gpg_strerror (err));
+ xfree (get_membuf (&mb, &len));
+ kcd->dlineerr = err;
+ goto leave;
+ }
+
+ kcd->dlinedata = get_membuf (&mb, &kcd->dlinedatalen);
+ if (!kcd->dlinedata)
+ {
+ err = gpg_error_from_syserror ();
+ goto leave;
+ }
+ }
+
+ leave:
+ return err;
+}
+
+
+
+/* Wait for the data from the server and on success return it at
+ * (R_DATA, R_DATALEN). */
+gpg_error_t
+kbx_client_data_wait (kbx_client_data_t kcd, char **r_data, size_t *r_datalen)
+{
+ gpg_error_t err = 0;
+ int rc;
+
+ *r_data = NULL;
+ *r_datalen = 0;
+ if (kcd->fp)
+ {
+ lock_datastream (kcd);
+ if (!kcd->data && !kcd->dataerr)
+ {
+ /* log_debug ("%s: waiting on datastream_cond ...\n", __func__); */
+ rc = npth_cond_wait (&kcd->cond, &kcd->mutex);
+ if (rc)
+ {
+ err = gpg_error_from_errno (rc);
+ log_error ("%s: waiting on condition failed: %s\n",
+ __func__, gpg_strerror (err));
+ }
+ /* else */
+ /* log_debug ("%s: waiting on datastream.cond done\n", __func__); */
+ }
+ *r_data = kcd->data;
+ kcd->data = NULL;
+ *r_datalen = kcd->datalen;
+ err = err? err : kcd->dataerr;
+
+ unlock_datastream (kcd);
+ }
+ else
+ {
+ *r_data = kcd->dlinedata;
+ kcd->dlinedata = NULL;
+ *r_datalen = kcd->dlinedatalen;
+ err = kcd->dlineerr;
+ }
+
+ return err;
+}
diff --git a/kbx/kbx-client-util.h b/kbx/kbx-client-util.h
new file mode 100644
index 000000000..db6cb9475
--- /dev/null
+++ b/kbx/kbx-client-util.h
@@ -0,0 +1,41 @@
+/* kbx-client-util.c - Defs for utility functions for a keyboxd client
+ * Copyright (C) 2020 g10 Code GmbH
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG 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; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG 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, see .
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#ifndef GNUPG_KBX_CLIENT_UTIL_H
+#define GNUPG_KBX_CLIENT_UTIL_H 1
+
+
+struct kbx_client_data_s;
+typedef struct kbx_client_data_s *kbx_client_data_t;
+
+gpg_error_t kbx_client_data_new (kbx_client_data_t *r_kcd,
+ assuan_context_t ctx);
+void kbx_client_data_release (kbx_client_data_t kcd);
+gpg_error_t kbx_client_data_cmd (kbx_client_data_t kcd, const char *command,
+ gpg_error_t (*status_cb)(void *opaque,
+ const char *line),
+ void *status_cb_value);
+gpg_error_t kbx_client_data_wait (kbx_client_data_t kcd,
+ char **r_data, size_t *r_datalen);
+
+
+
+
+#endif /*GNUPG_KBX_CLIENT_UTIL_H*/