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