git/credential.c

#define USE_THE_REPOSITORY_VARIABLE

#include "git-compat-util.h"
#include "abspath.h"
#include "config.h"
#include "credential.h"
#include "gettext.h"
#include "string-list.h"
#include "run-command.h"
#include "url.h"
#include "prompt.h"
#include "sigchain.h"
#include "strbuf.h"
#include "urlmatch.h"
#include "git-compat-util.h"
#include "trace2.h"
#include "repository.h"

void credential_init(struct credential *c)
{ … }

void credential_clear(struct credential *c)
{ … }

void credential_next_state(struct credential *c)
{ … }

void credential_clear_secrets(struct credential *c)
{ … }

static void credential_set_capability(struct credential_capability *capa,
				      enum credential_op_type op_type)
{ … }


void credential_set_all_capabilities(struct credential *c,
				     enum credential_op_type op_type)
{ … }

static void announce_one(struct credential_capability *cc, const char *name, FILE *fp) { … }

void credential_announce_capabilities(struct credential *c, FILE *fp) { … }

int credential_match(const struct credential *want,
		     const struct credential *have, int match_password)
{ … }


static int credential_from_potentially_partial_url(struct credential *c,
						   const char *url);

static int credential_config_callback(const char *var, const char *value,
				      const struct config_context *ctx UNUSED,
				      void *data)
{ … }

static int proto_is_http(const char *s)
{ … }

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 UNUSED,
		      const struct urlmatch_item *b UNUSED)
{ … }

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

static void credential_apply_config(struct credential *c)
{ … }

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

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

static char *credential_ask_one(const char *what, struct credential *c,
				int flags)
{ … }

static int credential_getpass(struct credential *c)
{ … }

int credential_has_capability(const struct credential_capability *capa,
			      enum credential_op_type op_type)
{ … }

int credential_read(struct credential *c, FILE *fp,
		    enum credential_op_type op_type)
{ … }

static void credential_write_item(FILE *fp, const char *key, const char *value,
				  int required)
{ … }

void credential_write(const struct credential *c, FILE *fp,
		      enum credential_op_type op_type)
{ … }

static int run_credential_helper(struct credential *c,
				 const char *cmd,
				 int want_output)
{ … }

static int credential_do(struct credential *c, const char *helper,
			 const char *operation)
{ … }

void credential_fill(struct credential *c, int all_capabilities)
{ … }

void credential_approve(struct credential *c)
{ … }

void credential_reject(struct credential *c)
{ … }

static int check_url_component(const char *url, int quiet,
			       const char *name, const char *value)
{ … }

/*
 * Potentially-partial URLs can, but do not have to, contain
 *
 * - a protocol (or scheme) of the form "<protocol>://"
 *
 * - a host name (the part after the protocol and before the first slash after
 *   that, if any)
 *
 * - a user name and potentially a password (as "<user>[:<password>]@" part of
 *   the host name)
 *
 * - a path (the part after the host name, if any, starting with the slash)
 *
 * Missing parts will be left unset in `struct credential`. Thus, `https://`
 * will have only the `protocol` set, `example.com` only the host name, and
 * `/git` only the path.
 *
 * Note that an empty host name in an otherwise fully-qualified URL (e.g.
 * `cert:///path/to/cert.pem`) will be treated as unset if we expect the URL to
 * be potentially partial, and only then (otherwise, the empty string is used).
 *
 * The credential_from_url() function does not allow partial URLs.
 */
static int credential_from_url_1(struct credential *c, const char *url,
				 int allow_partial_url, int quiet)
{ … }

static int credential_from_potentially_partial_url(struct credential *c,
						   const char *url)
{ … }

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

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