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