Public Git Hosting - git/debian.git/blob

1 #include "cache.h"

2 #include "config.h"

3 #include "credential.h"

4 #include "string-list.h"

5 #include "run-command.h"

6 #include "url.h"

7 #include "prompt.h"

8 #include "sigchain.h"

9 #include "urlmatch.h"

void credential_init(struct credential *c)

12 {

13 struct credential blank = CREDENTIAL_INIT;

        memcpy(c, &blank, sizeof(*c));

15 }

void credential_clear(struct credential *c)

18 {

19 free(c->protocol);

20 free(c->host);

21 free(c->path);

22 free(c->username);

23 free(c->password);

        string_list_clear(&c->helpers, 0);

26 credential_init(c);

27 }

int credential_match(const struct credential *want,

30 const struct credential *have)

31 {

32 #define CHECK(x) (!want->x || (have->x && !strcmp(want->x, have->x)))

33 return CHECK(protocol) &&

34 CHECK(host) &&

35 CHECK(path) &&

36 CHECK(username);

37 #undef CHECK

38 }

static int credential_from_potentially_partial_url(struct credential *c,

42 const char *url);

static int credential_config_callback(const char *var, const char *value,

45 void *data)

46 {

47 struct credential *c = data;

48 const char *key;

        if (!skip_prefix(var, "credential.", &key))

51 return 0;

53 if (!value)

54 return config_error_nonbool(var);

        if (!strcmp(key, "helper")) {

57 if (*value)

                        string_list_append(&c->helpers, value);

59 else

                        string_list_clear(&c->helpers, 0);

        } else if (!strcmp(key, "username")) {

62 if (!c->username_from_proto) {

63 free(c->username);

                        c->username = xstrdup(value);

65 }

66 }

        else if (!strcmp(key, "usehttppath"))

                c->use_http_path = git_config_bool(var, value);

70 return 0;

71 }

static int proto_is_http(const char *s)

74 {

75 if (!s)

76 return 0;

        return !strcmp(s, "https") || !strcmp(s, "http");

78 }

static void credential_describe(struct credential *c, struct strbuf *out);

static void credential_format(struct credential *c, struct strbuf *out);

static int select_all(const struct urlmatch_item *a,

84 const struct urlmatch_item *b)

85 {

86 return 0;

87 }

static int match_partial_url(const char *url, void *cb)

90 {

91 struct credential *c = cb;

92 struct credential want = CREDENTIAL_INIT;

93 int matches = 0;

        if (credential_from_potentially_partial_url(&want, url) < 0)

                warning(_("skipping credential lookup for key: credential.%s"),

97 url);

98 else

                matches = credential_match(&want, c);

100 credential_clear(&want);

101

102 return matches;

103 }

104

static void credential_apply_config(struct credential *c)

106 {

107 char *normalized_url;

108 struct urlmatch_config config = URLMATCH_CONFIG_INIT;

109 struct strbuf url = STRBUF_INIT;

110

111 if (!c->host)

                die(_("refusing to work with credential missing host field"));

113 if (!c->protocol)

                die(_("refusing to work with credential missing protocol field"));

115

116 if (c->configured)

117 return;

118

119 config.section = "credential";

120 config.key = NULL;

121 config.collect_fn = credential_config_callback;

122 config.cascade_fn = NULL;

123 config.select_fn = select_all;

124 config.fallback_match_fn = match_partial_url;

125 config.cb = c;

126

127 credential_format(c, &url);

        normalized_url = url_normalize(url.buf, &config.url);

129

130 git_config(urlmatch_config_entry, &config);

        string_list_clear(&config.vars, 1);

132 free(normalized_url);

133 urlmatch_config_release(&config);

134 strbuf_release(&url);

135

136 c->configured = 1;

137

        if (!c->use_http_path && proto_is_http(c->protocol)) {

139 FREE_AND_NULL(c->path);

140 }

141 }

142

static void credential_describe(struct credential *c, struct strbuf *out)

144 {

145 if (!c->protocol)

146 return;

        strbuf_addf(out, "%s://", c->protocol);

        if (c->username && *c->username)

                strbuf_addf(out, "%s@", c->username);

150 if (c->host)

                strbuf_addstr(out, c->host);

152 if (c->path)

                strbuf_addf(out, "/%s", c->path);

154 }

155

static void credential_format(struct credential *c, struct strbuf *out)

157 {

158 if (!c->protocol)

159 return;

        strbuf_addf(out, "%s://", c->protocol);

        if (c->username && *c->username) {

                strbuf_add_percentencode(out, c->username, STRBUF_ENCODE_SLASH);

                strbuf_addch(out, '@');

164 }

165 if (c->host)

                strbuf_addstr(out, c->host);

167 if (c->path) {

                strbuf_addch(out, '/');

                strbuf_add_percentencode(out, c->path, 0);

170 }

171 }

172

static char *credential_ask_one(const char *what, struct credential *c,

174 int flags)

