technical/api-credentials.html - external/gitster/git-htmldocs - Git at Google

 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
  "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
 <head>
 <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=UTF-8" />
 <meta name="generator" content="AsciiDoc 8.6.9" />
 <title>credentials API</title>
 <style type="text/css">
 /* Shared CSS for AsciiDoc xhtml11 and html5 backends */

 /* Default font. */
 body {
  font-family: Georgia,serif;
 }

 /* Title font. */
 h1, h2, h3, h4, h5, h6,
 div.title, caption.title,
 thead, p.table.header,
 #toctitle,
 #author, #revnumber, #revdate, #revremark,
 #footer {
  font-family: Arial,Helvetica,sans-serif;
 }

 body {
  margin: 1em 5% 1em 5%;
 }

 a {
  color: blue;
  text-decoration: underline;
 }
 a:visited {
  color: fuchsia;
 }

 em {
  font-style: italic;
  color: navy;
 }

 strong {
  font-weight: bold;
  color: #083194;
 }

 h1, h2, h3, h4, h5, h6 {
  color: #527bbd;
  margin-top: 1.2em;
  margin-bottom: 0.5em;
  line-height: 1.3;
 }

 h1, h2, h3 {
  border-bottom: 2px solid silver;
 }
 h2 {
  padding-top: 0.5em;
 }
 h3 {
  float: left;
 }
 h3 + * {
  clear: left;
 }
 h5 {
  font-size: 1.0em;
 }

 div.sectionbody {
  margin-left: 0;
 }

 hr {
  border: 1px solid silver;
 }

 p {
  margin-top: 0.5em;
  margin-bottom: 0.5em;
 }

 ul, ol, li > p {
  margin-top: 0;
 }
 ul > li { color: #aaa; }
 ul > li > * { color: black; }

 .monospaced, code, pre {
  font-family: "Courier New", Courier, monospace;
  font-size: inherit;
  color: navy;
  padding: 0;
  margin: 0;
 }
 pre {
  white-space: pre-wrap;
 }

 #author {
  color: #527bbd;
  font-weight: bold;
  font-size: 1.1em;
 }
 #email {
 }
 #revnumber, #revdate, #revremark {
 }

 #footer {
  font-size: small;
  border-top: 2px solid silver;
  padding-top: 0.5em;
  margin-top: 4.0em;
 }
 #footer-text {
  float: left;
  padding-bottom: 0.5em;
 }
 #footer-badges {
  float: right;
  padding-bottom: 0.5em;
 }

 #preamble {
  margin-top: 1.5em;
  margin-bottom: 1.5em;
 }
 div.imageblock, div.exampleblock, div.verseblock,
 div.quoteblock, div.literalblock, div.listingblock, div.sidebarblock,
 div.admonitionblock {
  margin-top: 1.0em;
  margin-bottom: 1.5em;
 }
 div.admonitionblock {
  margin-top: 2.0em;
  margin-bottom: 2.0em;
  margin-right: 10%;
  color: #606060;
 }

 div.content { /* Block element content. */
  padding: 0;
 }

 /* Block element titles. */
 div.title, caption.title {
  color: #527bbd;
  font-weight: bold;
  text-align: left;
  margin-top: 1.0em;
  margin-bottom: 0.5em;
 }
 div.title + * {
  margin-top: 0;
 }

 td div.title:first-child {
  margin-top: 0.0em;
 }
 div.content div.title:first-child {
  margin-top: 0.0em;
 }
 div.content + div.title {
  margin-top: 0.0em;
 }

 div.sidebarblock > div.content {
  background: #ffffee;
  border: 1px solid #dddddd;
  border-left: 4px solid #f0f0f0;
  padding: 0.5em;
 }

 div.listingblock > div.content {
  border: 1px solid #dddddd;
  border-left: 5px solid #f0f0f0;
  background: #f8f8f8;
  padding: 0.5em;
 }

 div.quoteblock, div.verseblock {
  padding-left: 1.0em;
  margin-left: 1.0em;
  margin-right: 10%;
  border-left: 5px solid #f0f0f0;
  color: #888;
 }

 div.quoteblock > div.attribution {
  padding-top: 0.5em;
  text-align: right;
 }

 div.verseblock > pre.content {
  font-family: inherit;
  font-size: inherit;
 }
 div.verseblock > div.attribution {
  padding-top: 0.75em;
  text-align: left;
 }
 /* DEPRECATED: Pre version 8.2.7 verse style literal block. */
 div.verseblock + div.attribution {
  text-align: left;
 }

 div.admonitionblock .icon {
  vertical-align: top;
  font-size: 1.1em;
  font-weight: bold;
  text-decoration: underline;
  color: #527bbd;
  padding-right: 0.5em;
 }
 div.admonitionblock td.content {
  padding-left: 0.5em;
  border-left: 3px solid #dddddd;
 }

 div.exampleblock > div.content {
  border-left: 3px solid #dddddd;
  padding-left: 0.5em;
 }

 div.imageblock div.content { padding-left: 0; }
 span.image img { border-style: none; vertical-align: text-bottom; }
 a.image:visited { color: white; }

 dl {
  margin-top: 0.8em;
  margin-bottom: 0.8em;
 }
 dt {
  margin-top: 0.5em;
  margin-bottom: 0;
  font-style: normal;
  color: navy;
 }
 dd > *:first-child {
  margin-top: 0.1em;
 }

 ul, ol {
  list-style-position: outside;
 }
 ol.arabic {
  list-style-type: decimal;
 }
 ol.loweralpha {
  list-style-type: lower-alpha;
 }
 ol.upperalpha {
  list-style-type: upper-alpha;
 }
 ol.lowerroman {
  list-style-type: lower-roman;
 }
 ol.upperroman {
  list-style-type: upper-roman;
 }

 div.compact ul, div.compact ol,
 div.compact p, div.compact p,
 div.compact div, div.compact div {
  margin-top: 0.1em;
  margin-bottom: 0.1em;
 }

 tfoot {
  font-weight: bold;
 }
 td > div.verse {
  white-space: pre;
 }

 div.hdlist {
  margin-top: 0.8em;
  margin-bottom: 0.8em;
 }
 div.hdlist tr {
  padding-bottom: 15px;
 }
 dt.hdlist1.strong, td.hdlist1.strong {
  font-weight: bold;
 }
 td.hdlist1 {
  vertical-align: top;
  font-style: normal;
  padding-right: 0.8em;
  color: navy;
 }
 td.hdlist2 {
  vertical-align: top;
 }
 div.hdlist.compact tr {
  margin: 0;
  padding-bottom: 0;
 }

 .comment {
  background: yellow;
 }

 .footnote, .footnoteref {
  font-size: 0.8em;
 }

 span.footnote, span.footnoteref {
  vertical-align: super;
 }

 #footnotes {
  margin: 20px 0 20px 0;
  padding: 7px 0 0 0;
 }

 #footnotes div.footnote {
  margin: 0 0 5px 0;
 }

 #footnotes hr {
  border: none;
  border-top: 1px solid silver;
  height: 1px;
  text-align: left;
  margin-left: 0;
  width: 20%;
  min-width: 100px;
 }

 div.colist td {
  padding-right: 0.5em;
  padding-bottom: 0.3em;
  vertical-align: top;
 }
 div.colist td img {
  margin-top: 0.3em;
 }

 @media print {
  #footer-badges { display: none; }
 }

 #toc {
  margin-bottom: 2.5em;
 }

 #toctitle {
  color: #527bbd;
  font-size: 1.1em;
  font-weight: bold;
  margin-top: 1.0em;
  margin-bottom: 0.1em;
 }

 div.toclevel0, div.toclevel1, div.toclevel2, div.toclevel3, div.toclevel4 {
  margin-top: 0;
  margin-bottom: 0;
 }
 div.toclevel2 {
  margin-left: 2em;
  font-size: 0.9em;
 }
 div.toclevel3 {
  margin-left: 4em;
  font-size: 0.9em;
 }
 div.toclevel4 {
  margin-left: 6em;
  font-size: 0.9em;
 }

 span.aqua { color: aqua; }
 span.black { color: black; }
 span.blue { color: blue; }
 span.fuchsia { color: fuchsia; }
 span.gray { color: gray; }
 span.green { color: green; }
 span.lime { color: lime; }
 span.maroon { color: maroon; }
 span.navy { color: navy; }
 span.olive { color: olive; }
 span.purple { color: purple; }
 span.red { color: red; }
 span.silver { color: silver; }
 span.teal { color: teal; }
 span.white { color: white; }
 span.yellow { color: yellow; }

 span.aqua-background { background: aqua; }
 span.black-background { background: black; }
 span.blue-background { background: blue; }
 span.fuchsia-background { background: fuchsia; }
 span.gray-background { background: gray; }
 span.green-background { background: green; }
 span.lime-background { background: lime; }
 span.maroon-background { background: maroon; }
 span.navy-background { background: navy; }
 span.olive-background { background: olive; }
 span.purple-background { background: purple; }
 span.red-background { background: red; }
 span.silver-background { background: silver; }
 span.teal-background { background: teal; }
 span.white-background { background: white; }
 span.yellow-background { background: yellow; }

 span.big { font-size: 2em; }
 span.small { font-size: 0.6em; }

 span.underline { text-decoration: underline; }
 span.overline { text-decoration: overline; }
 span.line-through { text-decoration: line-through; }

 div.unbreakable { page-break-inside: avoid; }


 /*
  * xhtml11 specific
  *
  * */

 div.tableblock {
  margin-top: 1.0em;
  margin-bottom: 1.5em;
 }
 div.tableblock > table {
  border: 3px solid #527bbd;
 }
 thead, p.table.header {
  font-weight: bold;
  color: #527bbd;
 }
 p.table {
  margin-top: 0;
 }
 /* Because the table frame attribute is overriden by CSS in most browsers. */
 div.tableblock > table[frame="void"] {
  border-style: none;
 }
 div.tableblock > table[frame="hsides"] {
  border-left-style: none;
  border-right-style: none;
 }
 div.tableblock > table[frame="vsides"] {
  border-top-style: none;
  border-bottom-style: none;
 }


 /*
  * html5 specific
  *
  * */

 table.tableblock {
  margin-top: 1.0em;
  margin-bottom: 1.5em;
 }
 thead, p.tableblock.header {
  font-weight: bold;
  color: #527bbd;
 }
 p.tableblock {
  margin-top: 0;
 }
 table.tableblock {
  border-width: 3px;
  border-spacing: 0px;
  border-style: solid;
  border-color: #527bbd;
  border-collapse: collapse;
 }
 th.tableblock, td.tableblock {
  border-width: 1px;
  padding: 4px;
  border-style: solid;
  border-color: #527bbd;
 }

 table.tableblock.frame-topbot {
  border-left-style: hidden;
  border-right-style: hidden;
 }
 table.tableblock.frame-sides {
  border-top-style: hidden;
  border-bottom-style: hidden;
 }
 table.tableblock.frame-none {
  border-style: hidden;
 }

 th.tableblock.halign-left, td.tableblock.halign-left {
  text-align: left;
 }
 th.tableblock.halign-center, td.tableblock.halign-center {
  text-align: center;
 }
 th.tableblock.halign-right, td.tableblock.halign-right {
  text-align: right;
 }

 th.tableblock.valign-top, td.tableblock.valign-top {
  vertical-align: top;
 }
 th.tableblock.valign-middle, td.tableblock.valign-middle {
  vertical-align: middle;
 }
 th.tableblock.valign-bottom, td.tableblock.valign-bottom {
  vertical-align: bottom;
 }


 /*
  * manpage specific
  *
  * */

 body.manpage h1 {
  padding-top: 0.5em;
  padding-bottom: 0.5em;
  border-top: 2px solid silver;
  border-bottom: 2px solid silver;
 }
 body.manpage h2 {
  border-style: none;
 }
 body.manpage div.sectionbody {
  margin-left: 3em;
 }

 @media print {
  body.manpage div#toc { display: none; }
 }


 </style>
 <script type="text/javascript">
 /*<![CDATA[*/
 var asciidoc = { // Namespace.

 /////////////////////////////////////////////////////////////////////
 // Table Of Contents generator
 /////////////////////////////////////////////////////////////////////

 /* Author: Mihai Bazon, September 2002
  * http://students.infoiasi.ro/~mishoo
  *
  * Table Of Content generator
  * Version: 0.4
  *
  * Feel free to use this script under the terms of the GNU General Public
  * License, as long as you do not remove or alter this notice.
  */

  /* modified by Troy D. Hanson, September 2006. License: GPL */
  /* modified by Stuart Rackham, 2006, 2009. License: GPL */

 // toclevels = 1..4.
 toc: function (toclevels) {

  function getText(el) {
  var text = "";
  for (var i = el.firstChild; i != null; i = i.nextSibling) {
  if (i.nodeType == 3 /* Node.TEXT_NODE */) // IE doesn't speak constants.
  text += i.data;
  else if (i.firstChild != null)
  text += getText(i);
  }
  return text;
  }

  function TocEntry(el, text, toclevel) {
  this.element = el;
  this.text = text;
  this.toclevel = toclevel;
  }

  function tocEntries(el, toclevels) {
  var result = new Array;
  var re = new RegExp('[hH]([1-'+(toclevels+1)+'])');
  // Function that scans the DOM tree for header elements (the DOM2
  // nodeIterator API would be a better technique but not supported by all
  // browsers).
  var iterate = function (el) {
  for (var i = el.firstChild; i != null; i = i.nextSibling) {
  if (i.nodeType == 1 /* Node.ELEMENT_NODE */) {
  var mo = re.exec(i.tagName);
  if (mo && (i.getAttribute("class") || i.getAttribute("className")) != "float") {
  result[result.length] = new TocEntry(i, getText(i), mo[1]-1);
  }
  iterate(i);
  }
  }
  }
  iterate(el);
  return result;
  }

  var toc = document.getElementById("toc");
  if (!toc) {
  return;
  }

  // Delete existing TOC entries in case we're reloading the TOC.
  var tocEntriesToRemove = [];
  var i;
  for (i = 0; i < toc.childNodes.length; i++) {
  var entry = toc.childNodes[i];
  if (entry.nodeName.toLowerCase() == 'div'
  && entry.getAttribute("class")
  && entry.getAttribute("class").match(/^toclevel/))
  tocEntriesToRemove.push(entry);
  }
  for (i = 0; i < tocEntriesToRemove.length; i++) {
  toc.removeChild(tocEntriesToRemove[i]);
  }

  // Rebuild TOC entries.
  var entries = tocEntries(document.getElementById("content"), toclevels);
  for (var i = 0; i < entries.length; ++i) {
  var entry = entries[i];
  if (entry.element.id == "")
  entry.element.id = "_toc_" + i;
  var a = document.createElement("a");
  a.href = "#" + entry.element.id;
  a.appendChild(document.createTextNode(entry.text));
  var div = document.createElement("div");
  div.appendChild(a);
  div.className = "toclevel" + entry.toclevel;
  toc.appendChild(div);
  }
  if (entries.length == 0)
  toc.parentNode.removeChild(toc);
 },


 /////////////////////////////////////////////////////////////////////
 // Footnotes generator
 /////////////////////////////////////////////////////////////////////

 /* Based on footnote generation code from:
  * http://www.brandspankingnew.net/archive/2005/07/format_footnote.html
  */

 footnotes: function () {
  // Delete existing footnote entries in case we're reloading the footnodes.
  var i;
  var noteholder = document.getElementById("footnotes");
  if (!noteholder) {
  return;
  }
  var entriesToRemove = [];
  for (i = 0; i < noteholder.childNodes.length; i++) {
  var entry = noteholder.childNodes[i];
  if (entry.nodeName.toLowerCase() == 'div' && entry.getAttribute("class") == "footnote")
  entriesToRemove.push(entry);
  }
  for (i = 0; i < entriesToRemove.length; i++) {
  noteholder.removeChild(entriesToRemove[i]);
  }

  // Rebuild footnote entries.
  var cont = document.getElementById("content");
  var spans = cont.getElementsByTagName("span");
  var refs = {};
  var n = 0;
  for (i=0; i<spans.length; i++) {
  if (spans[i].className == "footnote") {
  n++;
  var note = spans[i].getAttribute("data-note");
  if (!note) {
  // Use [\s\S] in place of . so multi-line matches work.
  // Because JavaScript has no s (dotall) regex flag.
  note = spans[i].innerHTML.match(/\s*\[([\s\S]*)]\s*/)[1];
  spans[i].innerHTML =
  "[<a id='_footnoteref_" + n + "' href='#_footnote_" + n +
  "' title='View footnote' class='footnote'>" + n + "</a>]";
  spans[i].setAttribute("data-note", note);
  }
  noteholder.innerHTML +=
  "<div class='footnote' id='_footnote_" + n + "'>" +
  "<a href='#_footnoteref_" + n + "' title='Return to text'>" +
  n + "</a>. " + note + "</div>";
  var id =spans[i].getAttribute("id");
  if (id != null) refs["#"+id] = n;
  }
  }
  if (n == 0)
  noteholder.parentNode.removeChild(noteholder);
  else {
  // Process footnoterefs.
  for (i=0; i<spans.length; i++) {
  if (spans[i].className == "footnoteref") {
  var href = spans[i].getElementsByTagName("a")[0].getAttribute("href");
  href = href.match(/#.*/)[0]; // Because IE return full URL.
  n = refs[href];
  spans[i].innerHTML =
  "[<a href='#_footnote_" + n +
  "' title='View footnote' class='footnote'>" + n + "</a>]";
  }
  }
  }
 },

 install: function(toclevels) {
  var timerId;

  function reinstall() {
  asciidoc.footnotes();
  if (toclevels) {
  asciidoc.toc(toclevels);
  }
  }

  function reinstallAndRemoveTimer() {
  clearInterval(timerId);
  reinstall();
  }

  timerId = setInterval(reinstall, 500);
  if (document.addEventListener)
  document.addEventListener("DOMContentLoaded", reinstallAndRemoveTimer, false);
  else
  window.onload = reinstallAndRemoveTimer;
 }

 }
 asciidoc.install();
 /*]]>*/
 </script>
 </head>
 <body class="article">
 <div id="header">
 <h1>credentials API</h1>
 </div>
 <div id="content">
 <div id="preamble">
 <div class="sectionbody">
 <div class="paragraph"><p>The credentials API provides an abstracted way of gathering username and
 password credentials from the user (even though credentials in the wider
 world can take many forms, in this document the word "credential" always
 refers to a username and password pair).</p></div>
 <div class="paragraph"><p>This document describes two interfaces: the C API that the credential
 subsystem provides to the rest of Git, and the protocol that Git uses to
 communicate with system-specific "credential helpers". If you are
 writing Git code that wants to look up or prompt for credentials, see
 the section "C API" below. If you want to write your own helper, see
 the section on "Credential Helpers" below.</p></div>
 </div>
 </div>
 <div class="sect1">
 <h2 id="_typical_setup">Typical setup</h2>
 <div class="sectionbody">
 <div class="listingblock">
 <div class="content">
 <pre><code>+-----------------------+
 | Git code (C) |--- to server requiring ---&gt;
 | | authentication
 |.......................|
 | C credential API |--- prompt ---&gt; User
 +-----------------------+
  ^ |
  | pipe |
  | v
 +-----------------------+
 | Git credential helper |
 +-----------------------+</code></pre>
 </div></div>
 <div class="paragraph"><p>The Git code (typically a remote-helper) will call the C API to obtain
 credential data like a login/password pair (credential_fill). The
 API will itself call a remote helper (e.g. "git credential-cache" or
 "git credential-store") that may retrieve credential data from a
 store. If the credential helper cannot find the information, the C API
 will prompt the user. Then, the caller of the API takes care of
 contacting the server, and does the actual authentication.</p></div>
 </div>
 </div>
 <div class="sect1">
 <h2 id="_c_api">C API</h2>
 <div class="sectionbody">
 <div class="paragraph"><p>The credential C API is meant to be called by Git code which needs to
 acquire or store a credential. It is centered around an object
 representing a single credential and provides three basic operations:
 fill (acquire credentials by calling helpers and/or prompting the user),
 approve (mark a credential as successfully used so that it can be stored
 for later use), and reject (mark a credential as unsuccessful so that it
 can be erased from any persistent storage).</p></div>
 <div class="sect2">
 <h3 id="_data_structures">Data Structures</h3>
 <div class="dlist"><dl>
 <dt class="hdlist1">
 <code>struct credential</code>
 </dt>
 <dd>
 <p>
  This struct represents a single username/password combination
  along with any associated context. All string fields should be
  heap-allocated (or NULL if they are not known or not applicable).
  The meaning of the individual context fields is the same as
  their counterparts in the helper protocol; see the section below
  for a description of each field.
 </p>
 <div class="paragraph"><p>The <code>helpers</code> member of the struct is a <code>string_list</code> of helpers. Each
 string specifies an external helper which will be run, in order, to
 either acquire or store credentials. See the section on credential
 helpers below. This list is filled-in by the API functions
 according to the corresponding configuration variables before
 consulting helpers, so there usually is no need for a caller to
 modify the helpers field at all.</p></div>
 <div class="paragraph"><p>This struct should always be initialized with <code>CREDENTIAL_INIT</code> or
 <code>credential_init</code>.</p></div>
 </dd>
 </dl></div>
 </div>
 <div class="sect2">
 <h3 id="_functions">Functions</h3>
 <div class="dlist"><dl>
 <dt class="hdlist1">
 <code>credential_init</code>
 </dt>
 <dd>
 <p>
  Initialize a credential structure, setting all fields to empty.
 </p>
 </dd>
 <dt class="hdlist1">
 <code>credential_clear</code>
 </dt>
 <dd>
 <p>
  Free any resources associated with the credential structure,
  returning it to a pristine initialized state.
 </p>
 </dd>
 <dt class="hdlist1">
 <code>credential_fill</code>
 </dt>
 <dd>
 <p>
  Instruct the credential subsystem to fill the username and
  password fields of the passed credential struct by first
  consulting helpers, then asking the user. After this function
  returns, the username and password fields of the credential are
  guaranteed to be non-NULL. If an error occurs, the function will
  die().
 </p>
 </dd>
 <dt class="hdlist1">
 <code>credential_reject</code>
 </dt>
 <dd>
 <p>
  Inform the credential subsystem that the provided credentials
  have been rejected. This will cause the credential subsystem to
  notify any helpers of the rejection (which allows them, for
  example, to purge the invalid credentials from storage). It
  will also free() the username and password fields of the
  credential and set them to NULL (readying the credential for
  another call to <code>credential_fill</code>). Any errors from helpers are
  ignored.
 </p>
 </dd>
 <dt class="hdlist1">
 <code>credential_approve</code>
 </dt>
 <dd>
 <p>
  Inform the credential subsystem that the provided credentials
  were successfully used for authentication. This will cause the
  credential subsystem to notify any helpers of the approval, so
  that they may store the result to be used again. Any errors
  from helpers are ignored.
 </p>
 </dd>
 <dt class="hdlist1">
 <code>credential_from_url</code>
 </dt>
 <dd>
 <p>
  Parse a URL into broken-down credential fields.
 </p>
 </dd>
 </dl></div>
 </div>
 <div class="sect2">
 <h3 id="_example">Example</h3>
 <div class="paragraph"><p>The example below shows how the functions of the credential API could be
 used to login to a fictitious "foo" service on a remote host:</p></div>
 <div class="listingblock">
 <div class="content">
 <pre><code>int foo_login(struct foo_connection *f)
 {
  int status;
  /*
  * Create a credential with some context; we don't yet know the
  * username or password.
  */

  struct credential c = CREDENTIAL_INIT;
  c.protocol = xstrdup("foo");
  c.host = xstrdup(f-&gt;hostname);

  /*
  * Fill in the username and password fields by contacting
  * helpers and/or asking the user. The function will die if it
  * fails.
  */
  credential_fill(&amp;c);

  /*
  * Otherwise, we have a username and password. Try to use it.
  */
  status = send_foo_login(f, c.username, c.password);
  switch (status) {
  case FOO_OK:
  /* It worked. Store the credential for later use. */
  credential_accept(&amp;c);
  break;
  case FOO_BAD_LOGIN:
  /* Erase the credential from storage so we don't try it
  * again. */
  credential_reject(&amp;c);
  break;
  default:
  /*
  * Some other error occurred. We don't know if the
  * credential is good or bad, so report nothing to the
  * credential subsystem.
  */
  }

  /* Free any associated resources. */
  credential_clear(&amp;c);

  return status;
 }</code></pre>
 </div></div>
 </div>
 </div>
 </div>
 <div class="sect1">
 <h2 id="_credential_helpers">Credential Helpers</h2>
 <div class="sectionbody">
 <div class="paragraph"><p>Credential helpers are programs executed by Git to fetch or save
 credentials from and to long-term storage (where "long-term" is simply
 longer than a single Git process; e.g., credentials may be stored
 in-memory for a few minutes, or indefinitely on disk).</p></div>
 <div class="paragraph"><p>Each helper is specified by a single string in the configuration
 variable <code>credential.helper</code> (and others, see <a href="../git-config.html">git-config(1)</a>).
 The string is transformed by Git into a command to be executed using
 these rules:</p></div>
 <div class="olist arabic"><ol class="arabic">
 <li>
 <p>
 If the helper string begins with "!", it is considered a shell
  snippet, and everything after the "!" becomes the command.
 </p>
 </li>
 <li>
 <p>
 Otherwise, if the helper string begins with an absolute path, the
  verbatim helper string becomes the command.
 </p>
 </li>
 <li>
 <p>
 Otherwise, the string "git credential-" is prepended to the helper
  string, and the result becomes the command.
 </p>
 </li>
 </ol></div>
 <div class="paragraph"><p>The resulting command then has an "operation" argument appended to it
 (see below for details), and the result is executed by the shell.</p></div>
 <div class="paragraph"><p>Here are some example specifications:</p></div>
 <div class="listingblock">
 <div class="content">
 <pre><code># run "git credential-foo"
 foo

 # same as above, but pass an argument to the helper
 foo --bar=baz

 # the arguments are parsed by the shell, so use shell
 # quoting if necessary
 foo --bar="whitespace arg"

 # you can also use an absolute path, which will not use the git wrapper
 /path/to/my/helper --with-arguments

 # or you can specify your own shell snippet
 !f() { echo "password=`cat $HOME/.secret`"; }; f</code></pre>
 </div></div>
 <div class="paragraph"><p>Generally speaking, rule (3) above is the simplest for users to specify.
 Authors of credential helpers should make an effort to assist their
 users by naming their program "git-credential-$NAME", and putting it in
 the $PATH or $GIT_EXEC_PATH during installation, which will allow a user
 to enable it with <code>git config credential.helper $NAME</code>.</p></div>
 <div class="paragraph"><p>When a helper is executed, it will have one "operation" argument
 appended to its command line, which is one of:</p></div>
 <div class="dlist"><dl>
 <dt class="hdlist1">
 <code>get</code>
 </dt>
 <dd>
 <p>
  Return a matching credential, if any exists.
 </p>
 </dd>
 <dt class="hdlist1">
 <code>store</code>
 </dt>
 <dd>
 <p>
  Store the credential, if applicable to the helper.
 </p>
 </dd>
 <dt class="hdlist1">
 <code>erase</code>
 </dt>
 <dd>
 <p>
  Remove a matching credential, if any, from the helper&#8217;s storage.
 </p>
 </dd>
 </dl></div>
 <div class="paragraph"><p>The details of the credential will be provided on the helper&#8217;s stdin
 stream. The exact format is the same as the input/output format of the
 <code>git credential</code> plumbing command (see the section <code>INPUT/OUTPUT
 FORMAT</code> in <a href="../git-credential.html">git-credential(7)</a> for a detailed specification).</p></div>
 <div class="paragraph"><p>For a <code>get</code> operation, the helper should produce a list of attributes
 on stdout in the same format. A helper is free to produce a subset, or
 even no values at all if it has nothing useful to provide. Any provided
 attributes will overwrite those already known about by Git. If a helper
 outputs a <code>quit</code> attribute with a value of <code>true</code> or <code>1</code>, no further
 helpers will be consulted, nor will the user be prompted (if no
 credential has been provided, the operation will then fail).</p></div>
 <div class="paragraph"><p>For a <code>store</code> or <code>erase</code> operation, the helper&#8217;s output is ignored.
 If it fails to perform the requested operation, it may complain to
 stderr to inform the user. If it does not support the requested
 operation (e.g., a read-only store), it should silently ignore the
 request.</p></div>
 <div class="paragraph"><p>If a helper receives any other operation, it should silently ignore the
 request. This leaves room for future operations to be added (older
 helpers will just ignore the new requests).</p></div>
 </div>
 </div>
 <div class="sect1">
 <h2 id="_see_also">See also</h2>
 <div class="sectionbody">
 <div class="paragraph"><p><a href="../gitcredentials.html">gitcredentials(7)</a></p></div>
 <div class="paragraph"><p><a href="../git-config.html">git-config(5)</a> (See configuration variables <code>credential.*</code>)</p></div>
 </div>
 </div>
 </div>
 <div id="footnotes"><hr /></div>
 <div id="footer">
 <div id="footer-text">
 Last updated 2014-12-22 14:47:31 PST
 </div>
 </div>
 </body>
 </html>