Here are the requests:
pathname
\nResponse expected: no. Tell the server which
CVSROOT 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.
request-list
\nResponse expected: no. Tell the server what responses the client will accept. request-list is a space separated list of tokens. The Root request need not have been previously sent.
Response expected: yes. Ask the server to send back a Valid-requests response. The Root request need not have been previously sent.
local-directory
\nAdditional data: repository
\n. Response
expected: no. Tell the server what directory to use. The
repository
should be a directory name from a
previous server response. 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: /home/kingdon/zwork/cvsroot C: co S: Clear-sticky moddir/ S: /home/kingdon/zwork/cvsroot/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: /home/kingdon/zwork/cvsroot/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: /home/foo/repos/mod1 . . . C: Argument dir2 C: Directory dir2 C: /home/foo/repos/mod2 . . . C: Argument dir3 C: Directory dir3/subdir3 C: /home/foo/repos/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: /home/foo/repos/mod1 . . . C: Argument dir2 C: Directory dir2 C: /home/foo/repos/mod2 . . . C: Argument dir3 C: Directory dir3 C: /home/foo/repos/. . . . C: Directory dir3/subdir3 C: /home/foo/repos/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: /home/foo/repos/mod3 . . . C: Directory dir3 C: /home/foo/repos/. . . . 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.
level
\nResponse expected: no. Tell the server that
level
levels of directories above the directory
which Directory 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.
Response expected: no. Tell the server that the directory most recently specified with Directory 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.
tagspec
\nResponse expected: no. Tell the server that the directory
most recently specified with Directory 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.
entry-line
\nResponse expected: no. Tell the server what version of a
file is on the local machine. The name in
entry-line
is a name relative to the directory
most recently specified with Directory. 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.
entry-extra-line
\nResponse expected: no. Tell the server extra information about the file on the local machine (currently mergepoint data). This request is optional.
option
\nThis indicates to the server which keyword expansion options to use for the file specified by the next Modified 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.
time
\nFor the file specified by the next
Modified 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.
filename
\nResponse expected: no. Additional data: mode, \n, file
transmission. Send the server a copy of one locally modified file.
filename
is a file within the most recent
directory sent with Directory; 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.
filename
\nResponse expected: no. Additional data: none. Like Modified, 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.
filename
\nResponse expected: no. Tell the server that
filename
has not been modified in the checked
out directory. The filename
is a file within
the most recent directory sent with Directory;
it must not contain /.
Response expected: no. To specify the version of the protocol described in this document, servers must support this request (although it need not do anything) and clients must issue it. The Root request need not have been previously sent.
filename
\nResponse expected: no. Tell the server that an
edit 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
\ttime
\tclienthost
\tworking-dir
\twatches
\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.
user
\nResponse expected: no. Tell the server that the notification is being done on behalf of another user. Used for forced unedits. Only repository administrators can send this request.
filename
\nResponse expected: no. Additional data: no. Tell the server
to check whether filename
should be ignored,
and if not, next time the server sends responses, send (in a
M 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.
Response expected: no. Tell the server that filenames should be matched in a case-insensitive fashion. Note that this is not the primary mechanism for achieving case-insensitivity; for the most part the client keeps track of the case which the server wants to use and takes care to always use that case regardless of what the user specifies. For example the filenames given in Entry 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).
Response expected: no. Tell the server that we support Nonstandard file encodings (Unicode/Utf8). This is also used by the client so that it knows that the server can handle such files.
text
\nResponse expected: no. Save argument for use in a subsequent command. Arguments accumulate until an argument-using command is given, at which point they are forgotten.
text
\nResponse expected: no. Append \n followed by text to the current argument being saved.
option
\nResponse expected: no. Transmit one of the global options
-q, -Q,
-l, -t,
-r, or -n.
option
must be one of those strings, no
variations (such as combining of options) are allowed. For
graceful handling of valid-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.
level
\nResponse expected: no. Use zlib (RFC 1950/1951) compression
to compress all further communication between the client and the
server. After this request is sent, all further communication must
be compressed. All further data received from the server will also
be compressed. The level
argument suggests to
the server the level of compression that it should apply; it
should be an integer between 1 and 9, inclusive, where a higher
number indicates more compression.
Response expected: no. Use encryption to encrypt all further communication between the client and the server. This will only work if the connection was made using a protocol that supports encryption in the first place. If both the Gzip-stream and the Protocol-encrypt requests are used, the Protocol-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 Protocol-encrypt request.
Response expected: no. Use GSSAPI authentication to authenticate all further communication between the client and the server. This will only work if the connection was made using a protocol that supports authentication in the first place. Encrypted data is automatically authenticated, so using both Protocol-authenticate and Protocol-encrypt has no effect beyond that of Protocol-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 Protocol-authenticate request.
Response expected: yes. Return the server side cvsrc file immediately for the client to process. (There was a read-cvsrc command supported in some versions of cvsnt, which is now depreciated).
Response expected: yes. Return the server side cvswrappers file immediately for the client to process.
Response expected: yes. Return the server side cvsignore file immediately for the client to process.
error-text
\nResponse expected: no. If the user is listed in the 'readers' file or otherwise has no permission to write to the repository, generate an error whose text is equal to the supplied error-text. If the user has write access then this command does nothing.
Response expected: yes. Return the character set that the server is using. The client is expected to convert all traffic to/from the server to this codepage.
client-version-string
\nResponse-exptectd: yes. Tell the server what version of the client is in use. Responds with the server version. The server may change its behaviour due to this but the client must not rely on it doing so.
Response expected: no. This is sent by the client to indicate the set of RCS expansion (-k) options that is supports. The server will avoid sending unsupported options in its output, and may substitute equivalent options. If this is not sent a predefined list based on cvs 1.11.x is used.
Response expected: no. These pseudo-requests are never sent by the client. Their presence in the valid-requests output serves to tell the client what sort of connection the server is expecting. The client is free to ignore these requests, however ignoring a -Required request is likely to cause the server to fail the connection.
variable
=value
\nResponse expected: no. Set a user variable
variable
to value
. The
Root request need not have been previously
sent.
Response expected: yes. Expand the modules which are specified in the arguments. Returns the data in Module-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 expand modules on the client side.
Expand may not be the best word for what this request does. It does not necessarily tell you all the files contained in a module, for example. Basically it is a way of telling you which working directories the server needs to know about in order to handle a checkout of the specified modules.
For example, suppose that the server has a module defined by
aliasmodule -a 1dir
That is, one can check out aliasmodule and it will take 1dir in the repository and check it out to 1dir in the working directory. Now suppose the client already has this module checked out and is planning on using the co request to update it. Without using expand-modules, the client would have two bad choices: it could either send information about all working directories under the current directory, which could be unnecessarily slow, or it could be ignorant of the fact that aliasmodule stands for 1dir, and neglect to send information for 1dir, which would lead to incorrect operation.
With expand-modules, the client would first ask for the module to be expanded:
C: Root /home/kingdon/zwork/cvsroot . . . C: Argument aliasmodule C: Directory . C: /home/kingdon/zwork/cvsroot C: expand-modules S: Module-expansion 1dir S: ok
and then it knows to check the 1dir directory and send requests such as Entry and Modified for the files in that directory.
Response expected: yes. Actually do a cvs command. This uses any previous Argument, Directory, Entry, or Modified requests, if they have been sent. The last Directory sent specifies the working directory at the time of the operation. No provision is made for any input from the user. This means that ci must use a -m argument if it wants to specify a log message.
Response expected: yes. Show information for past revisions. This uses any previous Directory, Entry, or Modified requests, if they have been sent. The last Directory sent specifies the working directory at the time of the operation. Also uses previous Argument's of which the canonical forms are the following (cvs 1.10 and older clients sent what the user specified, but clients are encouraged to use the canonical forms and other forms are deprecated):
These options go by themselves, one option per Argument request.
date1
<date2
Select revisions between date1
and
date2
. Either date may be omitted in
which case there is no date limit at that end of the range
(clients may specify dates such as 1 Jan 1970 or 1 Jan 2038
for similar purposes but this is problematic as it makes
assumptions about what dates the server supports). Dates are
in RFC822/1123 format. The -d is one
Argument request and the date range is a
second one.
date1
<=date2
Likewise but compare dates for equality.
singledate
Select the single, latest revision dated
singledate
or earlier.
To include several date ranges and/or singledates, repeat the -d option as many times as necessary.
rev1
:rev2
, -rbranch
, -rbranch
., -rSpecify revisions (note that rev1
or rev2
can be omitted, or can refer to
branches). Send both the -r and the
revision information in a single Argument
request. To include several revision selections, repeat the
-r option.
state
, -w, -wlogin
Select on states or users. To include more than one state or user, repeat the option. Send the -s option as a separate argument from the state being selected. Send the -w option as part of the same argument as the user being selected.
Response expected: yes. Get files from the repository. This uses any previous Argument, Directory, Entry, or Modified requests, if they have been sent. Arguments to this command are module names; the client cannot know what directories they correspond to except by (1) just sending the co request, and then seeing what directory names the server sends back in its responses, and (2) the expand-modules request.
Response expected: yes. Get files from the repository. This uses any previous Argument, Directory, Entry, or Modified requests, if they have been sent. Arguments to this command are module names, as described for the co request. The intention behind this command is that a client can get sources from a server without storing CVS information about those sources. That is, a client probably should not count on being able to take the entries line returned in the Created response from an export request and send it in a future Entry request. Note that the entries line in the Created response must indicate whether the file is binary or text, so the client can create it correctly.
Response expected: yes. Actually do a cvs command. This uses any previous Argument requests, if they have been sent. The client should not send Directory, Entry, or Modified requests for these commands; they are not used. Arguments to these commands are module names, as described for co.
root-name
\nResponse expected: yes. If it doesn't already exist, create
a cvs repository root-name
. Note that
root-name
is a local directory and
not a fully qualified
CVSROOT variable. The Root
request need not have been previously sent.
Response expected: yes. Actually do a cvs update command. This uses any previous Argument, Directory, Entry, or Modified requests, if they have been sent. The last Directory sent specifies the working directory at the time of the operation. The -I option is not used-files which the client can decide whether to ignore are not mentioned and the client sends the Questionable request for others.
Response expected: yes. Actually do a cvs import command. This uses any previous Argument, Directory, Entry, or Modified requests, if they have been sent. The last Directory sent specifies the working directory at the time of the operation - unlike most commands, the repository field of each Directory request is ignored (it merely must point somewhere within the root). The files to be imported are sent in Modified requests (files which the client knows should be ignored are not sent; the server must still process the CVSROOT/cvsignore file unless -I ! is sent). A log message must have been specified with a -m argument.
Response expected: yes. Add a file or directory. This uses any previous Argument, Directory, Entry, or Modified requests, if they have been sent. The last Directory sent specifies the working directory at the time of the operation.
To add a directory, send the directory to be added using Directory and Argument requests. For example:
C: Root /u/cvsroot . . . C: Argument nsdir C: Directory nsdir C: /u/cvsroot/1dir/nsdir C: Directory . C: /u/cvsroot/1dir C: add S: M Directory /u/cvsroot/1dir/nsdir added to the repository S: ok
You will notice that the server does not signal to the client in any particular way that the directory has been successfully added. The client is supposed to just assume that the directory has been added and update its records accordingly. Note also that adding a directory is immediate; it does not wait until a ci request as files do.
To add a file, send the file to be added using a Modified request. For example:
C: Argument nfile C: Directory . C: /u/cvsroot/1dir C: Modified nfile C: u=rw,g=r,o=r C: 6 C: hello C: add S: E cvs server: scheduling file `nfile' for addition S: Mode u=rw,g=r,o=r S: Checked-in ./ S: /u/cvsroot/1dir/nfile S: /nfile/0/// S: E cvs server: use 'cvs commit' to add this file permanently S: ok
Note that the file has not been added to the repository; the only effect of a successful add request, for a file, is to supply the client with a new entries line containing 0 to indicate an added file. In fact, the client probably could perform this operation without contacting the server, although using add does cause the server to perform a few more checks.
The client sends a subsequent ci to actually add the file to the repository.
Another quirk of the add request is that
with CVS 1.9 and older, a pathname specified in an
Argument request cannot contain
/. There is no good reason for this
restriction, and in fact more recent CVS servers don't have it.
But the way to interoperate with the older servers is to ensure
that all Directory requests for
add (except those used to add directories, as
described above), use . for
local-directory
. Specifying another string for
local-directory
may not get an error, but it
will get you strange Checked-in responses from
the buggy servers.
Response expected: yes. Remove a file. This uses any previous Argument, Directory, Entry, or Modified requests, if they have been sent. The last Directory sent specifies the working directory at the time of the operation.
Note that this request does not actually do anything to the repository; the only effect of a successful remove request is to supply the client with a new entries line containing - to indicate a removed file. In fact, the client probably could perform this operation without contacting the server, although using remove may cause the server to perform a few more checks.
The client sends a subsequent ci request to actually record the removal in the repository.
Response expected: yes. Actually do the cvs watch on, cvs watch off, cvs watch add, and cvs watch remove commands, respectively. This uses any previous Argument, Directory, Entry, or Modified requests, if they have been sent. The last Directory sent specifies the working directory at the time of the operation.
Response expected: yes. Note that a cvs release command has taken place and update the history file accordingly.
Response expected: yes. This request is a null command in the sense that it doesn't do anything, but merely (as with any other requests expecting a response) sends back any responses pertaining to pending errors, pending Notified responses, etc. The Root request need not have been previously sent.
Response expected: yes. This request does not actually do anything. It is used as a signal that the server is able to generate patches when given an update request. The client must issue the -u argument to update in order to receive patches.
Response expected: yes. Request that the server transmit mappings from filenames to keyword expansion modes in Wrapper-rcsOption responses.
Response expected: yes. Request that the server transmit its version message. The Root request need not have been previously sent.
other-request
text
\nResponse expected: yes. Any unrecognized request expects a response, and does not contain any additional data. The response will normally be something like error unrecognized request, but it could be a different error if a previous request which doesn't expect a response produced an error.
When the client is done, it drops the connection.