This document describes the client/server protocol used by CVS. It does not describe how to use or administer client/server CVS; see the regular CVS manual for that. This is version 1.12.13 of the protocol specification—See Introduction, for more on what this version number means.
CVS is a version control system (with some additional configuration management functionality). It maintains a central repository which stores files (often source code), including past versions, information about who modified them and when, and so on. People who wish to look at or modify those files, known as developers, use CVS to check out a working directory from the repository, to check in new versions of files to the repository, and other operations such as viewing the modification history of a file. If developers are connected to the repository by a network, particularly a slow or flaky one, the most efficient way to use the network is with the CVS-specific protocol described in this document.
Developers, using the machine on which they store their working directory, run the CVS client program. To perform operations which cannot be done locally, it connects to the CVS server program, which maintains the repository. For more information on how to connect see Connection and Authentication.
This document describes the CVS protocol. Unfortunately, it does not yet completely document one aspect of the protocol—the detailed operation of each CVS command and option—and one must look at the CVS user documentation, cvs.texinfo, for that information. The protocol is non-proprietary (anyone who wants to is encouraged to implement it) and an implementation, known as CVS, is available under the GNU General Public License. The CVS distribution, containing this implementation, cvs.texinfo, and a copy (possibly more or less up to date than what you are reading now) of this document, cvsclient.texi, can be found at the usual GNU FTP sites, with a filename such as cvs-version.tar.gz.
This is version 1.12.13 of the protocol specification. This
version number is intended only to aid in distinguishing different
versions of this specification. Although the specification is currently
maintained in conjunction with the CVS implementation, and carries the
same version number, it also intends to document what is involved with
interoperating with other implementations (such as other versions of
CVS); see Requirements. This version number should not be used
by clients or servers to determine what variant of the protocol to
speak; they should instead use the valid-requests and
Valid-responses mechanism (see Protocol), which is more
flexible.
Connection and authentication occurs before the CVS protocol itself is started. There are several ways to connect.
cvs. It is
invoked with one argument, server. Once it invokes the server,
the client proceeds to start the cvs protocol.
The pserver server listens on a port (in the current implementation, by having inetd call "cvs pserver") which defaults to 2401 (this port is officially registered). The client connects, and sends the following:
The client must send the
identical string for cvs root both here and later in the
Root request of the cvs
protocol itself. Servers are encouraged to enforce this restriction.
The possible server responses (each of which is followed by a linefeed)
are the following. Note that although there is a small similarity
between this authentication protocol and the cvs protocol, they are
separate.
I LOVE YOUI HATE YOUE textunrecognized auth response and text, and then exit, upon
receiving this response.
error code textunrecognized auth response and text, and then exit, upon
receiving this response.
Note that text for this response, or the text in an E
response, is not designed for machine parsing. More vigorous use of
code, or future extensions, will be needed to prove a cleaner
machine-parseable indication of what the error was.
If the client wishes to merely authenticate without starting the cvs protocol, the procedure is the same, except BEGIN AUTH REQUEST is replaced with BEGIN VERIFICATION REQUEST, END AUTH REQUEST is replaced with END VERIFICATION REQUEST, and upon receipt of I LOVE YOU the connection is closed rather than continuing.
Another mechanism is GSSAPI authentication. GSSAPI is a
generic interface to security services such as kerberos. GSSAPI is
specified in RFC2078 (GSSAPI version 2) and RFC1508 (GSSAPI version 1);
we are not aware of differences between the two which affect the
protocol in incompatible ways, so we make no attempt to specify one
version or the other.
The procedure here is to start with ‘BEGIN
GSSAPI REQUEST’. GSSAPI authentication information is then exchanged
between the client and the server. Each packet of information consists
of a two byte big endian length, followed by that many bytes of data.
After the GSSAPI authentication is complete, the server continues with
the responses described above (‘I LOVE YOU’, etc.).
The pserver authentication protocol, as described in Connection and Authentication, trivially encodes the passwords. This is only to prevent inadvertent compromise; it provides no protection against even a relatively unsophisticated attacker. For comparison, HTTP Basic Authentication (as described in RFC2068) uses BASE64 for a similar purpose. CVS uses its own algorithm, described here.
The scrambled password starts with ‘A’, which serves to identify the scrambling algorithm in use. After that follows a single octet for each character in the password, according to a fixed encoding. The values are shown here, with the encoded values in decimal. Control characters, space, and characters outside the invariant ISO 646 character set are not shown; such characters are not recommended for use in passwords. There is a long discussion of character set issues in Protocol Notes.
0 111 P 125 p 58
! 120 1 52 A 57 Q 55 a 121 q 113
" 53 2 75 B 83 R 54 b 117 r 32
3 119 C 43 S 66 c 104 s 90
4 49 D 46 T 124 d 101 t 44
% 109 5 34 E 102 U 126 e 100 u 98
& 72 6 82 F 40 V 59 f 69 v 60
' 108 7 81 G 89 W 47 g 73 w 51
( 70 8 95 H 38 X 92 h 99 x 33
) 64 9 65 I 103 Y 71 i 63 y 97
* 76 : 112 J 45 Z 115 j 94 z 62
+ 67 ; 86 K 50 k 93
, 116 < 118 L 42 l 39
- 74 = 110 M 123 m 37
. 68 > 122 N 91 n 61
/ 87 ? 105 O 35 _ 56 o 48
In the following, ‘\n’ refers to a linefeed and ‘\t’ refers to a horizontal tab; requests are what the client sends and responses are what the server sends. In general, the connection is governed by the client—the server does not send responses without first receiving requests to do so; see Response intro for more details of this convention.
It is typical, early in the connection, for the client to transmit a
Valid-responses request, containing all the responses it
supports, followed by a valid-requests request, which elicits
from the server a Valid-requests response containing all the
requests it understands. In this way, the client and server each find
out what the other supports before exchanging large amounts of data
(such as file contents).
General protocol conventions:
The protocol itself:
An example session, and some further observations:
Entries lines are transmitted as:
/ name / version / conflict / options / tag_or_date
tag_or_date is either ‘T’ tag or ‘D’ date or empty. If it is followed by a slash, anything after the slash shall be silently ignored.
version can be empty, or start with ‘0’ or ‘-’, for no user file, new user file, or user file to be removed, respectively.
conflict, if it starts with ‘+’, indicates that the file had conflicts in it. The rest of conflict is ‘=’ if the timestamp matches the file, or anything else if it doesn't. If conflict does not start with a ‘+’, it is silently ignored.
options signifies the keyword expansion options (for example
‘-ko’). In an Entry request, this indicates the options
that were specified with the file from the previous file updating
response (see Response intro, for a list of file updating
responses); if the client is specifying the ‘-k’ or ‘-A’
option to update, then it is the server which figures out what
overrides what.
A mode is any number of repetitions of
mode-type = data
separated by ‘,’.
mode-type is an identifier composed of alphanumeric characters. Currently specified: ‘u’ for user, ‘g’ for group, ‘o’ for other (see below for discussion of whether these have their POSIX meaning or are more loose). Unrecognized values of mode-type are silently ignored.
data consists of any data not containing ‘,’, ‘\0’ or ‘\n’. For ‘u’, ‘g’, and ‘o’ mode types, data consists of alphanumeric characters, where ‘r’ means read, ‘w’ means write, ‘x’ means execute, and unrecognized letters are silently ignored.
The two most obvious ways in which the mode matters are: (1) is it writeable? This is used by the developer communication features, and is implemented even on OS/2 (and could be implemented on DOS), whose notion of mode is limited to a readonly bit. (2) is it executable? Unix CVS users need CVS to store this setting (for shell scripts and the like). The current CVS implementation on unix does a little bit more than just maintain these two settings, but it doesn't really have a nice general facility to store or version control the mode, even on unix, much less across operating systems with diverse protection features. So all the ins and outs of what the mode means across operating systems haven't really been worked out (e.g. should the VMS port use ACLs to get POSIX semantics for groups?).
In most contexts, ‘/’ is used to separate directory and file names in filenames, and any use of other conventions (for example, that the user might type on the command line) is converted to that form. The only exceptions might be a few cases in which the server provides a magic cookie which the client then repeats verbatim, but as the server has not yet been ported beyond unix, the two rules provide the same answer (and what to do if future server ports are operating on a repository like e:/foo or CVS_ROOT:[FOO.BAR] has not been carefully thought out).
Characters outside the invariant ISO 646 character set should be avoided in filenames. This restriction may need to be relaxed to allow for characters such as ‘[’ and ‘]’ (see above about non-unix servers); this has not been carefully considered (and currently implementations probably use whatever character sets that the operating systems they are running on allow, and/or that users specify). Of course the most portable practice is to restrict oneself further, to the POSIX portable filename character set as specified in POSIX.1.
File contents (noted below as file transmission) can be sent in one of two forms. The simpler form is a number of bytes, followed by a linefeed, followed by the specified number of bytes of file contents. These are the entire contents of the specified file. Second, if both client and server support ‘gzip-file-contents’, a ‘z’ may precede the length, and the `file contents' sent are actually compressed with ‘gzip’ (RFC1952/1951) compression. The length specified is that of the compressed version of the file.
In neither case are the file content followed by any additional data. The transmission of a file will end with a linefeed iff that file (or its compressed form) ends with a linefeed.
The encoding of file contents depends on the value for the ‘-k’ option. If the file is binary (as specified by the ‘-kb’ option in the appropriate place), then it is just a certain number of octets, and the protocol contributes nothing towards determining the encoding (using the file name is one widespread, if not universally popular, mechanism). If the file is text (not binary), then the file is sent as a series of lines, separated by linefeeds. If the keyword expansion is set to something other than ‘-ko’, then it is expected that the file conform to the RCS expectations regarding keyword expansion—in particular, that it is in a character set such as ASCII in which 0x24 is a dollar sign (‘$’).
In various contexts, for example the Argument request and the
M response, one transmits what is essentially an arbitrary
string. Often this will have been supplied by the user (for example,
the ‘-m’ option to the ci request). The protocol has no
mechanism to specify the character set of such strings; it would be
fairly safe to stick to the invariant ISO 646 character set but the
existing practice is probably to just transmit whatever the user
specifies, and hope that everyone involved agrees which character set is
in use, or sticks to a common subset.
The protocol contains times and dates in various places.
For the ‘-D’ option to the annotate, co, diff,
export, history, rannotate, rdiff,
rtag, tag,
and update requests, the server should support two formats:
26 May 1997 13:01:40 -0000 ; RFC 822 as modified by RFC 1123 5/26/1997 13:01:40 GMT ; traditional
The former format is preferred; the latter however is sent by the CVS command line client (versions 1.5 through at least 1.9).
For the ‘-d’ option to the log and rlog requests,
servers should at
least support RFC 822/1123 format. Clients are encouraged to use this
format too (the command line CVS client, version 1.10 and older, just passed
along the date format specified by the user, however).
The Mod-time response and Checkin-time request use RFC
822/1123 format (see the descriptions of that response and request for
details).
For Notify, see the description of that request.
By convention, requests which begin with a capital letter do not elicit a response from the server, while all others do – save one. The exception is ‘gzip-file-contents’. Unrecognized requests will always elicit a response from the server, even if that request begins with a capital letter.
The term command means a request which expects a response (except
valid-requests). The general model is that the client transmits
a great number of requests, but nothing happens until the very end when
the client transmits a command. Although the intention is that
transmitting several commands in one connection should be legal,
existing servers probably have some bugs with some combinations of more
than one command, and so clients may find it necessary to make several
connections in some cases. This should be thought of as a workaround
rather than a desired attribute of the protocol.
Here are the requests:
Root pathname \nCVSROOT to use.
Note that pathname is a local directory and not a fully
qualified CVSROOT variable. pathname must
already exist; if creating a new root, use the init request, not
Root. pathname does not include the hostname of the
server, how to access the server, etc.; by the time the CVS protocol is
in use, connection, authentication, etc., are already taken care of.
The Root request must be sent only once, and it must be sent
before any requests other than Valid-responses,
valid-requests, UseUnchanged, Set,
Global_option, init, noop, or version.
Valid-responses request-list \nRoot request need not have been previously sent.
valid-requests \nValid-requests response.
The Root request need not have been previously sent.
Command-prep command \nok or Redirect respnose.
Referrer CVSROOT \nDirectory local-directory \nRelative-directory local-directory \nThe repository should be a directory name from a previous server
response and may be specified either relative to the pathname provided
with the Root request or absolute. Relative or absolute, it must
specify a path within pathname.
Prior to cvs version FIXME - release number 1.12.10?,
repository had to be absolute and Relative-directory was not a
valid request. The Relative-directory request is synonymous with
Directory and is provided to alert modern clients that a relative
repository is acceptable.
Note that this both gives a default for Entry and Modified and
also for ci and the other commands; normal usage is to send
Directory for each directory in which there will be an
Entry or Modified, and then a final Directory
for the original directory, then the command.
The local-directory is relative to
the top level at which the command is occurring (i.e. the last
Directory which is sent before the command);
to indicate that top level, ‘.’ should be sent for
local-directory.
Here is an example of where a client gets repository and local-directory. Suppose that there is a module defined by
moddir 1dir
That is, one can check out moddir and it will take 1dir in
the repository and check it out to moddir in the working
directory. Then an initial check out could proceed like this:
C: Root /home/kingdon/zwork/cvsroot
. . .
C: Argument moddir
C: Directory .
C: .
C: co
S: Clear-sticky moddir/
S: 1dir/
. . .
S: ok
In this example the response shown is Clear-sticky, but it could
be another response instead. Note that it returns two pathnames.
The first one, moddir/, indicates the working
directory to check out into. The second one, ending in 1dir/,
indicates the directory to pass back to the server in a subsequent
Directory request. For example, a subsequent update
request might look like:
C: Directory moddir
C: 1dir
. . .
C: update
For a given local-directory, the repository will be the same for each of the responses, so one can use the repository from whichever response is most convenient. Typically a client will store the repository along with the sources for each local-directory, use that same setting whenever operating on that local-directory, and not update the setting as long as the local-directory exists.
A client is free to rename a local-directory at any time (for
example, in response to an explicit user request). While it is true
that the server supplies a local-directory to the client, as noted
above, this is only the default place to put the directory. Of course,
the various Directory requests for a single command (for example,
update or ci request) should name a particular directory
with the same local-directory.
Each Directory request specifies a brand-new
local-directory and repository; that is,
local-directory and repository are never relative to paths
specified in any previous Directory request.
Here's a more complex example, in which we request an update of a working directory which has been checked out from multiple places in the repository.
C: Argument dir1
C: Directory dir1
C: mod1
. . .
C: Argument dir2
C: Directory dir2
C: mod2
. . .
C: Argument dir3
C: Directory dir3/subdir3
C: mod3
. . .
C: update
While directories dir1 and dir2 will be handled in similar
fashion to the other examples given above, dir3 is slightly
different from the server's standpoint. Notice that module mod3
is actually checked out into dir3/subdir3, meaning that directory
dir3 is either empty or does not contain data checked out from
this repository.
The above example will work correctly in cvs 1.10.1 and later. The
server will descend the tree starting from all directories mentioned in
Argument requests and update those directories specifically
mentioned in Directory requests.
Previous versions of cvs (1.10 and earlier) do not behave the same
way. While the descent of the tree begins at all directories mentioned
in Argument requests, descent into subdirectories only occurs if
a directory has been mentioned in a Directory request.
Therefore, the above example would succeed in updating dir1 and
dir2, but would skip dir3 because that directory was not
specifically mentioned in a Directory request. A functional
version of the above that would run on a 1.10 or earlier server is as
follows:
C: Argument dir1
C: Directory dir1
C: mod1
. . .
C: Argument dir2
C: Directory dir2
C: mod2
. . .
C: Argument dir3
C: Directory dir3
C: .
. . .
C: Directory dir3/subdir3
C: mod3
. . .
C: update
Note the extra Directory dir3 request. It might be better to use
Emptydir as the repository for the dir3 directory, but the
above will certainly work.
One more peculiarity of the 1.10 and earlier protocol is the ordering of
Directory arguments. In order for a subdirectory to be
registered correctly for descent by the recursion processor, its parent
must be sent first. For example, the following would not work to update
dir3/subdir3:
. . .
C: Argument dir3
C: Directory dir3/subdir3
C: mod3
. . .
C: Directory dir3
C: .
. . .
C: update
The implementation of the server in 1.10 and earlier writes the
administration files for a given directory at the time of the
Directory request. It also tries to register the directory with
its parent to mark it for recursion. In the above example, at the time
dir3/subdir3 is created, the physical directory for dir3
will be created on disk, but the administration files will not have been
created. Therefore, when the server tries to register
dir3/subdir3 for recursion, the operation will silently fail
because the administration files do not yet exist for dir3.
Max-dotdot level \nDirectory requests are relative to will be
needed. For example, if the client is planning to use a
Directory request for ../../foo, it must send a
Max-dotdot request with a level of at least 2.
Max-dotdot must be sent before the first Directory
request.
Static-directory \nDirectory should not have
additional files checked out unless explicitly requested. The client
sends this if the Entries.Static flag is set, which is controlled
by the Set-static-directory and Clear-static-directory
responses.
Sticky tagspec \nDirectory has a sticky tag or date tagspec.
The first character of tagspec is ‘T’ for a tag, ‘D’
for a date, or some other character supplied by a Set-sticky response
from a previous request to the server. The remainder of tagspec
contains the actual tag or date, again as supplied by Set-sticky.
The server should remember Static-directory and Sticky
requests for a particular directory; the client need not resend them
each time it sends a Directory request for a given directory.
However, the server is not obliged to remember them beyond the context
of a single command.
Checkin-prog program \nDirectory has a checkin program program.
Such a program would have been previously set with the
Set-checkin-prog response.
Update-prog program \nDirectory has an update program program.
Such a program would have been previously set with the
Set-update-prog response.
Entry entry-line \nDirectory. If the user
is operating on only some files in a directory, Entry requests
for only those files need be included. If an Entry request is
sent without Modified, Is-modified, or Unchanged,
it means the file is
lost (does not exist in the working directory). If both Entry
and one of Modified, Is-modified, or Unchanged are
sent for the same file, Entry must be sent first. For a
given file, one can send Modified, Is-modified, or
Unchanged, but not more than one of these three.
Kopt option \nModified or Is-modified
request (for example ‘-kb’ for a binary file). This is similar to
Entry, but is used for a file for which there is no entries line.
Typically this will be a file being added via an add or
import request. The client may not send both Kopt and
Entry for the same file.
Checkin-time time \nModified request, use
time as the time of the checkin. The time is in the format
specified by RFC822 as modified by RFC1123. The client may specify any
timezone it chooses; servers will want to convert that to their own
timezone as appropriate. An example of this format is:
26 May 1997 13:01:40 -0400
There is no requirement that the client and server clocks be synchronized. The client just sends its recommendation for a timestamp (based on file timestamps or whatever), and the server should just believe it (this means that the time might be in the future, for example).
Note that this is not a general-purpose way to tell the server about the timestamp of a file; that would be a separate request (if there are servers which can maintain timestamp and time of checkin separately).
This request should affect the import request, and may optionally
affect the ci request or other relevant requests if any.
Modified filename \nDirectory; it
must not contain ‘/’. If
the user is operating on only some files in a directory, only those
files need to be included. This can also be sent without Entry,
if there is no entry for the file.
Is-modified filename \nModified,
but used if the server only needs
to know whether the file is modified, not the contents.
The commands which can take Is-modified instead of
Modified with no known change in behavior are: admin,
diff (if and only if two ‘-r’ or ‘-D’ options are
specified), watch-on, watch-off, watch-add,
watch-remove, watchers, editors,
log, and annotate.
For the status command, one can send Is-modified but if
the client is using imperfect mechanisms such as timestamps to determine
whether to consider a file modified, then the behavior will be
different. That is, if one sends Modified, then the server will
actually compare the contents of the file sent and the one it derives
from to determine whether the file is genuinely modified. But if one
sends Is-modified, then the server takes the client's word for
it. A similar situation exists for tag, if the ‘-c’ option
is specified.
Commands for which Modified is necessary are co,
ci, update, and import.
Commands which do not need to inform the server about a working
directory, and thus should not be sending either Modified or
Is-modified: rdiff, rtag, history,
init, and release.
Commands for which further investigation is warranted are:
remove, add, and export. Pending such
investigation, the more conservative course of action is to stick to
Modified.
Unchanged filename \nDirectory; it
must not contain ‘/’.
UseUnchanged \nRoot request need not have been previously sent.
Notify filename \nedit or unedit command has taken
place. The server needs to send a Notified response, but such
response is deferred until the next time that the server is sending
responses.
The filename is a file within the most recent directory sent with
Directory; it must not contain ‘/’.
Additional data:
notification-type \t time \t clienthost \t
working-dir \t watches \n
where notification-type is ‘E’ for edit, ‘U’ for unedit, undefined behavior if ‘C’, and all other letters should be silently ignored for future expansion. time is the time at which the edit or unedit took place, in a user-readable format of the client's choice (the server should treat the time as an opaque string rather than interpreting it). clienthost is the name of the host on which the edit or unedit took place, and working-dir is the pathname of the working directory where the edit or unedit took place. watches are the temporary watches, zero or more of the following characters in the following order: ‘E’ for edit, ‘U’ for unedit, ‘C’ for commit, and all other letters should be silently ignored for future expansion. If notification-type is ‘E’ the temporary watches are set; if it is ‘U’ they are cleared. If watches is followed by \t then the \t and the rest of the line should be ignored, for future expansion.
The time, clienthost, and working-dir fields may not contain the characters ‘+’, ‘,’, ‘>’, ‘;’, or ‘=’.
Note that a client may be capable of performing an edit or
unedit operation without connecting to the server at that time,
and instead connecting to the server when it is convenient (for example,
when a laptop is on the net again) to send the Notify requests.
Even if a client is capable of deferring notifications, it should
attempt to send them immediately (one can send Notify requests
together with a noop request, for example), unless perhaps if
it can know that a connection would be impossible.
Questionable filename \nM response) ‘?’ followed
by the directory and filename. filename must not contain
‘/’; it needs to be a file in the directory named by the most
recent Directory request.
Case \nEntry and Modified requests for the
same file must match in case regardless of whether the Case
request is sent. The latter mechanism is more general (it could also be
used for 8.3 filenames, VMS filenames with more than one ‘.’, and
any other situation in which there is a predictable mapping between
filenames in the working directory and filenames in the protocol), but
there are some situations it cannot handle (ignore patterns, or
situations where the user specifies a filename and the client does not
know about that file).
Though this request will be supported into the forseeable future, it has been
the source of numerous bug reports in the past due to the complexity of testing
this functionality via the test suite and client developers are encouraged not
to use it. Instead, please consider munging conflicting names and maintaining
a map for communicating with the server. For example, suppose the server sends
files case, CASE, and CaSe. The client could write all
three files to names such as, case, case_prefix_case, and
case_prefix_2_case and maintain a mapping between the file names in, for
instance a new CVS/Map file.
Argument text \nArgumentx text \nGlobal_option option \nvalid-requests, it is probably better to
make new global options separate requests, rather than trying to add
them to this request.
The Root request need not have been previously sent.
Gzip-stream level \nKerberos-encrypt \nGzip-stream and
the Kerberos-encrypt requests are used, the
Kerberos-encrypt request should be used first. This will make
the client and server encrypt the compressed data, as opposed to
compressing the encrypted data. Encrypted data is generally
incompressible.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Kerberos-encrypt request.
Gssapi-encrypt \nKerberos-encrypt, above, for
the relation between Gssapi-encrypt and Gzip-stream.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-encrypt request.
Gssapi-authenticate \nGssapi-authenticate
and Gssapi-encrypt has no effect beyond that of
Gssapi-encrypt. Unlike encrypted data, it is reasonable to
compress authenticated data.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-authenticate request.
Set variable=value \nRoot request need not have been previously sent.
Hostname hostname \nedit
request.
LocalDir hostname \nedit request.
expand-modules \nModule-expansion responses. Note
that the server can assume that this is checkout or export, not rtag or
rdiff; the latter do not access the working directory and thus have no
need to en a laptop is on the net again) to send the Notify requests.
Even if a client is capable of deferring notifications, it should
attempt to send them immediately (one can send Notify requests
together with a noop request, for example), unless perhaps if
it can know that a connection would be impossible.
Questionable filename \nM response) ‘?’ followed
by the directory and filename. filename must not contain
‘/’; it needs to be a file in the directory named by the most
recent Directory request.
Case \nEntry and Modified requests for the
same file must match in case regardless of whether the Case
request is sent. The latter mechanism is more general (it could also be
used for 8.3 filenames, VMS filenames with more than one ‘.’, and
any other situation in which there is a predictable mapping between
filenames in the working directory and filenames in the protocol), but
there are some situations it cannot handle (ignore patterns, or
situations where the user specifies a filename and the client does not
know about that file).
Though this request will be supported into the forseeable future, it has been
the source of numerous bug reports in the past due to the complexity of testing
this functionality via the test suite and client developers are encouraged not
to use it. Instead, please consider munging conflicting names and maintaining
a map for communicating with the server. For example, suppose the server sends
files case, CASE, and CaSe. The client could write all
three files to names such as, case, case_prefix_case, and
case_prefix_2_case and maintain a mapping between the file names in, for
instance a new CVS/Map file.
Argument text \nArgumentx text \nGlobal_option option \nvalid-requests, it is probably better to
make new global options separate requests, rather than trying to add
them to this request.
The Root request need not have been previously sent.
Gzip-stream level \nKerberos-encrypt \nGzip-stream and
the Kerberos-encrypt requests are used, the
Kerberos-encrypt request should be used first. This will make
the client and server encrypt the compressed data, as opposed to
compressing the encrypted data. Encrypted data is generally
incompressible.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Kerberos-encrypt request.
Gssapi-encrypt \nKerberos-encrypt, above, for
the relation between Gssapi-encrypt and Gzip-stream.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-encrypt request.
Gssapi-authenticate \nGssapi-authenticate
and Gssapi-encrypt has no effect beyond that of
Gssapi-encrypt. Unlike encrypted data, it is reasonable to
compress authenticated data.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-authenticate request.
Set variable=value \nRoot request need not have been previously sent.
Hostname hostname \nedit
request.
LocalDir hostname \nedit request.
expand-modules \nModule-expansion responses. Note
that the server can assume that this is checkout or export, not rtag or
rdiff; the latter do not access the working directory and thus have no
need to en a laptop is on the net again) to send the Notify requests.
Even if a client is capable of deferring notifications, it should
attempt to send them immediately (one can send Notify requests
together with a noop request, for example), unless perhaps if
it can know that a connection would be impossible.
Questionable filename \nM response) ‘?’ followed
by the directory and filename. filename must not contain
‘/’; it needs to be a file in the directory named by the most
recent Directory request.
Case \nEntry and Modified requests for the
same file must match in case regardless of whether the Case
request is sent. The latter mechanism is more general (it could also be
used for 8.3 filenames, VMS filenames with more than one ‘.’, and
any other situation in which there is a predictable mapping between
filenames in the working directory and filenames in the protocol), but
there are some situations it cannot handle (ignore patterns, or
situations where the user specifies a filename and the client does not
know about that file).
Though this request will be supported into the forseeable future, it has been
the source of numerous bug reports in the past due to the complexity of testing
this functionality via the test suite and client developers are encouraged not
to use it. Instead, please consider munging conflicting names and maintaining
a map for communicating with the server. For example, suppose the server sends
files case, CASE, and CaSe. The client could write all
three files to names such as, case, case_prefix_case, and
case_prefix_2_case and maintain a mapping between the file names in, for
instance a new CVS/Map file.
Argument text \nArgumentx text \nGlobal_option option \nvalid-requests, it is probably better to
make new global options separate requests, rather than trying to add
them to this request.
The Root request need not have been previously sent.
Gzip-stream level \nKerberos-encrypt \nGzip-stream and
the Kerberos-encrypt requests are used, the
Kerberos-encrypt request should be used first. This will make
the client and server encrypt the compressed data, as opposed to
compressing the encrypted data. Encrypted data is generally
incompressible.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Kerberos-encrypt request.
Gssapi-encrypt \nKerberos-encrypt, above, for
the relation between Gssapi-encrypt and Gzip-stream.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-encrypt request.
Gssapi-authenticate \nGssapi-authenticate
and Gssapi-encrypt has no effect beyond that of
Gssapi-encrypt. Unlike encrypted data, it is reasonable to
compress authenticated data.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-authenticate request.
Set variable=value \nRoot request need not have been previously sent.
Hostname hostname \nedit
request.
LocalDir hostname \nedit request.
expand-modules \nModule-expansion responses. Note
that the server can assume that this is checkout or export, not rtag or
rdiff; the latter do not access the working directory and thus have no
need to en a laptop is on the net again) to send the Notify requests.
Even if a client is capable of deferring notifications, it should
attempt to send them immediately (one can send Notify requests
together with a noop request, for example), unless perhaps if
it can know that a connection would be impossible.
Questionable filename \nM response) ‘?’ followed
by the directory and filename. filename must not contain
‘/’; it needs to be a file in the directory named by the most
recent Directory request.
Case \nEntry and Modified requests for the
same file must match in case regardless of whether the Case
request is sent. The latter mechanism is more general (it could also be
used for 8.3 filenames, VMS filenames with more than one ‘.’, and
any other situation in which there is a predictable mapping between
filenames in the working directory and filenames in the protocol), but
there are some situations it cannot handle (ignore patterns, or
situations where the user specifies a filename and the client does not
know about that file).
Though this request will be supported into the forseeable future, it has been
the source of numerous bug reports in the past due to the complexity of testing
this functionality via the test suite and client developers are encouraged not
to use it. Instead, please consider munging conflicting names and maintaining
a map for communicating with the server. For example, suppose the server sends
files case, CASE, and CaSe. The client could write all
three files to names such as, case, case_prefix_case, and
case_prefix_2_case and maintain a mapping between the file names in, for
instance a new CVS/Map file.
Argument text \nArgumentx text \nGlobal_option option \nvalid-requests, it is probably better to
make new global options separate requests, rather than trying to add
them to this request.
The Root request need not have been previously sent.
Gzip-stream level \nKerberos-encrypt \nGzip-stream and
the Kerberos-encrypt requests are used, the
Kerberos-encrypt request should be used first. This will make
the client and server encrypt the compressed data, as opposed to
compressing the encrypted data. Encrypted data is generally
incompressible.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Kerberos-encrypt request.
Gssapi-encrypt \nKerberos-encrypt, above, for
the relation between Gssapi-encrypt and Gzip-stream.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-encrypt request.
Gssapi-authenticate \nGssapi-authenticate
and Gssapi-encrypt has no effect beyond that of
Gssapi-encrypt. Unlike encrypted data, it is reasonable to
compress authenticated data.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-authenticate request.
Set variable=value \nRoot request need not have been previously sent.
Hostname hostname \nedit
request.
LocalDir hostname \nedit request.
expand-modules \nModule-expansion responses. Note
that the server can assume that this is checkout or export, not rtag or
rdiff; the latter do not access the working directory and thus have no
need to en a laptop is on the net again) to send the Notify requests.
Even if a client is capable of deferring notifications, it should
attempt to send them immediately (one can send Notify requests
together with a noop request, for example), unless perhaps if
it can know that a connection would be impossible.
Questionable filename \nM response) ‘?’ followed
by the directory and filename. filename must not contain
‘/’; it needs to be a file in the directory named by the most
recent Directory request.
Case \nEntry and Modified requests for the
same file must match in case regardless of whether the Case
request is sent. The latter mechanism is more general (it could also be
used for 8.3 filenames, VMS filenames with more than one ‘.’, and
any other situation in which there is a predictable mapping between
filenames in the working directory and filenames in the protocol), but
there are some situations it cannot handle (ignore patterns, or
situations where the user specifies a filename and the client does not
know about that file).
Though this request will be supported into the forseeable future, it has been
the source of numerous bug reports in the past due to the complexity of testing
this functionality via the test suite and client developers are encouraged not
to use it. Instead, please consider munging conflicting names and maintaining
a map for communicating with the server. For example, suppose the server sends
files case, CASE, and CaSe. The client could write all
three files to names such as, case, case_prefix_case, and
case_prefix_2_case and maintain a mapping between the file names in, for
instance a new CVS/Map file.
Argument text \nArgumentx text \nGlobal_option option \nvalid-requests, it is probably better to
make new global options separate requests, rather than trying to add
them to this request.
The Root request need not have been previously sent.
Gzip-stream level \nKerberos-encrypt \nGzip-stream and
the Kerberos-encrypt requests are used, the
Kerberos-encrypt request should be used first. This will make
the client and server encrypt the compressed data, as opposed to
compressing the encrypted data. Encrypted data is generally
incompressible.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Kerberos-encrypt request.
Gssapi-encrypt \nKerberos-encrypt, above, for
the relation between Gssapi-encrypt and Gzip-stream.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-encrypt request.
Gssapi-authenticate \nGssapi-authenticate
and Gssapi-encrypt has no effect beyond that of
Gssapi-encrypt. Unlike encrypted data, it is reasonable to
compress authenticated data.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-authenticate request.
Set variable=value \nRoot request need not have been previously sent.
Hostname hostname \nedit
request.
LocalDir hostname \nedit request.
expand-modules \nModule-expansion responses. Note
that the server can assume that this is checkout or export, not rtag or
rdiff; the latter do not access the working directory and thus have no
need to en a laptop is on the net again) to send the Notify requests.
Even if a client is capable of deferring notifications, it should
attempt to send them immediately (one can send Notify requests
together with a noop request, for example), unless perhaps if
it can know that a connection would be impossible.
Questionable filename \nM response) ‘?’ followed
by the directory and filename. filename must not contain
‘/’; it needs to be a file in the directory named by the most
recent Directory request.
Case \nEntry and Modified requests for the
same file must match in case regardless of whether the Case
request is sent. The latter mechanism is more general (it could also be
used for 8.3 filenames, VMS filenames with more than one ‘.’, and
any other situation in which there is a predictable mapping between
filenames in the working directory and filenames in the protocol), but
there are some situations it cannot handle (ignore patterns, or
situations where the user specifies a filename and the client does not
know about that file).
Though this request will be supported into the forseeable future, it has been
the source of numerous bug reports in the past due to the complexity of testing
this functionality via the test suite and client developers are encouraged not
to use it. Instead, please consider munging conflicting names and maintaining
a map for communicating with the server. For example, suppose the server sends
files case, CASE, and CaSe. The client could write all
three files to names such as, case, case_prefix_case, and
case_prefix_2_case and maintain a mapping between the file names in, for
instance a new CVS/Map file.
Argument text \nArgumentx text \nGlobal_option option \nvalid-requests, it is probably better to
make new global options separate requests, rather than trying to add
them to this request.
The Root request need not have been previously sent.
Gzip-stream level \nKerberos-encrypt \nGzip-stream and
the Kerberos-encrypt requests are used, the
Kerberos-encrypt request should be used first. This will make
the client and server encrypt the compressed data, as opposed to
compressing the encrypted data. Encrypted data is generally
incompressible.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Kerberos-encrypt request.
Gssapi-encrypt \nKerberos-encrypt, above, for
the relation between Gssapi-encrypt and Gzip-stream.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-encrypt request.
Gssapi-authenticate \nGssapi-authenticate
and Gssapi-encrypt has no effect beyond that of
Gssapi-encrypt. Unlike encrypted data, it is reasonable to
compress authenticated data.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-authenticate request.
Set variable=value \nRoot request need not have been previously sent.
Hostname hostname \nedit
request.
LocalDir hostname \nedit request.
expand-modules \nModule-expansion responses. Note
that the server can assume that this is checkout or export, not rtag or
rdiff; the latter do not access the working directory and thus have no
need to en a laptop is on the net again) to send the Notify requests.
Even if a client is capable of deferring notifications, it should
attempt to send them immediately (one can send Notify requests
together with a noop request, for example), unless perhaps if
it can know that a connection would be impossible.
Questionable filename \nM response) ‘?’ followed
by the directory and filename. filename must not contain
‘/’; it needs to be a file in the directory named by the most
recent Directory request.
Case \nEntry and Modified requests for the
same file must match in case regardless of whether the Case
request is sent. The latter mechanism is more general (it could also be
used for 8.3 filenames, VMS filenames with more than one ‘.’, and
any other situation in which there is a predictable mapping between
filenames in the working directory and filenames in the protocol), but
there are some situations it cannot handle (ignore patterns, or
situations where the user specifies a filename and the client does not
know about that file).
Though this request will be supported into the forseeable future, it has been
the source of numerous bug reports in the past due to the complexity of testing
this functionality via the test suite and client developers are encouraged not
to use it. Instead, please consider munging conflicting names and maintaining
a map for communicating with the server. For example, suppose the server sends
files case, CASE, and CaSe. The client could write all
three files to names such as, case, case_prefix_case, and
case_prefix_2_case and maintain a mapping between the file names in, for
instance a new CVS/Map file.
Argument text \nArgumentx text \nGlobal_option option \nvalid-requests, it is probably better to
make new global options separate requests, rather than trying to add
them to this request.
The Root request need not have been previously sent.
Gzip-stream level \nKerberos-encrypt \nGzip-stream and
the Kerberos-encrypt requests are used, the
Kerberos-encrypt request should be used first. This will make
the client and server encrypt the compressed data, as opposed to
compressing the encrypted data. Encrypted data is generally
incompressible.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Kerberos-encrypt request.
Gssapi-encrypt \nKerberos-encrypt, above, for
the relation between Gssapi-encrypt and Gzip-stream.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-encrypt request.
Gssapi-authenticate \nGssapi-authenticate
and Gssapi-encrypt has no effect beyond that of
Gssapi-encrypt. Unlike encrypted data, it is reasonable to
compress authenticated data.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-authenticate request.
Set variable=value \nRoot request need not have been previously sent.
Hostname hostname \nedit
request.
LocalDir hostname \nedit request.
expand-modules \nModule-expansion responses. Note
that the server can assume that this is checkout or export, not rtag or
rdiff; the latter do not access the working directory and thus have no
need to en a laptop is on the net again) to send the Notify requests.
Even if a client is capable of deferring notifications, it should
attempt to send them immediately (one can send Notify requests
together with a noop request, for example), unless perhaps if
it can know that a connection would be impossible.
Questionable filename \nM response) ‘?’ followed
by the directory and filename. filename must not contain
‘/’; it needs to be a file in the directory named by the most
recent Directory request.
Case \nEntry and Modified requests for the
same file must match in case regardless of whether the Case
request is sent. The latter mechanism is more general (it could also be
used for 8.3 filenames, VMS filenames with more than one ‘.’, and
any other situation in which there is a predictable mapping between
filenames in the working directory and filenames in the protocol), but
there are some situations it cannot handle (ignore patterns, or
situations where the user specifies a filename and the client does not
know about that file).
Though this request will be supported into the forseeable future, it has been
the source of numerous bug reports in the past due to the complexity of testing
this functionality via the test suite and client developers are encouraged not
to use it. Instead, please consider munging conflicting names and maintaining
a map for communicating with the server. For example, suppose the server sends
files case, CASE, and CaSe. The client could write all
three files to names such as, case, case_prefix_case, and
case_prefix_2_case and maintain a mapping between the file names in, for
instance a new CVS/Map file.
Argument text \nArgumentx text \nGlobal_option option \nvalid-requests, it is probably better to
make new global options separate requests, rather than trying to add
them to this request.
The Root request need not have been previously sent.
Gzip-stream level \nKerberos-encrypt \nGzip-stream and
the Kerberos-encrypt requests are used, the
Kerberos-encrypt request should be used first. This will make
the client and server encrypt the compressed data, as opposed to
compressing the encrypted data. Encrypted data is generally
incompressible.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Kerberos-encrypt request.
Gssapi-encrypt \nKerberos-encrypt, above, for
the relation between Gssapi-encrypt and Gzip-stream.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-encrypt request.
Gssapi-authenticate \nGssapi-authenticate
and Gssapi-encrypt has no effect beyond that of
Gssapi-encrypt. Unlike encrypted data, it is reasonable to
compress authenticated data.
Note that this request does not fully prevent an attacker from hijacking
the connection, in the sense that it does not prevent hijacking the
connection between the initial authentication and the
Gssapi-authenticate request.
Set variable=value \nRoot request need not have been previously sent.
Hostname hostname \nedit
request.
LocalDir hostname \nedit request.
expand-modules \nModule-expansion responses. Note
that the server can assume that this is checkout or export, not rtag or
rdiff; the latter do not access the working directory and thus have no
need to en a laptop is on the net again) to send the Notify requests.
Even if a client is capable of deferring notifications, it should
attempt to send them immediately (one can send Notify requests
together with a noop request, for example), unless perhaps if
it can know that a connection would be impossible.
Questionable filename \nM response) ‘?’ followed
by the directory and filename. filename must not contain
‘/’; it needs to be a file in the directory named by the most
recent Directory request.
Case \nEntry and Modified requests for the
same file must match in case regardless of whether the Case
request is sent. The latter mechanism is more general (it could also be
used for 8.3 filenames, VMS filenames with more than one ‘.’, and
any other situation in which there is a predictable mapping between
filenames in the working directory and filenames in the protocol), but
there are some situations it cannot handle (ignore patterns, or
situations where the user specifies a filename and the client does not
know about that file).
Though this request will be supported into the forseeable future, it has been
the source of numerous bug reports in the past due to the complexity of testing
this functionality via the test suite and client developers are encouraged not
to use it. Instead, please consider munging conflicting names and maintaining
a map for communicating with the server. For example, suppose the server sends
files case, CASE, and CaSe. The client could write all
three files to names such as, case, case_prefix_case, and
case_prefix_2_case and maintain a mapping between the file names in, for
instance a new CVS/Map file.
Argument text \nArgumentx text \nGlobal_option option \n