sign_buffer: use pipe_command

[thirdparty/git.git] / gpg-interface.c

diff --git a/gpg-interface.c b/gpg-interface.c
index c4b1e8c78d396194753d8a7287678bc476f858d6..74f08a2a0e3b196f907aa13928bcd1f1275c6e21 100644 (file)
--- a/gpg-interface.c
+++ b/gpg-interface.c
@@ -3,6 +3,7 @@
 #include "strbuf.h"
 #include "gpg-interface.h"
 #include "sigchain.h"
+#include "tempfile.h"
 
 static char *configured_signing_key;
 static const char *gpg_program = "gpg";
@@ -150,42 +151,26 @@ const char *get_signing_key(void)
 int sign_buffer(struct strbuf *buffer, struct strbuf *signature, const char *signing_key)
 {
        struct child_process gpg = CHILD_PROCESS_INIT;
-       const char *args[4];
-       ssize_t len;
+       int ret;
        size_t i, j, bottom;
 
-       gpg.argv = args;
-       gpg.in = -1;
-       gpg.out = -1;
-       args[0] = gpg_program;
-       args[1] = "-bsau";
-       args[2] = signing_key;
-       args[3] = NULL;
+       argv_array_pushl(&gpg.args,
+                        gpg_program,
+                        "-bsau", signing_key,
+                        NULL);
 
-       if (start_command(&gpg))
-               return error(_("could not run gpg."));
+       bottom = signature->len;
 
        /*
         * When the username signingkey is bad, program could be terminated
         * because gpg exits without reading and then write gets SIGPIPE.
         */
        sigchain_push(SIGPIPE, SIG_IGN);
-
-       if (write_in_full(gpg.in, buffer->buf, buffer->len) != buffer->len) {
-               close(gpg.in);
-               close(gpg.out);
-               finish_command(&gpg);
-               return error(_("gpg did not accept the data"));
-       }
-       close(gpg.in);
-
-       bottom = signature->len;
-       len = strbuf_read(signature, gpg.out, 1024);
-       close(gpg.out);
-
+       ret = pipe_command(&gpg, buffer->buf, buffer->len,
+                          signature, 1024, NULL, 0);
        sigchain_pop(SIGPIPE);
 
-       if (finish_command(&gpg) || !len || len < 0)
+       if (ret || signature->len == bottom)
                return error(_("gpg failed to sign the data"));
 
        /* Strip CR from the line endings, in case we are on Windows. */
@@ -210,50 +195,38 @@ int verify_signed_buffer(const char *payload, size_t payload_size,
                         struct strbuf *gpg_output, struct strbuf *gpg_status)
 {
        struct child_process gpg = CHILD_PROCESS_INIT;
-       const char *args_gpg[] = {NULL, "--status-fd=1", "--verify", "FILE", "-", NULL};
-       char path[PATH_MAX];
+       static struct tempfile temp;
        int fd, ret;
        struct strbuf buf = STRBUF_INIT;
-       struct strbuf *pbuf = &buf;
 
-       args_gpg[0] = gpg_program;
-       fd = git_mkstemp(path, PATH_MAX, ".git_vtag_tmpXXXXXX");
+       fd = mks_tempfile_t(&temp, ".git_vtag_tmpXXXXXX");
        if (fd < 0)
-               return error_errno(_("could not create temporary file '%s'"), path);
-       if (write_in_full(fd, signature, signature_size) < 0)
-               return error_errno(_("failed writing detached signature to '%s'"), path);
-       close(fd);
-
-       gpg.argv = args_gpg;
-       gpg.in = -1;
-       gpg.out = -1;
-       if (gpg_output)
-               gpg.err = -1;
-       args_gpg[3] = path;
-       if (start_command(&gpg)) {
-               unlink(path);
-               return error(_("could not run gpg."));
+               return error_errno(_("could not create temporary file"));
+       if (write_in_full(fd, signature, signature_size) < 0) {
+               error_errno(_("failed writing detached signature to '%s'"),
+                           temp.filename.buf);
+               delete_tempfile(&temp);
+               return -1;
        }
+       close(fd);
 
-       sigchain_push(SIGPIPE, SIG_IGN);
-       write_in_full(gpg.in, payload, payload_size);
-       close(gpg.in);
+       argv_array_pushl(&gpg.args,
+                        gpg_program,
+                        "--status-fd=1",
+                        "--verify", temp.filename.buf, "-",
+                        NULL);
 
-       if (gpg_output) {
-               strbuf_read(gpg_output, gpg.err, 0);
-               close(gpg.err);
-       }
-       if (gpg_status)
-               pbuf = gpg_status;
-       strbuf_read(pbuf, gpg.out, 0);
-       close(gpg.out);
+       if (!gpg_status)
+               gpg_status = &buf;
 
-       ret = finish_command(&gpg);
+       sigchain_push(SIGPIPE, SIG_IGN);
+       ret = pipe_command(&gpg, payload, payload_size,
+                          gpg_status, 0, gpg_output, 0);
        sigchain_pop(SIGPIPE);
 
-       unlink_or_warn(path);
+       delete_tempfile(&temp);
 
-       ret |= !strstr(pbuf->buf, "\n[GNUPG:] GOODSIG ");
+       ret |= !strstr(gpg_status->buf, "\n[GNUPG:] GOODSIG ");
        strbuf_release(&buf); /* no matter it was used or not */
 
        return ret;