builtin/credential-cache.c

   1 #include "builtin.h"
   2 #include "gettext.h"
   3 #include "parse-options.h"
   4 #include "path.h"
   5 #include "strbuf.h"
   6 #include "write-or-die.h"
   7
   8 #ifndef NO_UNIX_SOCKETS
   9
  10 #include "unix-socket.h"
  11 #include "run-command.h"
  12
  13 #define FLAG_SPAWN 0x1
  14 #define FLAG_RELAY 0x2
  15
  16 #ifdef GIT_WINDOWS_NATIVE
  17
  18 static int connection_closed(int error)
  19 {
  20         return (error == EINVAL);
  21 }
  22
  23 static int connection_fatally_broken(int error)
  24 {
  25         return (error != ENOENT) && (error != ENETDOWN);
  26 }
  27
  28 #else
  29
  30 static int connection_closed(int error)
  31 {
  32         return (error == ECONNRESET);
  33 }
  34
  35 static int connection_fatally_broken(int error)
  36 {
  37         return (error != ENOENT) && (error != ECONNREFUSED);
  38 }
  39
  40 #endif
  41
  42 static int send_request(const char *socket, const struct strbuf *out)
  43 {
  44         int got_data = 0;
  45         int fd = unix_stream_connect(socket, 0);
  46
  47         if (fd < 0)
  48                 return -1;
  49
  50         if (write_in_full(fd, out->buf, out->len) < 0)
  51                 die_errno("unable to write to cache daemon");
  52         shutdown(fd, SHUT_WR);
  53
  54         while (1) {
  55                 char in[1024];
  56                 int r;
  57
  58                 r = read_in_full(fd, in, sizeof(in));
  59                 if (r == 0 || (r < 0 && connection_closed(errno)))
  60                         break;
  61                 if (r < 0)
  62                         die_errno("read error from cache daemon");
  63                 write_or_die(1, in, r);
  64                 got_data = 1;
  65         }
  66         close(fd);
  67         return got_data;
  68 }
  69
  70 static void spawn_daemon(const char *socket)
  71 {
  72         struct child_process daemon = CHILD_PROCESS_INIT;
  73         char buf[128];
  74         int r;
  75
  76         strvec_pushl(&daemon.args,
  77                      "credential-cache--daemon", socket,
  78                      NULL);
  79         daemon.git_cmd = 1;
  80         daemon.no_stdin = 1;
  81         daemon.out = -1;
  82
  83         if (start_command(&daemon))
  84                 die_errno("unable to start cache daemon");
  85         r = read_in_full(daemon.out, buf, sizeof(buf));
  86         if (r < 0)
  87                 die_errno("unable to read result code from cache daemon");
  88         if (r != 3 || memcmp(buf, "ok\n", 3))
  89                 die("cache daemon did not start: %.*s", r, buf);
  90         close(daemon.out);
  91 }
  92
  93 static void do_cache(const char *socket, const char *action, int timeout,
  94                      int flags)
  95 {
  96         struct strbuf buf = STRBUF_INIT;
  97
  98         strbuf_addf(&buf, "action=%s\n", action);
  99         strbuf_addf(&buf, "timeout=%d\n", timeout);
 100         if (flags & FLAG_RELAY) {
 101                 if (strbuf_read(&buf, 0, 0) < 0)
 102                         die_errno("unable to relay credential");
 103         }
 104
 105         if (send_request(socket, &buf) < 0) {
 106                 if (connection_fatally_broken(errno))
 107                         die_errno("unable to connect to cache daemon");
 108                 if (flags & FLAG_SPAWN) {
 109                         spawn_daemon(socket);
 110                         if (send_request(socket, &buf) < 0)
 111                                 die_errno("unable to connect to cache daemon");
 112                 }
 113         }
 114         strbuf_release(&buf);
 115 }
 116
 117 static char *get_socket_path(void)
 118 {
 119         struct stat sb;
 120         char *old_dir, *socket;
 121         old_dir = interpolate_path("~/.git-credential-cache", 0);
 122         if (old_dir && !stat(old_dir, &sb) && S_ISDIR(sb.st_mode))
 123                 socket = xstrfmt("%s/socket", old_dir);
 124         else
 125                 socket = xdg_cache_home("credential/socket");
 126         free(old_dir);
 127         return socket;
 128 }
 129
 130 int cmd_credential_cache(int argc, const char **argv, const char *prefix)
 131 {
 132         char *socket_path = NULL;
 133         int timeout = 900;
 134         const char *op;
 135         const char * const usage[] = {
 136                 "git credential-cache [<options>] <action>",
 137                 NULL
 138         };
 139         struct option options[] = {
 140                 OPT_INTEGER(0, "timeout", &timeout,
 141                             "number of seconds to cache credentials"),
 142                 OPT_STRING(0, "socket", &socket_path, "path",
 143                            "path of cache-daemon socket"),
 144                 OPT_END()
 145         };
 146
 147         argc = parse_options(argc, argv, prefix, options, usage, 0);
 148         if (!argc)
 149                 usage_with_options(usage, options);
 150         op = argv[0];
 151
 152         if (!have_unix_sockets())
 153                 die(_("credential-cache unavailable; no unix socket support"));
 154
 155         if (!socket_path)
 156                 socket_path = get_socket_path();
 157         if (!socket_path)
 158                 die("unable to find a suitable socket path; use --socket");
 159
 160         if (!strcmp(op, "exit"))
 161                 do_cache(socket_path, op, timeout, 0);
 162         else if (!strcmp(op, "get") || !strcmp(op, "erase"))
 163                 do_cache(socket_path, op, timeout, FLAG_RELAY);
 164         else if (!strcmp(op, "store"))
 165                 do_cache(socket_path, op, timeout, FLAG_RELAY|FLAG_SPAWN);
 166         else
 167                 ; /* ignore unknown operation */
 168
 169         return 0;
 170 }
 171
 172 #else
 173
 174 int cmd_credential_cache(int argc, const char **argv, const char *prefix)
 175 {
 176         const char * const usage[] = {
 177                 "git credential-cache [options] <action>",
 178                 "",
 179                 "credential-cache is disabled in this build of Git",
 180                 NULL
 181         };
 182         struct option options[] = { OPT_END() };
 183
 184         argc = parse_options(argc, argv, prefix, options, usage, 0);
 185         die(_("credential-cache unavailable; no unix socket support"));
 186 }
 187
 188 #endif /* NO_UNIX_SOCKETS */