175 {

176 struct strbuf desc = STRBUF_INIT;

177 struct strbuf prompt = STRBUF_INIT;

178 char *r;

179

180 credential_describe(c, &desc);

181 if (desc.len)

                strbuf_addf(&prompt, "%s for '%s': ", what, desc.buf);

183 else

                strbuf_addf(&prompt, "%s: ", what);

185

        r = git_prompt(prompt.buf, flags);

187

188 strbuf_release(&desc);

189 strbuf_release(&prompt);

190 return xstrdup(r);

191 }

192

static void credential_getpass(struct credential *c)

194 {

195 if (!c->username)

                c->username = credential_ask_one("Username", c,

197 PROMPT_ASKPASS|PROMPT_ECHO);

198 if (!c->password)

                c->password = credential_ask_one("Password", c,

200 PROMPT_ASKPASS);

201 }

202

int credential_read(struct credential *c, FILE *fp)

204 {

205 struct strbuf line = STRBUF_INIT;

206

        while (strbuf_getline(&line, fp) != EOF) {

                char *key = line.buf;

                char *value = strchr(key, '=');

210

211 if (!line.len)

212 break;

213

214 if (!value) {

                        warning("invalid credential line: %s", key);

216 strbuf_release(&line);

217 return -1;

218 }

219 *value = '\0';

220

                if (!strcmp(key, "username")) {

222 free(c->username);

                        c->username = xstrdup(value);

224 c->username_from_proto = 1;

                } else if (!strcmp(key, "password")) {

226 free(c->password);

                        c->password = xstrdup(value);

                } else if (!strcmp(key, "protocol")) {

229 free(c->protocol);

                        c->protocol = xstrdup(value);

                } else if (!strcmp(key, "host")) {

232 free(c->host);

                        c->host = xstrdup(value);

                } else if (!strcmp(key, "path")) {

235 free(c->path);

                        c->path = xstrdup(value);

                } else if (!strcmp(key, "url")) {

238 credential_from_url(c, value);

                } else if (!strcmp(key, "quit")) {

                        c->quit = !!git_config_bool("quit", value);

241 }

242 /*

243 * Ignore other lines; we don't know what they mean, but

244 * this future-proofs us when later versions of git do

245 * learn new lines, and the helpers are updated to match.

246 */

247 }

248

249 strbuf_release(&line);

250 return 0;

251 }

252

static void credential_write_item(FILE *fp, const char *key, const char *value,

254 int required)

255 {

256 if (!value && required)

                BUG("credential value for %s is missing", key);

258 if (!value)

259 return;

        if (strchr(value, '\n'))

                die("credential value for %s contains newline", key);

        fprintf(fp, "%s=%s\n", key, value);

263 }

264

void credential_write(const struct credential *c, FILE *fp)

266 {

        credential_write_item(fp, "protocol", c->protocol, 1);

        credential_write_item(fp, "host", c->host, 1);

        credential_write_item(fp, "path", c->path, 0);

        credential_write_item(fp, "username", c->username, 0);

        credential_write_item(fp, "password", c->password, 0);

272 }

273

static int run_credential_helper(struct credential *c,

275 const char *cmd,

276 int want_output)

277 {

278 struct child_process helper = CHILD_PROCESS_INIT;

279 FILE *fp;

280

        strvec_push(&helper.args, cmd);

282 helper.use_shell = 1;

283 helper.in = -1;

284 if (want_output)

285 helper.out = -1;

286 else

287 helper.no_stdout = 1;

288

        if (start_command(&helper) < 0)

290 return -1;

291

        fp = xfdopen(helper.in, "w");

293 sigchain_push(SIGPIPE, SIG_IGN);

294 credential_write(c, fp);

295 fclose(fp);

296 sigchain_pop(SIGPIPE);

297

298 if (want_output) {

299 int r;

                fp = xfdopen(helper.out, "r");

                r = credential_read(c, fp);

302 fclose(fp);

                if (r < 0) {

304 finish_command(&helper);

305 return -1;

306 }

307 }

308

        if (finish_command(&helper))

310 return -1;

311 return 0;

312 }

313

static int credential_do(struct credential *c, const char *helper,

315 const char *operation)

316 {

317 struct strbuf cmd = STRBUF_INIT;

318 int r;

319

        if (helper[0] == '!')

                strbuf_addstr(&cmd, helper   1);

        else if (is_absolute_path(helper))

323 strbuf_addstr(&cmd, helper);

324 else

                strbuf_addf(&cmd, "git credential-%s", helper);

326

        strbuf_addf(&cmd, " %s", operation);

        r = run_credential_helper(c, cmd.buf, !strcmp(operation, "get"));

329

330 strbuf_release(&cmd);

331 return r;

332 }

333

void credential_fill(struct credential *c)

335 {

336 int i;

337

        if (c->username && c->password)

339 return;

340

341 credential_apply_config(c);

342

        for (i = 0; i < c->helpers.nr; i  ) {

                credential_do(c, c->helpers.items[i].string, "get");

                if (c->username && c->password)

346 return;

347 if (c->quit)

348 die("credential helper '%s' told us to quit",

                            c->helpers.items[i].string);

350 }

351

352 credential_getpass(c);

        if (!c->username && !c->password)

354 die("unable to get password from user");

355 }

