make the sender advertise shallow commits to the receiver
[git/git.git] / Documentation / technical / pack-protocol.txt
CommitLineData
b31222cf
SC
1Packfile transfer protocols
2===========================
3
4Git supports transferring data in packfiles over the ssh://, git:// and
5file:// transports. There exist two sets of protocols, one for pushing
6data from a client to a server and another for fetching data from a
7server to a client. All three transports (ssh, git, file) use the same
8protocol to transfer data.
9
10The processes invoked in the canonical Git implementation are 'upload-pack'
11on the server side and 'fetch-pack' on the client side for fetching data;
12then 'receive-pack' on the server and 'send-pack' on the client for pushing
13data. The protocol functions to have a server tell a client what is
14currently on the server, then for the two to negotiate the smallest amount
15of data to send in order to fully update one or the other.
16
17Transports
18----------
19There are three transports over which the packfile protocol is
20initiated. The Git transport is a simple, unauthenticated server that
21takes the command (almost always 'upload-pack', though Git
22servers can be configured to be globally writable, in which 'receive-
23pack' initiation is also allowed) with which the client wishes to
24communicate and executes it and connects it to the requesting
25process.
26
27In the SSH transport, the client just runs the 'upload-pack'
28or 'receive-pack' process on the server over the SSH protocol and then
29communicates with that invoked process over the SSH connection.
30
31The file:// transport runs the 'upload-pack' or 'receive-pack'
32process locally and communicates with it over a pipe.
33
34Git Transport
35-------------
36
37The Git transport starts off by sending the command and repository
38on the wire using the pkt-line format, followed by a NUL byte and a
8e50175d 39hostname parameter, terminated by a NUL byte.
b31222cf
SC
40
41 0032git-upload-pack /project.git\0host=myserver.com\0
42
43--
44 git-proto-request = request-command SP pathname NUL [ host-parameter NUL ]
45 request-command = "git-upload-pack" / "git-receive-pack" /
46 "git-upload-archive" ; case sensitive
47 pathname = *( %x01-ff ) ; exclude NUL
48 host-parameter = "host=" hostname [ ":" port ]
49--
50
51Only host-parameter is allowed in the git-proto-request. Clients
52MUST NOT attempt to send additional parameters. It is used for the
53git-daemon name based virtual hosting. See --interpolated-path
54option to git daemon, with the %H/%CH format characters.
55
56Basically what the Git client is doing to connect to an 'upload-pack'
57process on the server side over the Git protocol is this:
58
59 $ echo -e -n \
60 "0039git-upload-pack /schacon/gitbook.git\0host=example.com\0" |
61 nc -v example.com 9418
62
d78e5aec
NTND
63If the server refuses the request for some reasons, it could abort
64gracefully with an error message.
65
66----
67 error-line = PKT-LINE("ERR" SP explanation-text)
68----
69
b31222cf
SC
70
71SSH Transport
72-------------
73
74Initiating the upload-pack or receive-pack processes over SSH is
75executing the binary on the server via SSH remote execution.
76It is basically equivalent to running this:
77
78 $ ssh git.example.com "git-upload-pack '/project.git'"
79
80For a server to support Git pushing and pulling for a given user over
81SSH, that user needs to be able to execute one or both of those
82commands via the SSH shell that they are provided on login. On some
83systems, that shell access is limited to only being able to run those
84two commands, or even just one of them.
85
86In an ssh:// format URI, it's absolute in the URI, so the '/' after
87the host name (or port number) is sent as an argument, which is then
88read by the remote git-upload-pack exactly as is, so it's effectively
89an absolute path in the remote filesystem.
90
91 git clone ssh://user@example.com/project.git
92 |
93 v
94 ssh user@example.com "git-upload-pack '/project.git'"
95
96In a "user@host:path" format URI, its relative to the user's home
97directory, because the Git client will run:
98
99 git clone user@example.com:project.git
100 |
101 v
102 ssh user@example.com "git-upload-pack 'project.git'"
103
104The exception is if a '~' is used, in which case
105we execute it without the leading '/'.
106
107 ssh://user@example.com/~alice/project.git,
108 |
109 v
110 ssh user@example.com "git-upload-pack '~alice/project.git'"
111
112A few things to remember here:
113
114- The "command name" is spelled with dash (e.g. git-upload-pack), but
115 this can be overridden by the client;
116
117- The repository path is always quoted with single quotes.
118
119Fetching Data From a Server
5316c8e9 120---------------------------
b31222cf
SC
121
122When one Git repository wants to get data that a second repository
123has, the first can 'fetch' from the second. This operation determines
124what data the server has that the client does not then streams that
125data down to the client in packfile format.
126
127
128Reference Discovery
129-------------------
130
131When the client initially connects the server will immediately respond
132with a listing of each reference it has (all branches and tags) along
133with the object name that each reference currently points to.
134
135 $ echo -e -n "0039git-upload-pack /schacon/gitbook.git\0host=example.com\0" |
136 nc -v example.com 9418
5316c8e9
TA
137 00887217a7c7e582c46cec22a130adf4b9d7d950fba0 HEAD\0multi_ack thin-pack
138 side-band side-band-64k ofs-delta shallow no-progress include-tag
b31222cf
SC
139 00441d3fcd5ced445d1abc402225c0b8a1299641f497 refs/heads/integration
140 003f7217a7c7e582c46cec22a130adf4b9d7d950fba0 refs/heads/master
141 003cb88d2441cac0977faf98efc80305012112238d9d refs/tags/v0.9
142 003c525128480b96c89e6418b1e40909bf6c5b2d580f refs/tags/v1.0
143 003fe92df48743b7bc7d26bcaabfddde0a1e20cae47c refs/tags/v1.0^{}
144 0000
145
146Server SHOULD terminate each non-flush line using LF ("\n") terminator;
147client MUST NOT complain if there is no terminator.
148
149The returned response is a pkt-line stream describing each ref and
150its current value. The stream MUST be sorted by name according to
151the C locale ordering.
152
153If HEAD is a valid ref, HEAD MUST appear as the first advertised
154ref. If HEAD is not a valid ref, HEAD MUST NOT appear in the
155advertisement list at all, but other refs may still appear.
156
157The stream MUST include capability declarations behind a NUL on the
158first ref. The peeled value of a ref (that is "ref^{}") MUST be
159immediately after the ref itself, if presented. A conforming server
6a5d0b0a 160MUST peel the ref if it's an annotated tag.
b31222cf
SC
161
162----
163 advertised-refs = (no-refs / list-of-refs)
ad491366 164 *shallow
b31222cf
SC
165 flush-pkt
166
167 no-refs = PKT-LINE(zero-id SP "capabilities^{}"
168 NUL capability-list LF)
169
170 list-of-refs = first-ref *other-ref
171 first-ref = PKT-LINE(obj-id SP refname
172 NUL capability-list LF)
173
174 other-ref = PKT-LINE(other-tip / other-peeled)
175 other-tip = obj-id SP refname LF
176 other-peeled = obj-id SP refname "^{}" LF
177
ad491366
NTND
178 shallow = PKT-LINE("shallow" SP obj-id)
179
b31222cf
SC
180 capability-list = capability *(SP capability)
181 capability = 1*(LC_ALPHA / DIGIT / "-" / "_")
182 LC_ALPHA = %x61-7A
183----
184
185Server and client MUST use lowercase for obj-id, both MUST treat obj-id
186as case-insensitive.
187
188See protocol-capabilities.txt for a list of allowed server capabilities
189and descriptions.
190
191Packfile Negotiation
192--------------------
a1e90b23
AN
193After reference and capabilities discovery, the client can decide to
194terminate the connection by sending a flush-pkt, telling the server it can
195now gracefully terminate, and disconnect, when it does not need any pack
196data. This can happen with the ls-remote command, and also can happen when
197the client already is up-to-date.
198
199Otherwise, it enters the negotiation phase, where the client and
200server determine what the minimal packfile necessary for transport is,
4a1c2695
AN
201by telling the server what objects it wants, its shallow objects
202(if any), and the maximum commit depth it wants (if any). The client
203will also send a list of the capabilities it wants to be in effect,
204out of what the server said it could do with the first 'want' line.
b31222cf
SC
205
206----
207 upload-request = want-list
4a1c2695
AN
208 *shallow-line
209 *1depth-request
210 flush-pkt
b31222cf
SC
211
212 want-list = first-want
213 *additional-want
4a1c2695
AN
214
215 shallow-line = PKT_LINE("shallow" SP obj-id)
216
217 depth-request = PKT_LINE("deepen" SP depth)
b31222cf
SC
218
219 first-want = PKT-LINE("want" SP obj-id SP capability-list LF)
220 additional-want = PKT-LINE("want" SP obj-id LF)
221
4a1c2695 222 depth = 1*DIGIT
b31222cf
SC
223----
224
225Clients MUST send all the obj-ids it wants from the reference
226discovery phase as 'want' lines. Clients MUST send at least one
227'want' command in the request body. Clients MUST NOT mention an
228obj-id in a 'want' command which did not appear in the response
229obtained through ref discovery.
230
4a1c2695
AN
231The client MUST write all obj-ids which it only has shallow copies
232of (meaning that it does not have the parents of a commit) as
233'shallow' lines so that the server is aware of the limitations of
af04fa2a 234the client's history.
4a1c2695
AN
235
236The client now sends the maximum commit history depth it wants for
237this transaction, which is the number of commits it wants from the
238tip of the history, if any, as a 'deepen' line. A depth of 0 is the
239same as not making a depth request. The client does not want to receive
240any commits beyond this depth, nor objects needed only to complete
241those commits. Commits whose parents are not received as a result are
242defined as shallow and marked as such in the server. This information
243is sent back to the client in the next step.
244
245Once all the 'want's and 'shallow's (and optional 'deepen') are
246transferred, clients MUST send a flush-pkt, to tell the server side
247that it is done sending the list.
248
249Otherwise, if the client sent a positive depth request, the server
250will determine which commits will and will not be shallow and
251send this information to the client. If the client did not request
252a positive depth, this step is skipped.
b31222cf 253
4a1c2695
AN
254----
255 shallow-update = *shallow-line
256 *unshallow-line
257 flush-pkt
b31222cf 258
4a1c2695
AN
259 shallow-line = PKT-LINE("shallow" SP obj-id)
260
261 unshallow-line = PKT-LINE("unshallow" SP obj-id)
262----
263
264If the client has requested a positive depth, the server will compute
01f7d7f1
PO
265the set of commits which are no deeper than the desired depth. The set
266of commits start at the client's wants.
267
268The server writes 'shallow' lines for each
4a1c2695
AN
269commit whose parents will not be sent as a result. The server writes
270an 'unshallow' line for each commit which the client has indicated is
271shallow, but is no longer shallow at the currently requested depth
272(that is, its parents will now be sent). The server MUST NOT mark
273as unshallow anything which the client has not indicated was shallow.
b31222cf
SC
274
275Now the client will send a list of the obj-ids it has using 'have'
4a1c2695
AN
276lines, so the server can make a packfile that only contains the objects
277that the client needs. In multi_ack mode, the canonical implementation
278will send up to 32 of these at a time, then will send a flush-pkt. The
279canonical implementation will skip ahead and send the next 32 immediately,
280so that there is always a block of 32 "in-flight on the wire" at a time.
281
282----
283 upload-haves = have-list
284 compute-end
285
286 have-list = *have-line
287 have-line = PKT-LINE("have" SP obj-id LF)
288 compute-end = flush-pkt / PKT-LINE("done")
289----
b31222cf
SC
290
291If the server reads 'have' lines, it then will respond by ACKing any
292of the obj-ids the client said it had that the server also has. The
293server will ACK obj-ids differently depending on which ack mode is
294chosen by the client.
295
296In multi_ack mode:
297
298 * the server will respond with 'ACK obj-id continue' for any common
299 commits.
300
301 * once the server has found an acceptable common base commit and is
302 ready to make a packfile, it will blindly ACK all 'have' obj-ids
303 back to the client.
304
305 * the server will then send a 'NACK' and then wait for another response
306 from the client - either a 'done' or another list of 'have' lines.
307
308In multi_ack_detailed mode:
309
310 * the server will differentiate the ACKs where it is signaling
311 that it is ready to send data with 'ACK obj-id ready' lines, and
312 signals the identified common commits with 'ACK obj-id common' lines.
313
314Without either multi_ack or multi_ack_detailed:
315
316 * upload-pack sends "ACK obj-id" on the first common object it finds.
317 After that it says nothing until the client gives it a "done".
318
319 * upload-pack sends "NAK" on a flush-pkt if no common object
320 has been found yet. If one has been found, and thus an ACK
6a5d0b0a 321 was already sent, it's silent on the flush-pkt.
b31222cf
SC
322
323After the client has gotten enough ACK responses that it can determine
324that the server has enough information to send an efficient packfile
325(in the canonical implementation, this is determined when it has received
326enough ACKs that it can color everything left in the --date-order queue
327as common with the server, or the --date-order queue is empty), or the
328client determines that it wants to give up (in the canonical implementation,
329this is determined when the client sends 256 'have' lines without getting
330any of them ACKed by the server - meaning there is nothing in common and
6a5d0b0a 331the server should just send all of its objects), then the client will send
b31222cf 332a 'done' command. The 'done' command signals to the server that the client
6a5d0b0a 333is ready to receive its packfile data.
b31222cf
SC
334
335However, the 256 limit *only* turns on in the canonical client
336implementation if we have received at least one "ACK %s continue"
337during a prior round. This helps to ensure that at least one common
338ancestor is found before we give up entirely.
339
340Once the 'done' line is read from the client, the server will either
341send a final 'ACK obj-id' or it will send a 'NAK'. The server only sends
342ACK after 'done' if there is at least one common base and multi_ack or
343multi_ack_detailed is enabled. The server always sends NAK after 'done'
344if there is no common base found.
345
6a5d0b0a 346Then the server will start sending its packfile data.
b31222cf
SC
347
348----
349 server-response = *ack_multi ack / nak
350 ack_multi = PKT-LINE("ACK" SP obj-id ack_status LF)
351 ack_status = "continue" / "common" / "ready"
352 ack = PKT-LINE("ACK SP obj-id LF)
353 nak = PKT-LINE("NAK" LF)
354----
355
356A simple clone may look like this (with no 'have' lines):
357
358----
79135e4c 359 C: 0054want 74730d410fcb6603ace96f1dc55ea6196122532d multi_ack \
b31222cf
SC
360 side-band-64k ofs-delta\n
361 C: 0032want 7d1665144a3a975c05f1f43902ddaf084e784dbe\n
362 C: 0032want 5a3f6be755bbb7deae50065988cbfa1ffa9ab68a\n
363 C: 0032want 7e47fe2bd8d01d481f44d7af0531bd93d3b21c01\n
364 C: 0032want 74730d410fcb6603ace96f1dc55ea6196122532d\n
365 C: 0000
366 C: 0009done\n
367
368 S: 0008NAK\n
369 S: [PACKFILE]
370----
371
372An incremental update (fetch) response might look like this:
373
374----
79135e4c 375 C: 0054want 74730d410fcb6603ace96f1dc55ea6196122532d multi_ack \
b31222cf
SC
376 side-band-64k ofs-delta\n
377 C: 0032want 7d1665144a3a975c05f1f43902ddaf084e784dbe\n
378 C: 0032want 5a3f6be755bbb7deae50065988cbfa1ffa9ab68a\n
379 C: 0000
380 C: 0032have 7e47fe2bd8d01d481f44d7af0531bd93d3b21c01\n
381 C: [30 more have lines]
382 C: 0032have 74730d410fcb6603ace96f1dc55ea6196122532d\n
383 C: 0000
384
385 S: 003aACK 7e47fe2bd8d01d481f44d7af0531bd93d3b21c01 continue\n
386 S: 003aACK 74730d410fcb6603ace96f1dc55ea6196122532d continue\n
387 S: 0008NAK\n
388
389 C: 0009done\n
390
c8a97906 391 S: 0031ACK 74730d410fcb6603ace96f1dc55ea6196122532d\n
b31222cf
SC
392 S: [PACKFILE]
393----
394
395
396Packfile Data
397-------------
398
399Now that the client and server have finished negotiation about what
400the minimal amount of data that needs to be sent to the client is, the server
401will construct and send the required data in packfile format.
402
403See pack-format.txt for what the packfile itself actually looks like.
404
405If 'side-band' or 'side-band-64k' capabilities have been specified by
406the client, the server will send the packfile data multiplexed.
407
408Each packet starting with the packet-line length of the amount of data
409that follows, followed by a single byte specifying the sideband the
410following data is coming in on.
411
412In 'side-band' mode, it will send up to 999 data bytes plus 1 control
413code, for a total of up to 1000 bytes in a pkt-line. In 'side-band-64k'
414mode it will send up to 65519 data bytes plus 1 control code, for a
415total of up to 65520 bytes in a pkt-line.
416
417The sideband byte will be a '1', '2' or a '3'. Sideband '1' will contain
418packfile data, sideband '2' will be used for progress information that the
419client will generally print to stderr and sideband '3' is used for error
420information.
421
422If no 'side-band' capability was specified, the server will stream the
423entire packfile without multiplexing.
424
425
426Pushing Data To a Server
5316c8e9 427------------------------
b31222cf
SC
428
429Pushing data to a server will invoke the 'receive-pack' process on the
430server, which will allow the client to tell it which references it should
431update and then send all the data the server will need for those new
432references to be complete. Once all the data is received and validated,
433the server will then update its references to what the client specified.
434
435Authentication
436--------------
437
438The protocol itself contains no authentication mechanisms. That is to be
439handled by the transport, such as SSH, before the 'receive-pack' process is
440invoked. If 'receive-pack' is configured over the Git transport, those
441repositories will be writable by anyone who can access that port (9418) as
442that transport is unauthenticated.
443
444Reference Discovery
445-------------------
446
447The reference discovery phase is done nearly the same way as it is in the
448fetching protocol. Each reference obj-id and name on the server is sent
449in packet-line format to the client, followed by a flush-pkt. The only
450real difference is that the capability listing is different - the only
451possible values are 'report-status', 'delete-refs' and 'ofs-delta'.
452
453Reference Update Request and Packfile Transfer
454----------------------------------------------
455
456Once the client knows what references the server is at, it can send a
457list of reference update requests. For each reference on the server
458that it wants to update, it sends a line listing the obj-id currently on
459the server, the obj-id the client would like to update it to and the name
460of the reference.
461
462This list is followed by a flush-pkt and then the packfile that should
463contain all the objects that the server will need to complete the new
464references.
465
466----
467 update-request = command-list [pack-file]
468
469 command-list = PKT-LINE(command NUL capability-list LF)
470 *PKT-LINE(command LF)
471 flush-pkt
472
473 command = create / delete / update
474 create = zero-id SP new-id SP name
475 delete = old-id SP zero-id SP name
476 update = old-id SP new-id SP name
477
478 old-id = obj-id
479 new-id = obj-id
480
481 pack-file = "PACK" 28*(OCTET)
482----
483
484If the receiving end does not support delete-refs, the sending end MUST
485NOT ask for delete command.
486
487The pack-file MUST NOT be sent if the only command used is 'delete'.
488
489A pack-file MUST be sent if either create or update command is used,
490even if the server already has all the necessary objects. In this
491case the client MUST send an empty pack-file. The only time this
492is likely to happen is if the client is creating
493a new branch or a tag that points to an existing obj-id.
494
495The server will receive the packfile, unpack it, then validate each
496reference that is being updated that it hasn't changed while the request
497was being processed (the obj-id is still the same as the old-id), and
498it will run any update hooks to make sure that the update is acceptable.
499If all of that is fine, the server will then update the references.
500
501Report Status
502-------------
503
504After receiving the pack data from the sender, the receiver sends a
505report if 'report-status' capability is in effect.
506It is a short listing of what happened in that update. It will first
507list the status of the packfile unpacking as either 'unpack ok' or
508'unpack [error]'. Then it will list the status for each of the references
509that it tried to update. Each line is either 'ok [refname]' if the
510update was successful, or 'ng [refname] [error]' if the update was not.
511
512----
513 report-status = unpack-status
514 1*(command-status)
515 flush-pkt
516
517 unpack-status = PKT-LINE("unpack" SP unpack-result LF)
518 unpack-result = "ok" / error-msg
519
520 command-status = command-ok / command-fail
521 command-ok = PKT-LINE("ok" SP refname LF)
522 command-fail = PKT-LINE("ng" SP refname SP error-msg LF)
523
524 error-msg = 1*(OCTECT) ; where not "ok"
525----
526
527Updates can be unsuccessful for a number of reasons. The reference can have
528changed since the reference discovery phase was originally sent, meaning
529someone pushed in the meantime. The reference being pushed could be a
530non-fast-forward reference and the update hooks or configuration could be
531set to not allow that, etc. Also, some references can be updated while others
532can be rejected.
533
534An example client/server communication might look like this:
535
536----
537 S: 007c74730d410fcb6603ace96f1dc55ea6196122532d refs/heads/local\0report-status delete-refs ofs-delta\n
538 S: 003e7d1665144a3a975c05f1f43902ddaf084e784dbe refs/heads/debug\n
539 S: 003f74730d410fcb6603ace96f1dc55ea6196122532d refs/heads/master\n
540 S: 003f74730d410fcb6603ace96f1dc55ea6196122532d refs/heads/team\n
541 S: 0000
542
543 C: 003e7d1665144a3a975c05f1f43902ddaf084e784dbe 74730d410fcb6603ace96f1dc55ea6196122532d refs/heads/debug\n
544 C: 003e74730d410fcb6603ace96f1dc55ea6196122532d 5a3f6be755bbb7deae50065988cbfa1ffa9ab68a refs/heads/master\n
545 C: 0000
546 C: [PACKDATA]
547
c8a97906
TRC
548 S: 000eunpack ok\n
549 S: 0018ok refs/heads/debug\n
550 S: 002ang refs/heads/master non-fast-forward\n
b31222cf 551----