2 #include "parse-options.h"
4 #ifndef NO_UNIX_SOCKETS
8 #include "credential.h"
9 #include "unix-socket.h"
11 struct credential_cache_entry
{
12 struct credential item
;
13 timestamp_t expiration
;
15 static struct credential_cache_entry
*entries
;
16 static int entries_nr
;
17 static int entries_alloc
;
19 static void cache_credential(struct credential
*c
, int timeout
)
21 struct credential_cache_entry
*e
;
23 ALLOC_GROW(entries
, entries_nr
+ 1, entries_alloc
);
24 e
= &entries
[entries_nr
++];
26 /* take ownership of pointers */
27 memcpy(&e
->item
, c
, sizeof(*c
));
28 memset(c
, 0, sizeof(*c
));
29 e
->expiration
= time(NULL
) + timeout
;
32 static struct credential_cache_entry
*lookup_credential(const struct credential
*c
)
35 for (i
= 0; i
< entries_nr
; i
++) {
36 struct credential
*e
= &entries
[i
].item
;
37 if (credential_match(c
, e
))
43 static void remove_credential(const struct credential
*c
)
45 struct credential_cache_entry
*e
;
47 e
= lookup_credential(c
);
52 static timestamp_t
check_expirations(void)
54 static timestamp_t wait_for_entry_until
;
56 timestamp_t now
= time(NULL
);
57 timestamp_t next
= TIME_MAX
;
60 * Initially give the client 30 seconds to actually contact us
61 * and store a credential before we decide there's no point in
62 * keeping the daemon around.
64 if (!wait_for_entry_until
)
65 wait_for_entry_until
= now
+ 30;
67 while (i
< entries_nr
) {
68 if (entries
[i
].expiration
<= now
) {
70 credential_clear(&entries
[i
].item
);
72 memcpy(&entries
[i
], &entries
[entries_nr
], sizeof(*entries
));
74 * Stick around 30 seconds in case a new credential
75 * shows up (e.g., because we just removed a failed
76 * one, and we will soon get the correct one).
78 wait_for_entry_until
= now
+ 30;
81 if (entries
[i
].expiration
< next
)
82 next
= entries
[i
].expiration
;
88 if (wait_for_entry_until
<= now
)
90 next
= wait_for_entry_until
;
96 static int read_request(FILE *fh
, struct credential
*c
,
97 struct strbuf
*action
, int *timeout
)
99 static struct strbuf item
= STRBUF_INIT
;
102 strbuf_getline_lf(&item
, fh
);
103 if (!skip_prefix(item
.buf
, "action=", &p
))
104 return error("client sent bogus action line: %s", item
.buf
);
105 strbuf_addstr(action
, p
);
107 strbuf_getline_lf(&item
, fh
);
108 if (!skip_prefix(item
.buf
, "timeout=", &p
))
109 return error("client sent bogus timeout line: %s", item
.buf
);
112 if (credential_read(c
, fh
) < 0)
117 static void serve_one_client(FILE *in
, FILE *out
)
119 struct credential c
= CREDENTIAL_INIT
;
120 struct strbuf action
= STRBUF_INIT
;
123 if (read_request(in
, &c
, &action
, &timeout
) < 0)
125 else if (!strcmp(action
.buf
, "get")) {
126 struct credential_cache_entry
*e
= lookup_credential(&c
);
128 fprintf(out
, "username=%s\n", e
->item
.username
);
129 fprintf(out
, "password=%s\n", e
->item
.password
);
130 if (e
->item
.password_expiry_utc
!= TIME_MAX
)
131 fprintf(out
, "password_expiry_utc=%"PRItime
"\n",
132 e
->item
.password_expiry_utc
);
135 else if (!strcmp(action
.buf
, "exit")) {
137 * It's important that we clean up our socket first, and then
138 * signal the client only once we have finished the cleanup.
139 * Calling exit() directly does this, because we clean up in
140 * our atexit() handler, and then signal the client when our
141 * process actually ends, which closes the socket and gives
146 else if (!strcmp(action
.buf
, "erase"))
147 remove_credential(&c
);
148 else if (!strcmp(action
.buf
, "store")) {
150 warning("cache client didn't specify a timeout");
151 else if (!c
.username
|| !c
.password
)
152 warning("cache client gave us a partial credential");
154 remove_credential(&c
);
155 cache_credential(&c
, timeout
);
159 warning("cache client sent unknown action: %s", action
.buf
);
161 credential_clear(&c
);
162 strbuf_release(&action
);
165 static int serve_cache_loop(int fd
)
170 wakeup
= check_expirations();
176 if (poll(&pfd
, 1, 1000 * wakeup
) < 0) {
178 die_errno("poll failed");
182 if (pfd
.revents
& POLLIN
) {
186 client
= accept(fd
, NULL
, NULL
);
188 warning_errno("accept failed");
191 client2
= dup(client
);
193 warning_errno("dup failed");
198 in
= xfdopen(client
, "r");
199 out
= xfdopen(client2
, "w");
200 serve_one_client(in
, out
);
207 static void serve_cache(const char *socket_path
, int debug
)
209 struct unix_stream_listen_opts opts
= UNIX_STREAM_LISTEN_OPTS_INIT
;
212 fd
= unix_stream_listen(socket_path
, &opts
);
214 die_errno("unable to bind to '%s'", socket_path
);
219 if (!freopen("/dev/null", "w", stderr
))
220 die_errno("unable to point stderr to /dev/null");
223 while (serve_cache_loop(fd
))
229 static const char permissions_advice
[] = N_(
230 "The permissions on your socket directory are too loose; other\n"
231 "users may be able to read your cached credentials. Consider running:\n"
234 static void init_socket_directory(const char *path
)
237 char *path_copy
= xstrdup(path
);
238 char *dir
= dirname(path_copy
);
240 if (!stat(dir
, &st
)) {
241 if (st
.st_mode
& 077)
242 die(_(permissions_advice
), dir
);
245 * We must be sure to create the directory with the correct mode,
246 * not just chmod it after the fact; otherwise, there is a race
247 * condition in which somebody can chdir to it, sleep, then try to open
248 * our protected socket.
250 if (safe_create_leading_directories_const(dir
) < 0)
251 die_errno("unable to create directories for '%s'", dir
);
252 if (mkdir(dir
, 0700) < 0)
253 die_errno("unable to mkdir '%s'", dir
);
258 * We don't actually care what our cwd is; we chdir here just to
259 * be a friendly daemon and avoid tying up our original cwd.
260 * If this fails, it's OK to just continue without that benefit.
267 int cmd_credential_cache_daemon(int argc
, const char **argv
, const char *prefix
)
269 struct tempfile
*socket_file
;
270 const char *socket_path
;
271 int ignore_sighup
= 0;
272 static const char *usage
[] = {
273 "git credential-cache--daemon [--debug] <socket-path>",
277 const struct option options
[] = {
278 OPT_BOOL(0, "debug", &debug
,
279 N_("print debugging messages to stderr")),
283 git_config_get_bool("credentialcache.ignoresighup", &ignore_sighup
);
285 argc
= parse_options(argc
, argv
, prefix
, options
, usage
, 0);
286 socket_path
= argv
[0];
289 usage_with_options(usage
, options
);
291 if (!is_absolute_path(socket_path
))
292 die("socket directory must be an absolute path");
294 init_socket_directory(socket_path
);
295 socket_file
= register_tempfile(socket_path
);
298 signal(SIGHUP
, SIG_IGN
);
300 serve_cache(socket_path
, debug
);
301 delete_tempfile(&socket_file
);
308 int cmd_credential_cache_daemon(int argc
, const char **argv
, const char *prefix
)
310 const char * const usage
[] = {
311 "git credential-cache--daemon [--debug] <socket-path>",
313 "credential-cache--daemon is disabled in this build of Git",
316 struct option options
[] = { OPT_END() };
318 argc
= parse_options(argc
, argv
, prefix
, options
, usage
, 0);
319 die(_("credential-cache--daemon unavailable; no unix socket support"));
322 #endif /* NO_UNIX_SOCKET */