356

void credential_approve(struct credential *c)

358 {

359 int i;

360

361 if (c->approved)

362 return;

        if (!c->username || !c->password)

364 return;

365

366 credential_apply_config(c);

367

        for (i = 0; i < c->helpers.nr; i  )

                credential_do(c, c->helpers.items[i].string, "store");

370 c->approved = 1;

371 }

372

void credential_reject(struct credential *c)

374 {

375 int i;

376

377 credential_apply_config(c);

378

        for (i = 0; i < c->helpers.nr; i  )

                credential_do(c, c->helpers.items[i].string, "erase");

381

382 FREE_AND_NULL(c->username);

383 FREE_AND_NULL(c->password);

384 c->approved = 0;

385 }

386

static int check_url_component(const char *url, int quiet,

                               const char *name, const char *value)

389 {

390 if (!value)

391 return 0;

        if (!strchr(value, '\n'))

393 return 0;

394

395 if (!quiet)

                warning(_("url contains a newline in its %s component: %s"),

397 name, url);

398 return -1;

399 }

400

401 /*

402 * Potentially-partial URLs can, but do not have to, contain

403 *

404 * - a protocol (or scheme) of the form "<protocol>://"

405 *

406 * - a host name (the part after the protocol and before the first slash after

407 * that, if any)

408 *

409 * - a user name and potentially a password (as "<user>[:<password>]@" part of

410 * the host name)

411 *

412 * - a path (the part after the host name, if any, starting with the slash)

413 *

414 * Missing parts will be left unset in `struct credential`. Thus, `https://`

415 * will have only the `protocol` set, `example.com` only the host name, and

416 * `/git` only the path.

417 *

418 * Note that an empty host name in an otherwise fully-qualified URL (e.g.

419 * `cert:///path/to/cert.pem`) will be treated as unset if we expect the URL to

420 * be potentially partial, and only then (otherwise, the empty string is used).

421 *

422 * The credential_from_url() function does not allow partial URLs.

423 */

static int credential_from_url_1(struct credential *c, const char *url,

425 int allow_partial_url, int quiet)

426 {

        const char *at, *colon, *cp, *slash, *host, *proto_end;

428

429 credential_clear(c);

430

431 /*

432 * Match one of:

433 * (1) proto://<host>/...

434 * (2) proto://<user>@<host>/...

435 * (3) proto://<user>:<pass>@<host>/...

436 */

        proto_end = strstr(url, "://");

        if (!allow_partial_url && (!proto_end || proto_end == url)) {

439 if (!quiet)

                        warning(_("url has no scheme: %s"), url);

441 return -1;

442 }

        cp = proto_end ? proto_end   3 : url;

        at = strchr(cp, '@');

        colon = strchr(cp, ':');

446

447 /*

448 * A query or fragment marker before the slash ends the host portion.

449 * We'll just continue to call this "slash" for simplicity. Notably our

450 * "trim leading slashes" part won't skip over this part of the path,

451 * but that's what we'd want.

452 */

        slash = cp   strcspn(cp, "/?#");

454

        if (!at || slash <= at) {

456 /* Case (1) */

457 host = cp;

458 }

        else if (!colon || at <= colon) {

460 /* Case (2) */

                c->username = url_decode_mem(cp, at - cp);

                if (c->username && *c->username)

463 c->username_from_proto = 1;

464 host = at 1;

465 } else {

466 /* Case (3) */

                c->username = url_decode_mem(cp, colon - cp);

                if (c->username && *c->username)

469 c->username_from_proto = 1;

                c->password = url_decode_mem(colon   1, at - (colon   1));

471 host = at 1;

472 }

473

        if (proto_end && proto_end - url > 0)

                c->protocol = xmemdupz(url, proto_end - url);

        if (!allow_partial_url || slash - host > 0)

                c->host = url_decode_mem(host, slash - host);

478 /* Trim leading and trailing slashes from path */

        while (*slash == '/')

480 slash ;

481 if (*slash) {

482 char *p;

                c->path = url_decode(slash);

                p = c->path   strlen(c->path) - 1;

                while (p > c->path && *p == '/')

486 *p-- = '\0';

487 }

488

        if (check_url_component(url, quiet, "username", c->username) < 0 ||

            check_url_component(url, quiet, "password", c->password) < 0 ||

            check_url_component(url, quiet, "protocol", c->protocol) < 0 ||

            check_url_component(url, quiet, "host", c->host) < 0 ||

            check_url_component(url, quiet, "path", c->path) < 0)

494 return -1;

495

496 return 0;

497 }

498

static int credential_from_potentially_partial_url(struct credential *c,

500 const char *url)

501 {

        return credential_from_url_1(c, url, 1, 0);

503 }

504

int credential_from_url_gently(struct credential *c, const char *url, int quiet)

506 {

        return credential_from_url_1(c, url, 0, quiet);

508 }

509

void credential_from_url(struct credential *c, const char *url)

511 {

        if (credential_from_url_gently(c, url, 0) < 0)

                die(_("credential url cannot be parsed: %s"), url);

514 }