{
    "mode": "info",
    "parameter": "cvsclient",
    "section": "",
    "url": "https://www.chedong.com/phpMan.php/info/cvsclient/json",
    "generated": "2026-11-15T14:35:07Z",
    "sections": {
        "File: cvsclient.info,  Node: Top,  Next: Introduction,  Up: (dir)": {
            "content": "",
            "subsections": []
        },
        "CVS Client/Server": {
            "content": "",
            "subsections": []
        },
        "This document describes the client/server protocol used by CVS. It does": {
            "content": "not describe how to use or administer client/server CVS; for that, *note\nthe regular CVS manual: (cvs)Top.  This specification applies to CVS\nversion 1.12.13-MirOS-0AB9.1 and up.\n\n* Menu:\n\n* Introduction::      What is CVS and what is the client/server protocol for?\n* Goals::             Basic design decisions, requirements, scope, etc.\n* Connection and Authentication::  Various ways to connect to the server\n* Password scrambling::  Scrambling used by pserver\n* Protocol::          Complete description of the protocol\n* Protocol Notes::    Possible enhancements, limitations, etc. of the protocol\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Introduction,  Next: Goals,  Prev: Top,  Up: Top": {
            "content": "",
            "subsections": []
        },
        "1 Introduction": {
            "content": "CVS is a version control system (with some additional configuration\nmanagement functionality).  It maintains a central \"repository\" which\nstores files (often source code), including past versions, information\nabout who modified them and when, and so on.  People who wish to look at\nor modify those files, known as \"developers\", use CVS to \"check out\" a\n\"working directory\" from the repository, to \"check in\" new versions of\nfiles to the repository, and other operations such as viewing the\nmodification history of a file.  If developers are connected to the\nrepository by a network, particularly a slow or flaky one, the most\nefficient way to use the network is with the CVS-specific protocol\ndescribed in this document.\n\nDevelopers, using the machine on which they store their working\ndirectory, run the CVS \"client\" program.  To perform operations which\ncannot be done locally, it connects to the CVS \"server\" program, which\nmaintains the repository.  For more information on how to connect see\n*note Connection and Authentication::.\n\nThis document describes the CVS protocol.  Unfortunately, it does not\nyet completely document one aspect of the protocol--the detailed\noperation of each CVS command and option--and one must look at the CVS\nuser documentation, 'cvs.texinfo', for that information.  The protocol\nis non-proprietary (anyone who wants to is encouraged to implement it)\nand an implementation, known as CVS, is available under the GNU General",
            "subsections": []
        },
        "Public License.  The CVS distribution, containing this implementation,": {
            "content": "'cvs.texinfo', and a copy (possibly more or less up to date than what\nyou are reading now) of this document, 'cvsclient.texi', can be found at\nthe usual GNU FTP sites, with a filename such as 'cvs-VERSION.tar.gz'.\n\nThis is version 1.12.13 of the protocol specification.  This version\nnumber is intended only to aid in distinguishing different versions of\nthis specification.  Although the specification is currently maintained\nin conjunction with the CVS implementation, and carries the same version\nnumber, it also intends to document what is involved with interoperating\nwith other implementations (such as other versions of CVS); see *note",
            "subsections": []
        },
        "Requirements::.  This version number should not be used by clients or": {
            "content": "servers to determine what variant of the protocol to speak; they should\ninstead use the 'valid-requests' and 'Valid-responses' mechanism (*note\nProtocol::), which is more flexible.\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Goals,  Next: Connection and Authentication,  Prev: Introduction,  Up: Top": {
            "content": "",
            "subsections": []
        },
        "2 Goals": {
            "content": "* Do not assume any access to the repository other than via this\nprotocol.  It does not depend on NFS, rdist, etc.\n\n* Providing a reliable transport is outside this protocol.  The\nprotocol expects a reliable transport that is transparent (that is,\nthere is no translation of characters, including characters such as\nlinefeeds or carriage returns), and can transmit all 256 octets\n(for example for proper handling of binary files, compression, and\nencryption).  The encoding of characters specified by the protocol\n(the names of requests and so on) is the invariant ISO 646\ncharacter set (a subset of most popular character sets including\nASCII and others).  For more details on running the protocol over\nthe TCP reliable transport, see *note Connection and\nAuthentication::.\n\n* Security and authentication are handled outside this protocol (but\nsee below about 'cvs kserver' and 'cvs pserver').\n\n* The protocol makes it possible for updates to be atomic with\nrespect to checkins; that is if someone commits changes to several\nfiles in one cvs command, then an update by someone else would\neither get all the changes, or none of them.  The current CVS\nserver can't do this, but that isn't the protocol's fault.\n\n* The protocol is, with a few exceptions, transaction-based.  That\nis, the client sends all its requests (without waiting for server\nresponses), and then waits for the server to send back all\nresponses (without waiting for further client requests).  This has\nthe advantage of minimizing network turnarounds and the\ndisadvantage of sometimes transferring more data than would be\nnecessary if there were a richer interaction.  Another, more\nsubtle, advantage is that there is no need for the protocol to\nprovide locking for features such as making checkins atomic with\nrespect to updates.  Any such locking can be handled entirely by\nthe server.  A good server implementation (such as the current CVS\nserver) will make sure that it does not have any such locks in\nplace whenever it is waiting for communication with the client;\nthis prevents one client on a slow or flaky network from\ninterfering with the work of others.\n\n* It is a general design goal to provide only one way to do a given\noperation (where possible).  For example, implementations have no\nchoice about whether to terminate lines with linefeeds or some\nother character(s), and request and response names are\ncase-sensitive.  This is to enhance interoperability.  If a\nprotocol allows more than one way to do something, it is all too\neasy for some implementations to support only some of them (perhaps\naccidentally).\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Connection and Authentication,  Next: Password scrambling,  Prev: Goals,  Up: Top": {
            "content": "",
            "subsections": []
        },
        "3 How to Connect to and Authenticate Oneself to the CVS server": {
            "content": "",
            "subsections": []
        },
        "Connection and authentication occurs before the CVS protocol itself is": {
            "content": "started.  There are several ways to connect.\n\nserver\nIf the client has a way to execute commands on the server, and\nprovide input to the commands and output from them, then it can\nconnect that way.  This could be the usual rsh (port 514) protocol,\nKerberos rsh, SSH, or any similar mechanism.  The client may allow\nthe user to specify the name of the server program; the default is\n'cvs'.  It is invoked with one argument, 'server'.  Once it invokes\nthe server, the client proceeds to start the cvs protocol.\n\nkserver\nThe kerberised server listens on a port (in the current\nimplementation, by having inetd call \"cvs kserver\") which defaults\nto 1999.  The client connects, sends the usual kerberos\nauthentication information, and then starts the cvs protocol.\nNote: port 1999 is officially registered for another use, and in\nany event one cannot register more than one port for CVS, so\nGSS-API (see below) is recommended instead of kserver as a way to\nsupport kerberos.\n\npserver\nThe name \"pserver\" is somewhat confusing.  It refers to both a\ngeneric framework which allows the CVS protocol to support several\nauthentication mechanisms, and a name for a specific mechanism\nwhich transfers a username and a cleartext password.  Servers need\nnot support all mechanisms, and in fact servers will typically want\nto support only those mechanisms which meet the relevant security\nneeds.\n\nThe pserver server listens on a port (in the current\nimplementation, by having inetd call \"cvs pserver\") which defaults\nto 2401 (this port is officially registered).  The client connects,\nand sends the following:\n\n* the string 'BEGIN AUTH REQUEST', a linefeed,\n* the cvs root, a linefeed,\n* the username, a linefeed,\n* the password trivially encoded (see *note Password\nscrambling::), a linefeed,\n* the string 'END AUTH REQUEST', and a linefeed.\n\nThe client must send the identical string for cvs root both here\nand later in the 'Root' request of the cvs protocol itself.\nServers are encouraged to enforce this restriction.  The possible\nserver responses (each of which is followed by a linefeed) are the\nfollowing.  Note that although there is a small similarity between\nthis authentication protocol and the cvs protocol, they are\nseparate.\n\n'I LOVE YOU'\nThe authentication is successful.  The client proceeds with\nthe cvs protocol itself.\n\n'I HATE YOU'\nThe authentication fails.  After sending this response, the\nserver may close the connection.  It is up to the server to\ndecide whether to give this response, which is generic, or a\nmore specific response using 'E' and/or 'error'.\n\n'E TEXT'\nProvide a message for the user.  After this reponse, the\nauthentication protocol continues with another response.\nTypically the server will provide a series of 'E' responses\nfollowed by 'error'.  Compatibility note: CVS 1.9.10 and older\nclients will print 'unrecognized auth response' and TEXT, and\nthen exit, upon receiving this response.\n\n'error CODE TEXT'\nThe authentication fails.  After sending this response, the\nserver may close the connection.  The CODE is a code\ndescribing why it failed, intended for computer consumption.\nThe only code currently defined is '0' which is nonspecific,\nbut clients must silently treat any unrecognised codes as\nnonspecific.  The TEXT should be supplied to the user.\nCompatibility note: CVS 1.9.10 and older clients will print\n'unrecognized auth response' and TEXT, and then exit, upon\nreceiving this response.  Note that TEXT for this response, or\nthe TEXT in an 'E' response, is not designed for machine\nparsing.  More vigorous use of CODE, or future extensions,\nwill be needed to prove a cleaner machine-parseable indication\nof what the error was.\n\nIf the client wishes to merely authenticate without starting the\ncvs protocol, the procedure is the same, except BEGIN AUTH REQUEST\nis replaced with BEGIN VERIFICATION REQUEST, END AUTH REQUEST is\nreplaced with END VERIFICATION REQUEST, and upon receipt of I LOVE\nYOU the connection is closed rather than continuing.\n\nAnother mechanism is GSSAPI authentication.  GSSAPI is a generic\ninterface to security services such as kerberos.  GSSAPI is\nspecified in RFC2078 (GSSAPI version 2) and RFC1508 (GSSAPI version\n1); we are not aware of differences between the two which affect\nthe protocol in incompatible ways, so we make no attempt to specify\none version or the other.  The procedure here is to start with\n'BEGIN GSSAPI REQUEST'.  GSSAPI authentication information is then\nexchanged between the client and the server.  Each packet of\ninformation consists of a two byte big endian length, followed by\nthat many bytes of data.  After the GSSAPI authentication is\ncomplete, the server continues with the responses described above\n('I LOVE YOU', etc.).\n\nfuture possibilities\nThere are a nearly unlimited number of ways to connect and\nauthenticate.  One might want to allow access based on IP address\n(similar to the usual rsh protocol but with different/no\nrestrictions on ports < 1024), to adopt mechanisms such as\nPluggable Authentication Modules (PAM), to allow users to run their\nown servers under their own usernames without root access, or any\nnumber of other possibilities.  The way to add future mechanisms,\nfor the most part, should be to continue to use port 2401, but to\nuse different strings in place of 'BEGIN AUTH REQUEST'.\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Password scrambling,  Next: Protocol,  Prev: Connection and Authentication,  Up: Top": {
            "content": "",
            "subsections": []
        },
        "4 Password scrambling algorithm": {
            "content": "The pserver authentication protocol, as described in *note Connection\nand Authentication::, trivially encodes the passwords.  This is only to\nprevent inadvertent compromise; it provides no protection against even a\nrelatively unsophisticated attacker.  For comparison, HTTP Basic",
            "subsections": []
        },
        "Authentication (as described in RFC2068) uses BASE64 for a similar": {
            "content": "purpose.  CVS uses its own algorithm, described here.\n\nThe scrambled password starts with 'A', which serves to identify the\nscrambling algorithm in use.  After that follows a single octet for each\ncharacter in the password, according to a fixed encoding.  The values\nare shown here, with the encoded values in decimal.  Control characters,\nspace, and characters outside the invariant ISO 646 character set are\nnot shown; such characters are not recommended for use in passwords.\nThere is a long discussion of character set issues in *note Protocol\nNotes::.\n\n0 111           P 125           p  58\n! 120   1  52   A  57   Q  55   a 121   q 113\n\"  53   2  75   B  83   R  54   b 117   r  32\n3 119   C  43   S  66   c 104   s  90\n4  49   D  46   T 124   d 101   t  44\n% 109   5  34   E 102   U 126   e 100   u  98\n&  72   6  82   F  40   V  59   f  69   v  60\n' 108   7  81   G  89   W  47   g  73   w  51\n(  70   8  95   H  38   X  92   h  99   x  33\n)  64   9  65   I 103   Y  71   i  63   y  97\n*  76   : 112   J  45   Z 115   j  94   z  62\n+  67   ;  86   K  50           k  93\n, 116   < 118   L  42           l  39\n-  74   = 110   M 123           m  37\n.  68   > 122   N  91           n  61\n/  87   ? 105   O  35     56   o  48\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Protocol,  Next: Protocol Notes,  Prev: Password scrambling,  Up: Top": {
            "content": "",
            "subsections": []
        },
        "5 The CVS client/server protocol": {
            "content": "In the following, '\\n' refers to a linefeed and '\\t' refers to a\nhorizontal tab; \"requests\" are what the client sends and \"responses\" are\nwhat the server sends.  In general, the connection is governed by the\nclient--the server does not send responses without first receiving\nrequests to do so; see *note Response intro:: for more details of this\nconvention.\n\nIt is typical, early in the connection, for the client to transmit a\n'Valid-responses' request, containing all the responses it supports,\nfollowed by a 'valid-requests' request, which elicits from the server a\n'Valid-requests' response containing all the requests it understands.",
            "subsections": []
        },
        "In this way, the client and server each find out what the other supports": {
            "content": "before exchanging large amounts of data (such as file contents).\n\n* Menu:\n\n\nGeneral protocol conventions:\n\n* Entries Lines::                   Transmitting RCS data\n* File Modes::                      Read, write, execute, and possibly more...\n* Filenames::                       Conventions regarding filenames\n* File transmissions::              How file contents are transmitted\n* Strings::                         Strings in various requests and responses\n* Dates::                           Times and dates\n\nThe protocol itself:\n\n* Request intro::                   General conventions relating to requests\n* Requests::                        List of requests\n* Response intro::                  General conventions relating to responses\n* Response pathnames::              The \"pathname\" in responses\n* Responses::                       List of responses\n* Text tags::                       More details about the MT response\n\nAn example session, and some further observations:\n\n* Example::                         A conversation between client and server\n* Requirements::                    Things not to omit from an implementation\n* Obsolete::                        Former protocol features\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Entries Lines,  Next: File Modes,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.1 Entries Lines",
                    "content": "Entries lines are transmitted as:\n\n/ NAME / VERSION / CONFLICT / OPTIONS / TAGORDATE\n\nTAGORDATE is either 'T' TAG or 'D' DATE or empty.  If it is\nfollowed by a slash, anything after the slash shall be silently ignored.\n\nVERSION can be empty, or start with '0' or '-', for no user file, new\nuser file, or user file to be removed, respectively.\n\nCONFLICT, if it starts with '+', indicates that the file had\nconflicts in it.  The rest of CONFLICT is '=' if the timestamp matches\nthe file, or anything else if it doesn't.  If CONFLICT does not start\nwith a '+', it is silently ignored.\n\nOPTIONS signifies the keyword expansion options (for example '-ko')."
                }
            ]
        },
        "In an 'Entry' request, this indicates the options that were specified": {
            "content": "with the file from the previous file updating response (*note Response\nintro::, for a list of file updating responses); if the client is\nspecifying the '-k' or '-A' option to 'update', then it is the server\nwhich figures out what overrides what.\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: File Modes,  Next: Filenames,  Prev: Entries Lines,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.2 File Modes",
                    "content": "A mode is any number of repetitions of\n\nMODE-TYPE = DATA\n\nseparated by ','.\n\nMODE-TYPE is an identifier composed of alphanumeric characters."
                }
            ]
        },
        "Currently specified: 'u' for user, 'g' for group, 'o' for other (see": {
            "content": "below for discussion of whether these have their POSIX meaning or are\nmore loose).  Unrecognised values of MODE-TYPE are silently ignored.\n\nDATA consists of any data not containing ',', '\\0' or '\\n'.  For 'u',\n'g', and 'o' mode types, data consists of alphanumeric characters, where\n'r' means read, 'w' means write, 'x' means execute, and unrecognised\nletters are silently ignored.\n\nThe two most obvious ways in which the mode matters are: (1) is it\nwriteable?  This is used by the developer communication features, and is\nimplemented even on OS/2 (and could be implemented on DOS), whose notion\nof mode is limited to a readonly bit.  (2) is it executable?  Unix CVS\nusers need CVS to store this setting (for shell scripts and the like).",
            "subsections": []
        },
        "The current CVS implementation on unix does a little bit more than just": {
            "content": "maintain these two settings, but it doesn't really have a nice general\nfacility to store or version control the mode, even on unix, much less\nacross operating systems with diverse protection features.  So all the\nins and outs of what the mode means across operating systems haven't\nreally been worked out (e.g.  should the VMS port use ACLs to get POSIX\nsemantics for groups?).\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Filenames,  Next: File transmissions,  Prev: File Modes,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.3 Conventions regarding transmission of file names",
                    "content": ""
                }
            ]
        },
        "In most contexts, '/' is used to separate directory and file names in": {
            "content": "filenames, and any use of other conventions (for example, that the user\nmight type on the command line) is converted to that form.  The only\nexceptions might be a few cases in which the server provides a magic\ncookie which the client then repeats verbatim, but as the server has not\nyet been ported beyond unix, the two rules provide the same answer (and\nwhat to do if future server ports are operating on a repository like\ne:/foo or CVSROOT:[FOO.BAR] has not been carefully thought out).\n\nCharacters outside the invariant ISO 646 character set should be\navoided in filenames.  This restriction may need to be relaxed to allow\nfor characters such as '[' and ']' (see above about non-unix servers);\nthis has not been carefully considered (and currently implementations\nprobably use whatever character sets that the operating systems they are\nrunning on allow, and/or that users specify).  Of course the most\nportable practice is to restrict oneself further, to the POSIX portable\nfilename character set as specified in POSIX.1.\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: File transmissions,  Next: Strings,  Prev: Filenames,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.4 File transmissions",
                    "content": ""
                }
            ]
        },
        "File contents (noted below as FILE TRANSMISSION) can be sent in one of": {
            "content": "two forms.  The simpler form is a number of bytes, followed by a\nlinefeed, followed by the specified number of bytes of file contents.",
            "subsections": []
        },
        "These are the entire contents of the specified file.  Second, if both": {
            "content": "client and server support 'gzip-file-contents', a 'z' may precede the\nlength, and the 'file contents' sent are actually compressed with 'gzip'\n(RFC1952/1951) compression.  The length specified is that of the\ncompressed version of the file.\n\nIn neither case are the file content followed by any additional data.",
            "subsections": []
        },
        "The transmission of a file will end with a linefeed iff that file (or": {
            "content": "its compressed form) ends with a linefeed.\n\nThe encoding of file contents depends on the value for the '-k'\noption.  If the file is binary (as specified by the '-kb' option in the\nappropriate place), then it is just a certain number of octets, and the\nprotocol contributes nothing towards determining the encoding (using the\nfile name is one widespread, if not universally popular, mechanism).  If\nthe file is text (not binary), then the file is sent as a series of\nlines, separated by linefeeds.  If the keyword expansion is set to\nsomething other than '-ko', then it is expected that the file conform to\nthe RCS expectations regarding keyword expansion--in particular, that it\nis in a character set such as ASCII in which 0x24 is a dollar sign\n('$').\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Strings,  Next: Dates,  Prev: File transmissions,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.5 Strings",
                    "content": ""
                }
            ]
        },
        "In various contexts, for example the 'Argument' request and the 'M'": {
            "content": "response, one transmits what is essentially an arbitrary string.  Often\nthis will have been supplied by the user (for example, the '-m' option\nto the 'ci' request will show up in the 'LOGM' response).  The protocol\nhas no mechanism to specify the character set of such strings; it would\nhave been, initially, fairly safe to stick to the invariant ISO 646\ncharacter set but the existing practice is probably to just transmit\nwhatever the user specifies, and hope that everyone involved agrees\nwhich character set is in use, or sticks to a common subset.  In modern\ntimes, UTF-8 should be used.\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Dates,  Next: Request intro,  Prev: Strings,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.6 Dates",
                    "content": "The protocol contains times and dates in various places.\n\nFor the '-D' option to the 'annotate', 'co', 'diff', 'export',\n'history', 'rannotate', 'rdiff', 'rtag', 'tag', and 'update' requests,\nthe server should support two formats:\n\n26 May 1997 13:01:40 -0000  ; RFC 822 as modified by RFC 1123\n5/26/1997 13:01:40 GMT    ; traditional\n\nThe former format is preferred; the latter however is sent by the CVS\ncommand line client (versions 1.5 through at least 1.9).\n\nFor the '-d' option to the 'log' and 'rlog' requests, servers should\nat least support RFC 822/1123 format.  Clients are encouraged to use\nthis format too (the command line CVS client, version 1.10 and older,\njust passed along the date format specified by the user, however).\n\nThe 'Mod-time' response and 'Checkin-time' request use RFC 822/1123\nformat (see the descriptions of that response and request for details).\n\nFor 'Notify', see the description of that request.\n"
                }
            ]
        },
        "File: cvsclient.info,  Node: Request intro,  Next: Requests,  Prev: Dates,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.7 Request intro",
                    "content": ""
                }
            ]
        },
        "By convention, requests which begin with a capital letter do not elicit": {
            "content": "a response from the server, while all others do - save one.  The\nexception is 'gzip-file-contents'.  Unrecognised requests will always\nelicit a response from the server, even if that request begins with a\ncapital letter.\n\nThe term \"command\" means a request which expects a response (except\n'valid-requests').  The general model is that the client transmits a\ngreat number of requests, but nothing happens until the very end when\nthe client transmits a command.  Although the intention is that\ntransmitting several commands in one connection should be legal,\nexisting servers probably have some bugs with some combinations of more\nthan one command, and so clients may find it necessary to make several\nconnections in some cases.  This should be thought of as a workaround\nrather than a desired attribute of the protocol.\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Requests,  Next: Response intro,  Prev: Request intro,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.8 Requests",
                    "content": "Here are the requests:\n\n'Root PATHNAME \\n'\nResponse expected: no.  Tell the server which 'CVSROOT' to use.\nNote that PATHNAME is a local directory and not a fully qualified\n'CVSROOT' variable.  PATHNAME must already exist; if creating a new\nroot, use the 'init' request, not 'Root'.  PATHNAME does not\ninclude the hostname of the server, how to access the server, etc.;\nby the time the CVS protocol is in use, connection, authentication,\netc., are already taken care of.\n\nThe 'Root' request must be sent only once, and it must be sent\nbefore any requests other than 'Valid-responses', 'valid-requests',\n'UseUnchanged', 'Set', 'Globaloption', 'init', 'noop', or\n'version'.\n\n'Valid-responses REQUEST-LIST \\n'\nResponse expected: no.  Tell the server what responses the client\nwill accept.  request-list is a space separated list of tokens.\nThe 'Root' request need not have been previously sent.\n\n'valid-requests \\n'\nResponse expected: yes.  Ask the server to send back a\n'Valid-requests' response.  The 'Root' request need not have been\npreviously sent.\n\n'Command-prep COMMAND \\n'\nResponse expected: yes.  Notify the server of the command that we\nare leading up to.  Intended to allow the server to send a redirect\nfor write operations.  Requires either an 'ok' or 'Redirect'\nrespnose.\n\n'Referrer CVSROOT \\n'\nResponse expected: no.  Notify a primary server of a server which\nreferred us.  Intended to allow a primary (write) server to update\nthe read-only mirror a client is using for reads to minimise races\non any subsequent updates from the client.\n\n'Directory LOCAL-DIRECTORY \\n'\n'Relative-directory LOCAL-DIRECTORY \\n'\nAdditional data: REPOSITORY \\n.  Response expected: no.  Tell the\nserver what directory to use.\n\nThe REPOSITORY should be a directory name from a previous server\nresponse and may be specified either relative to the PATHNAME\nprovided with the 'Root' request or absolute.  Relative or\nabsolute, it must specify a path within PATHNAME.\n\nPrior to CVS version *FIXME - release number 1.12.10?*, REPOSITORY\nhad to be absolute and 'Relative-directory' was not a valid\nrequest.  The 'Relative-directory' request is synonymous with\n'Directory' and is provided to alert modern clients that a relative\nREPOSITORY is acceptable.\n\nNote that this both gives a default for 'Entry' and 'Modified' and\nalso for 'ci' and the other commands; normal usage is to send\n'Directory' for each directory in which there will be an 'Entry' or\n'Modified', and then a final 'Directory' for the original\ndirectory, then the command.  The LOCAL-DIRECTORY is relative to\nthe top level at which the command is occurring (i.e.  the last\n'Directory' which is sent before the command); to indicate that top\nlevel, '.' should be sent for LOCAL-DIRECTORY.\n\nHere is an example of where a client gets REPOSITORY and\nLOCAL-DIRECTORY.  Suppose that there is a module defined by\n\nmoddir 1dir\n\nThat is, one can check out 'moddir' and it will take '1dir' in the\nrepository and check it out to 'moddir' in the working directory.\nThen an initial check out could proceed like this:\n\nC: Root /home/kingdon/zwork/cvsroot\n. . .\nC: Argument moddir\nC: Directory .\nC: .\nC: co\nS: Clear-sticky moddir/\nS: 1dir/\n. . .\nS: ok\n\nIn this example the response shown is 'Clear-sticky', but it could\nbe another response instead.  Note that it returns two pathnames.\nThe first one, 'moddir/', indicates the working directory to check\nout into.  The second one, ending in '1dir/', indicates the\ndirectory to pass back to the server in a subsequent 'Directory'\nrequest.  For example, a subsequent 'update' request might look\nlike:\n\nC: Directory moddir\nC: 1dir\n. . .\nC: update\n\nFor a given LOCAL-DIRECTORY, the repository will be the same for\neach of the responses, so one can use the repository from whichever\nresponse is most convenient.  Typically a client will store the\nrepository along with the sources for each LOCAL-DIRECTORY, use\nthat same setting whenever operating on that LOCAL-DIRECTORY, and\nnot update the setting as long as the LOCAL-DIRECTORY exists.\n\nA client is free to rename a LOCAL-DIRECTORY at any time (for\nexample, in response to an explicit user request).  While it is\ntrue that the server supplies a LOCAL-DIRECTORY to the client, as\nnoted above, this is only the default place to put the directory.\nOf course, the various 'Directory' requests for a single command\n(for example, 'update' or 'ci' request) should name a particular\ndirectory with the same LOCAL-DIRECTORY.\n\nEach 'Directory' request specifies a brand-new LOCAL-DIRECTORY and\nREPOSITORY; that is, LOCAL-DIRECTORY and REPOSITORY are never\nrelative to paths specified in any previous 'Directory' request.\n\nHere's a more complex example, in which we request an update of a\nworking directory which has been checked out from multiple places\nin the repository.\n\nC: Argument dir1\nC: Directory dir1\nC: mod1\n. . .\nC: Argument dir2\nC: Directory dir2\nC: mod2\n. . .\nC: Argument dir3\nC: Directory dir3/subdir3\nC: mod3\n. . .\nC: update\n\nWhile directories 'dir1' and 'dir2' will be handled in similar\nfashion to the other examples given above, 'dir3' is slightly\ndifferent from the server's standpoint.  Notice that module 'mod3'\nis actually checked out into 'dir3/subdir3', meaning that directory\n'dir3' is either empty or does not contain data checked out from\nthis repository.\n\nThe above example will work correctly in CVS 1.10.1 and later.  The\nserver will descend the tree starting from all directories\nmentioned in 'Argument' requests and update those directories\nspecifically mentioned in 'Directory' requests.\n\nPrevious versions of CVS (1.10 and earlier) do not behave the same\nway.  While the descent of the tree begins at all directories\nmentioned in 'Argument' requests, descent into subdirectories only\noccurs if a directory has been mentioned in a 'Directory' request.\nTherefore, the above example would succeed in updating 'dir1' and\n'dir2', but would skip 'dir3' because that directory was not\nspecifically mentioned in a 'Directory' request.  A functional\nversion of the above that would run on a 1.10 or earlier server is\nas follows:\n\nC: Argument dir1\nC: Directory dir1\nC: mod1\n. . .\nC: Argument dir2\nC: Directory dir2\nC: mod2\n. . .\nC: Argument dir3\nC: Directory dir3\nC: .\n. . .\nC: Directory dir3/subdir3\nC: mod3\n. . .\nC: update\n\nNote the extra 'Directory dir3' request.  It might be better to use\n'Emptydir' as the repository for the 'dir3' directory, but the\nabove will certainly work.\n\nOne more peculiarity of the 1.10 and earlier protocol is the\nordering of 'Directory' arguments.  In order for a subdirectory to\nbe registered correctly for descent by the recursion processor, its\nparent must be sent first.  For example, the following would not\nwork to update 'dir3/subdir3':\n\n. . .\nC: Argument dir3\nC: Directory dir3/subdir3\nC: mod3\n. . .\nC: Directory dir3\nC: .\n. . .\nC: update\n\nThe implementation of the server in 1.10 and earlier writes the\nadministration files for a given directory at the time of the\n'Directory' request.  It also tries to register the directory with\nits parent to mark it for recursion.  In the above example, at the\ntime 'dir3/subdir3' is created, the physical directory for 'dir3'\nwill be created on disk, but the administration files will not have\nbeen created.  Therefore, when the server tries to register\n'dir3/subdir3' for recursion, the operation will silently fail\nbecause the administration files do not yet exist for 'dir3'.\n\n'Max-dotdot LEVEL \\n'\nResponse expected: no.  Tell the server that LEVEL levels of\ndirectories above the directory which 'Directory' requests are\nrelative to will be needed.  For example, if the client is planning\nto use a 'Directory' request for '../../foo', it must send a\n'Max-dotdot' request with a LEVEL of at least 2.  'Max-dotdot' must\nbe sent before the first 'Directory' request.\n\n'Static-directory \\n'\nResponse expected: no.  Tell the server that the directory most\nrecently specified with 'Directory' should not have additional\nfiles checked out unless explicitly requested.  The client sends\nthis if the 'Entries.Static' flag is set, which is controlled by\nthe 'Set-static-directory' and 'Clear-static-directory' responses.\n\n'Sticky TAGSPEC \\n'\nResponse expected: no.  Tell the server that the directory most\nrecently specified with 'Directory' has a sticky tag or date\nTAGSPEC.  The first character of TAGSPEC is 'T' for a tag, 'D' for\na date, or some other character supplied by a Set-sticky response\nfrom a previous request to the server.  The remainder of TAGSPEC\ncontains the actual tag or date, again as supplied by Set-sticky.\n\nThe server should remember 'Static-directory' and 'Sticky' requests\nfor a particular directory; the client need not resend them each\ntime it sends a 'Directory' request for a given directory.\nHowever, the server is not obliged to remember them beyond the\ncontext of a single command.\n\n'Checkin-prog PROGRAM \\n'\nResponse expected: no.  Tell the server that the directory most\nrecently specified with 'Directory' has a checkin program PROGRAM.\nSuch a program would have been previously set with the\n'Set-checkin-prog' response.\n\n'Update-prog PROGRAM \\n'\nResponse expected: no.  Tell the server that the directory most\nrecently specified with 'Directory' has an update program PROGRAM.\nSuch a program would have been previously set with the\n'Set-update-prog' response.\n\n'Entry ENTRY-LINE \\n'\nResponse expected: no.  Tell the server what version of a file is\non the local machine.  The name in ENTRY-LINE is a name relative to\nthe directory most recently specified with 'Directory'.  If the\nuser is operating on only some files in a directory, 'Entry'\nrequests for only those files need be included.  If an 'Entry'\nrequest is sent without 'Modified', 'Is-modified', or 'Unchanged',\nit means the file is lost (does not exist in the working\ndirectory).  If both 'Entry' and one of 'Modified', 'Is-modified',\nor 'Unchanged' are sent for the same file, 'Entry' must be sent\nfirst.  For a given file, one can send 'Modified', 'Is-modified',\nor 'Unchanged', but not more than one of these three.\n\n'Kopt OPTION \\n'\nThis indicates to the server which keyword expansion options to use\nfor the file specified by the next 'Modified' or 'Is-modified'\nrequest (for example '-kb' for a binary file).  This is similar to\n'Entry', but is used for a file for which there is no entries line.\nTypically this will be a file being added via an 'add' or 'import'\nrequest.  The client may not send both 'Kopt' and 'Entry' for the\nsame file.\n\n'Checkin-time TIME \\n'\nFor the file specified by the next 'Modified' request, use TIME as\nthe time of the checkin.  The TIME is in the format specified by\nRFC822 as modified by RFC1123.  The client may specify any timezone\nit chooses; servers will want to convert that to their own timezone\nas appropriate.  An example of this format is:\n\n26 May 1997 13:01:40 -0400\n\nThere is no requirement that the client and server clocks be\nsynchronised.  The client just sends its recommendation for a\ntimestamp (based on file timestamps or whatever), and the server\nshould just believe it (this means that the time might be in the\nfuture, for example).\n\nNote that this is not a general-purpose way to tell the server\nabout the timestamp of a file; that would be a separate request (if\nthere are servers which can maintain timestamp and time of checkin\nseparately).\n\nThis request should affect the 'import' request, and may optionally\naffect the 'ci' request or other relevant requests if any.\n\n'Modified FILENAME \\n'\nResponse expected: no.  Additional data: mode, \\n, file\ntransmission.  Send the server a copy of one locally modified file.\nFILENAME is a file within the most recent directory sent with\n'Directory'; it must not contain '/'.  If the user is operating on\nonly some files in a directory, only those files need to be\nincluded.  This can also be sent without 'Entry', if there is no\nentry for the file.\n\n'Is-modified FILENAME \\n'\nResponse expected: no.  Additional data: none.  Like 'Modified',\nbut used if the server only needs to know whether the file is\nmodified, not the contents.\n\nThe commands which can take 'Is-modified' instead of 'Modified'\nwith no known change in behavior are: 'admin', 'diff' (if and only\nif two '-r' or '-D' options are specified), 'watch-on',\n'watch-off', 'watch-add', 'watch-remove', 'watchers', 'editors',\n'log', and 'annotate'.\n\nFor the 'status' command, one can send 'Is-modified' but if the\nclient is using imperfect mechanisms such as timestamps to\ndetermine whether to consider a file modified, then the behavior\nwill be different.  That is, if one sends 'Modified', then the\nserver will actually compare the contents of the file sent and the\none it derives from to determine whether the file is genuinely\nmodified.  But if one sends 'Is-modified', then the server takes\nthe client's word for it.  A similar situation exists for 'tag', if\nthe '-c' option is specified.\n\nCommands for which 'Modified' is necessary are 'co', 'ci',\n'update', and 'import'.\n\nCommands which do not need to inform the server about a working\ndirectory, and thus should not be sending either 'Modified' or\n'Is-modified': 'rdiff', 'rtag', 'history', 'init', and 'release'.\n\nCommands for which further investigation is warranted are:\n'remove', 'add', and 'export'.  Pending such investigation, the\nmore conservative course of action is to stick to 'Modified'.\n\n'Unchanged FILENAME \\n'\nResponse expected: no.  Tell the server that FILENAME has not been\nmodified in the checked out directory.  The FILENAME is a file\nwithin the most recent directory sent with 'Directory'; it must not\ncontain '/'.\n\n'UseUnchanged \\n'\nResponse expected: no.  To specify the version of the protocol\ndescribed in this document, servers must support this request\n(although it need not do anything) and clients must issue it.  The\n'Root' request need not have been previously sent.\n\n'Notify FILENAME \\n'\nResponse expected: no.  Tell the server that an 'edit' or 'unedit'\ncommand has taken place.  The server needs to send a 'Notified'\nresponse, but such response is deferred until the next time that\nthe server is sending responses.  The FILENAME is a file within the\nmost recent directory sent with 'Directory'; it must not contain\n'/'.  Additional data:\nNOTIFICATION-TYPE \\t TIME \\t CLIENTHOST \\t\nWORKING-DIR \\t WATCHES \\n\nwhere NOTIFICATION-TYPE is 'E' for edit, 'U' for unedit, undefined\nbehavior if 'C', and all other letters should be silently ignored\nfor future expansion.  TIME is the time at which the edit or unedit\ntook place, in a user-readable format of the client's choice (the\nserver should treat the time as an opaque string rather than\ninterpreting it).  CLIENTHOST is the name of the host on which the\nedit or unedit took place, and WORKING-DIR is the pathname of the\nworking directory where the edit or unedit took place.  WATCHES are\nthe temporary watches, zero or more of the following characters in\nthe following order: 'E' for edit, 'U' for unedit, 'C' for commit,\nand all other letters should be silently ignored for future\nexpansion.  If NOTIFICATION-TYPE is 'E' the temporary watches are\nset; if it is 'U' they are cleared.  If WATCHES is followed by \\t\nthen the \\t and the rest of the line should be ignored, for future\nexpansion.\n\nThe TIME, CLIENTHOST, and WORKING-DIR fields may not contain the\ncharacters '+', ',', '>', ';', or '='.\n\nNote that a client may be capable of performing an 'edit' or\n'unedit' operation without connecting to the server at that time,\nand instead connecting to the server when it is convenient (for\nexample, when a laptop is on the net again) to send the 'Notify'\nrequests.  Even if a client is capable of deferring notifications,\nit should attempt to send them immediately (one can send 'Notify'\nrequests together with a 'noop' request, for example), unless\nperhaps if it can know that a connection would be impossible.\n\n'Questionable FILENAME \\n'\nResponse expected: no.  Additional data: no.  Tell the server to\ncheck whether FILENAME should be ignored, and if not, next time the\nserver sends responses, send (in a 'M' response) '?' followed by\nthe directory and filename.  FILENAME must not contain '/'; it\nneeds to be a file in the directory named by the most recent\n'Directory' request.\n\n'Case \\n'\nResponse expected: no.  Tell the server that filenames should be\nmatched in a case-insensitive fashion.  Note that this is not the\nprimary mechanism for achieving case-insensitivity; for the most\npart the client keeps track of the case which the server wants to\nuse and takes care to always use that case regardless of what the\nuser specifies.  For example the filenames given in 'Entry' and\n'Modified' requests for the same file must match in case regardless\nof whether the 'Case' request is sent.  The latter mechanism is\nmore general (it could also be used for 8.3 filenames, VMS\nfilenames with more than one '.', and any other situation in which\nthere is a predictable mapping between filenames in the working\ndirectory and filenames in the protocol), but there are some\nsituations it cannot handle (ignore patterns, or situations where\nthe user specifies a filename and the client does not know about\nthat file).\n\nThough this request will be supported into the forseeable future,\nit has been the source of numerous bug reports in the past due to\nthe complexity of testing this functionality via the test suite and\nclient developers are encouraged not to use it.  Instead, please\nconsider munging conflicting names and maintaining a map for\ncommunicating with the server.  For example, suppose the server\nsends files 'case', 'CASE', and 'CaSe'.  The client could write all\nthree files to names such as, 'case', 'caseprefixcase', and\n'caseprefix2case' and maintain a mapping between the file names\nin, for instance a new 'CVS/Map' file.\n\n'Argument TEXT \\n'\nResponse expected: no.  Save argument for use in a subsequent\ncommand.  Arguments accumulate until an argument-using command is\ngiven, at which point they are forgotten.\n\n'Argumentx TEXT \\n'\nResponse expected: no.  Append \\n followed by text to the current\nargument being saved.\n\n'Globaloption OPTION \\n'\nResponse expected: no.  Transmit one of the global options '-q',\n'-Q', '-l', '-t', '-r', or '-n'.  OPTION must be one of those\nstrings, no variations (such as combining of options) are allowed.\nFor graceful handling of 'valid-requests', it is probably better to\nmake new global options separate requests, rather than trying to\nadd them to this request.  The 'Root' request need not have been\npreviously sent.\n\n'Gzip-stream LEVEL \\n'\nResponse expected: no.  Use zlib (RFC 1950/1951) compression to\ncompress all further communication between the client and the\nserver.  As of CVS 1.12.13, this request needs to be sent as the\nfirst non-rootless request if the server is configured with\ncompression level restrictions and LEVEL is outside the restricted\nrange.  After this request is sent, all further communication must\nbe compressed.  All further data received from the server will also\nbe compressed.  The LEVEL argument suggests to the server the level\nof compression that it should apply; it should be an integer\nbetween 0 and 9, inclusive, where '0' means no compression and\nhigher numbers indicate more compression.\n\n'Kerberos-encrypt \\n'\nResponse expected: no.  Use Kerberos encryption to encrypt all\nfurther communication between the client and the server.  This will\nonly work if the connection was made over Kerberos in the first\nplace.  If both the 'Gzip-stream' and the 'Kerberos-encrypt'\nrequests are used, the 'Kerberos-encrypt' request should be used\nfirst.  This will make the client and server encrypt the compressed\ndata, as opposed to compressing the encrypted data.  Encrypted data\nis generally incompressible.\n\nNote that this request does not fully prevent an attacker from\nhijacking the connection, in the sense that it does not prevent\nhijacking the connection between the initial authentication and the\n'Kerberos-encrypt' request.\n\n'Gssapi-encrypt \\n'\nResponse expected: no.  Use GSSAPI encryption to encrypt all\nfurther communication between the client and the server.  This will\nonly work if the connection was made over GSSAPI in the first\nplace.  See 'Kerberos-encrypt', above, for the relation between\n'Gssapi-encrypt' and 'Gzip-stream'.\n\nNote that this request does not fully prevent an attacker from\nhijacking the connection, in the sense that it does not prevent\nhijacking the connection between the initial authentication and the\n'Gssapi-encrypt' request.\n\n'Gssapi-authenticate \\n'\nResponse expected: no.  Use GSSAPI authentication to authenticate\nall further communication between the client and the server.  This\nwill only work if the connection was made over GSSAPI in the first\nplace.  Encrypted data is automatically authenticated, so using\nboth 'Gssapi-authenticate' and 'Gssapi-encrypt' has no effect\nbeyond that of 'Gssapi-encrypt'.  Unlike encrypted data, it is\nreasonable to compress authenticated data.\n\nNote that this request does not fully prevent an attacker from\nhijacking the connection, in the sense that it does not prevent\nhijacking the connection between the initial authentication and the\n'Gssapi-authenticate' request.\n\n'Set VARIABLE=VALUE \\n'\nResponse expected: no.  Set a user variable VARIABLE to VALUE.  The\n'Root' request need not have been previously sent.\n\n'Hostname HOSTNAME \\n'\nResponse expected: no.  Set the client hostname for an upcoming\n'edit' request.\n\n'LocalDir HOSTNAME \\n'\nResponse expected: no.  Set the local client directory name for an\nupcoming 'edit' request.\n\n'expand-modules \\n'\nResponse expected: yes.  Expand the modules which are specified in\nthe arguments.  Returns the data in 'Module-expansion' responses.\nNote that the server can assume that this is checkout or export,\nnot rtag or rdiff; the latter do not access the working directory\nand thus have no need to expand modules on the client side.\n\nExpand may not be the best word for what this request does.  It\ndoes not necessarily tell you all the files contained in a module,\nfor example.  Basically it is a way of telling you which working\ndirectories the server needs to know about in order to handle a\ncheckout of the specified modules.\n\nFor example, suppose that the server has a module defined by\n\naliasmodule -a 1dir\n\nThat is, one can check out 'aliasmodule' and it will take '1dir' in\nthe repository and check it out to '1dir' in the working directory.\nNow suppose the client already has this module checked out and is\nplanning on using the 'co' request to update it.  Without using\n'expand-modules', the client would have two bad choices: it could\neither send information about all working directories under the\ncurrent directory, which could be unnecessarily slow, or it could\nbe ignorant of the fact that 'aliasmodule' stands for '1dir', and\nneglect to send information for '1dir', which would lead to\nincorrect operation.\n\nWith 'expand-modules', the client would first ask for the module to\nbe expanded:\n\nC: Root /home/kingdon/zwork/cvsroot\n. . .\nC: Argument aliasmodule\nC: Directory .\nC: .\nC: expand-modules\nS: Module-expansion 1dir\nS: ok\n\nand then it knows to check the '1dir' directory and send requests\nsuch as 'Entry' and 'Modified' for the files in that directory.\n\n'ci \\n'\n'diff \\n'\n'list \\n'\n'tag \\n'\n'status \\n'\n'admin \\n'\n'history \\n'\n'watchers \\n'\n'editors \\n'\n'annotate \\n'\nResponse expected: yes.  Actually do a cvs command.  This uses any\nprevious 'Argument', 'Directory', 'Entry', or 'Modified' requests,\nif they have been sent.  The last 'Directory' sent specifies the\nworking directory at the time of the operation.  No provision is\nmade for any input from the user.  This means that 'ci' must use a\n'-m' argument if it wants to specify a log message.\n\n'log \\n'\nResponse expected: yes.  Show information for past revisions.  This\nuses any previous 'Directory', 'Entry', or 'Modified' requests, if\nthey have been sent.  The last 'Directory' sent specifies the\nworking directory at the time of the operation.  Also uses previous\n'Argument''s of which the canonical forms are the following (CVS\n1.10 and older clients sent what the user specified, but clients\nare encouraged to use the canonical forms and other forms are\ndeprecated):\n\n'-b, -h, -l, -N, -R, -t'\nThese options go by themselves, one option per 'Argument'\nrequest.\n\n'-d DATE1<DATE2'\nSelect revisions between DATE1 and DATE2.  Either date may be\nomitted in which case there is no date limit at that end of\nthe range (clients may specify dates such as 1 Jan 1970 or 1\nJan 2038 for similar purposes but this is problematic as it\nmakes assumptions about what dates the server supports).\nDates are in RFC822/1123 format.  The '-d' is one 'Argument'\nrequest and the date range is a second one.\n\n'-d DATE1<=DATE2'\nLikewise but compare dates for equality.\n\n'-d SINGLEDATE'\nSelect the single, latest revision dated SINGLEDATE or\nearlier.\n\nTo include several date ranges and/or singledates, repeat the\n'-d' option as many times as necessary.\n\n'-rREV1:REV2'\n'-rBRANCH'\n'-rBRANCH.'\n'-r'\nSpecify revisions (note that REV1 or REV2 can be omitted, or\ncan refer to branches).  Send both the '-r' and the revision\ninformation in a single 'Argument' request.  To include\nseveral revision selections, repeat the '-r' option.\n\n'-s STATE'\n'-w'\n'-wLOGIN'\nSelect on states or users.  To include more than one state or\nuser, repeat the option.  Send the '-s' option as a separate\nargument from the state being selected.  Send the '-w' option\nas part of the same argument as the user being selected.\n\n'co \\n'\nResponse expected: yes.  Get files from the repository.  This uses\nany previous 'Argument', 'Directory', 'Entry', or 'Modified'\nrequests, if they have been sent.  Arguments to this command are\nmodule names; the client cannot know what directories they\ncorrespond to except by (1) just sending the 'co' request, and then\nseeing what directory names the server sends back in its responses,\nand (2) the 'expand-modules' request.\n\n'export \\n'\nResponse expected: yes.  Get files from the repository.  This uses\nany previous 'Argument', 'Directory', 'Entry', or 'Modified'\nrequests, if they have been sent.  Arguments to this command are\nmodule names, as described for the 'co' request.  The intention\nbehind this command is that a client can get sources from a server\nwithout storing CVS information about those sources.  That is, a\nclient probably should not count on being able to take the entries\nline returned in the 'Created' response from an 'export' request\nand send it in a future 'Entry' request.  Note that the entries\nline in the 'Created' response must indicate whether the file is\nbinary or text, so the client can create it correctly.\n\n'ls \\n'\n'rannotate \\n'\n'rdiff \\n'\n'rlist \\n'\n'rlog \\n'\n'rtag \\n'\nResponse expected: yes.  Actually do a cvs command.  This uses any\nprevious 'Argument' requests, if they have been sent.  The client\nshould not send 'Directory', 'Entry', or 'Modified' requests for\nthese commands; they are not used.  Arguments to these commands are\nmodule names, as described for 'co'.  'ls' is a synonym for\n'rlist', for compatibility with CVSNT.\n\n'init ROOT-NAME \\n'\nResponse expected: yes.  If it doesn't already exist, create a CVS\nrepository ROOT-NAME.  Note that ROOT-NAME is a local directory and\nnot a fully qualified 'CVSROOT' variable.  The 'Root' request\nneed not have been previously sent.\n\n'suck \\n'\nResponse expected: yes.  Actually do a 'cvs suck' command.  This\nuses a previous 'Argument' request (only one, because the 'cvs\nsuck' CLI command takes only one).  This is an extension specific\nto MirBSD, MirPorts and Debian.\n\n'update \\n'\nResponse expected: yes.  Actually do a 'cvs update' command.  This\nuses any previous 'Argument', 'Directory', 'Entry', or 'Modified'\nrequests, if they have been sent.  The last 'Directory' sent\nspecifies the working directory at the time of the operation.  The\n'-I' option is not used-files which the client can decide whether\nto ignore are not mentioned and the client sends the 'Questionable'\nrequest for others.\n\n'import \\n'\nResponse expected: yes.  Actually do a 'cvs import' command.  This\nuses any previous 'Argument', 'Directory', 'Entry', or 'Modified'\nrequests, if they have been sent.  The last 'Directory' sent\nspecifies the working directory at the time of the operation -\nunlike most commands, the repository field of each 'Directory'\nrequest is ignored (it merely must point somewhere within the\nroot).  The files to be imported are sent in 'Modified' requests\n(files which the client knows should be ignored are not sent; the\nserver must still process the CVSROOT/cvsignore file unless -I !\nis sent).  A log message must have been specified with a '-m'\nargument.\n\n'add \\n'\nResponse expected: yes.  Add a file or directory.  This uses any\nprevious 'Argument', 'Directory', 'Entry', or 'Modified' requests,\nif they have been sent.  The last 'Directory' sent specifies the\nworking directory at the time of the operation.\n\nTo add a directory, send the directory to be added using\n'Directory' and 'Argument' requests.  For example:\n\nC: Root /u/cvsroot\n. . .\nC: Argument nsdir\nC: Directory nsdir\nC: 1dir/nsdir\nC: Directory .\nC: 1dir\nC: add\nS: M Directory /u/cvsroot/1dir/nsdir put under version control\nS: ok\n\nYou will notice that the server does not signal to the client in\nany particular way that the directory has been successfully added.\nThe client is supposed to just assume that the directory has been\nadded and update its records accordingly.  Note also that adding a\ndirectory is immediate; it does not wait until a 'ci' request as\nfiles do.\n\nTo add a file, send the file to be added using a 'Modified'\nrequest.  For example:\n\nC: Argument nfile\nC: Directory .\nC: 1dir\nC: Modified nfile\nC: u=rw,g=r,o=r\nC: 6\nC: hello\nC: add\nS: E cvs server: scheduling file `nfile' for addition\nS: Mode u=rw,g=r,o=r\nS: Checked-in ./\nS: /u/cvsroot/1dir/nfile\nS: /nfile/0///\nS: E cvs server: use 'cvs commit' to add this file permanently\nS: ok\n\nNote that the file has not been added to the repository; the only\neffect of a successful 'add' request, for a file, is to supply the\nclient with a new entries line containing '0' to indicate an added\nfile.  In fact, the client probably could perform this operation\nwithout contacting the server, although using 'add' does cause the\nserver to perform a few more checks.\n\nThe client sends a subsequent 'ci' to actually add the file to the\nrepository.\n\nAnother quirk of the 'add' request is that with CVS 1.9 and older,\na pathname specified in an 'Argument' request cannot contain '/'.\nThere is no good reason for this restriction, and in fact more\nrecent CVS servers don't have it.  But the way to interoperate with\nthe older servers is to ensure that all 'Directory' requests for\n'add' (except those used to add directories, as described above),\nuse '.' for LOCAL-DIRECTORY.  Specifying another string for\nLOCAL-DIRECTORY may not get an error, but it will get you strange\n'Checked-in' responses from the buggy servers.\n\n'remove \\n'\nResponse expected: yes.  Remove a file.  This uses any previous\n'Argument', 'Directory', 'Entry', or 'Modified' requests, if they\nhave been sent.  The last 'Directory' sent specifies the working\ndirectory at the time of the operation.\n\nNote that this request does not actually do anything to the\nrepository; the only effect of a successful 'remove' request is to\nsupply the client with a new entries line containing '-' to\nindicate a removed file.  In fact, the client probably could\nperform this operation without contacting the server, although\nusing 'remove' may cause the server to perform a few more checks.\n\nThe client sends a subsequent 'ci' request to actually record the\nremoval in the repository.\n\n'edit \\n'\nResponse expected: yes.  Actually do the 'cvs edit' command.  This\nuses any previous 'Argument', 'Directory', 'Entry', 'LocalDir', or\n'Hostname' requests, if they have been sent.  Unless the user has\nrequested that edits not be granted unless no one else is editing a\nfile, a local edit followed by an attempt to send 'Notify' requests\nto the server is preferred.\n\n'watch-on \\n'\n'watch-off \\n'\n'watch-add \\n'\n'watch-remove \\n'\nResponse expected: yes.  Actually do the 'cvs watch on', 'cvs watch\noff', 'cvs watch add', and 'cvs watch remove' commands,\nrespectively.  This uses any previous 'Argument', 'Directory',\n'Entry', or 'Modified' requests, if they have been sent.  The last\n'Directory' sent specifies the working directory at the time of the\noperation.\n\n'release \\n'\nResponse expected: yes.  Note that a 'cvs release' command has\ntaken place and update the history file accordingly.\n\n'global-list-quiet \\n'\nResponse expected: yes.  This request is a synonym for noop, but\nits existance notifies the client that a '-q' option to 'list' and\n'rlist' will be rejected.  This, in a reverse-logic sort of way, is\nhere so that when it isn't received, as for instance from CVSNT,\nthe client will know that the quiet option has to be sent as a\ncommand option rather than a global option.\n\n'noop \\n'\nResponse expected: yes.  This request is a null command in the\nsense that it doesn't do anything, but merely (as with any other\nrequests expecting a response) sends back any responses pertaining\nto pending errors, pending 'Notified' responses, etc.  The 'Root'\nrequest need not have been previously sent.\n\n'update-patches \\n'\nResponse expected: yes.  This request does not actually do\nanything.  It is used as a signal that the server is able to\ngenerate patches when given an 'update' request.  The client must\nissue the '-u' argument to 'update' in order to receive patches.\n\n'gzip-file-contents LEVEL \\n'\nResponse expected: no.  Note that this request does not follow the\nresponse convention stated above.  'Gzip-stream' is suggested\ninstead of 'gzip-file-contents' as it gives better compression; the\nonly reason to implement the latter is to provide compression with\nCVS 1.8 and earlier.  The 'gzip-file-contents' request asks the\nserver to compress files it sends to the client using 'gzip'\n(RFC1952/1951) compression, using the specified level of\ncompression.  If this request is not made, the server must not\ncompress files.\n\nThis is only a hint to the server.  It may still decide (for\nexample, in the case of very small files, or files that already\nappear to be compressed) not to do the compression.  Compression is\nindicated by a 'z' preceding the file length.\n\nAvailability of this request in the server indicates to the client\nthat it may compress files sent to the server, regardless of\nwhether the client actually uses this request.\n\n'wrapper-sendme-rcsOptions \\n'\nResponse expected: yes.  Request that the server transmit mappings\nfrom filenames to keyword expansion modes in 'Wrapper-rcsOption'\nresponses.\n\n'version \\n'\nResponse expected: yes.  Request that the server transmit its\nversion message.  The 'Root' request need not have been previously\nsent.\n\n'OTHER-REQUEST TEXT \\n'\nResponse expected: yes.  Any unrecognised request expects a\nresponse, and does not contain any additional data.  The response\nwill normally be something like 'error unrecognized request', but\nit could be a different error if a previous request which doesn't\nexpect a response produced an error.\n\nWhen the client is done, it drops the connection.\n"
                }
            ]
        },
        "File: cvsclient.info,  Node: Response intro,  Next: Response pathnames,  Prev: Requests,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.9 Introduction to Responses",
                    "content": ""
                }
            ]
        },
        "After a command which expects a response, the server sends however many": {
            "content": "of the following responses are appropriate.  The server should not send\ndata at other times (the current implementation may violate this\nprinciple in a few minor places, where the server is printing an error\nmessage and exiting--this should be investigated further).\n\nAny set of responses always ends with 'error' or 'ok'.  This\nindicates that the response is over.\n\nThe responses 'Checked-in', 'New-entry', 'Updated', 'Created',\n'Update-existing', 'Merged', and 'Patched' are refered to as \"file\nupdating\" responses, because they change the status of a file in the\nworking directory in some way.  The responses 'Mode', 'Mod-time', and\n'Checksum' are referred to as \"file update modifying\" responses because\nthey modify the next file updating response.  In no case shall a file\nupdate modifying response apply to a file updating response other than\nthe next one.  Nor can the same file update modifying response occur\ntwice for a given file updating response (if servers diagnose this\nproblem, it may aid in detecting the case where clients send an update\nmodifying response without following it by a file updating response).\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Response pathnames,  Next: Responses,  Prev: Response intro,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.10 The \"pathname\" in responses",
                    "content": ""
                }
            ]
        },
        "Many of the responses contain something called PATHNAME.  The name is": {
            "content": "somewhat misleading; it actually indicates a pair of pathnames.  First,\na local directory name relative to the directory in which the command\nwas given (i.e.  the last 'Directory' before the command).  Then a\nlinefeed and a repository name.  Then a slash and the filename (without\na ',v' ending).\n\nThe repository name may be absolute or relative to the PATHNAME sent\nwith the 'Root' request.  If absolute, the repository name must begin\nwith the PATHNAME sent with the 'Root' request.  Relative or absolute,\nthe repository name must specify a path underneath the 'Root' PATHNAME.\n\nFor example, for a file 'i386.mh' which is in the local directory\n'gas.clean/config' and for which the repository name is\n'devo/gas/config':\n\ngas.clean/config/\ndevo/gas/config/i386.mh\n\nIf the server wants to tell the client to create a directory, then it\nmerely uses the directory in any response, as described above, and the\nclient should create the directory if it does not exist.  Note that this\nshould only be done one directory at a time, in order to permit the\nclient to correctly store the repository for each directory.  Servers\ncan use requests such as 'Clear-sticky', 'Clear-static-directory', or\nany other requests, to create directories.\n\nSome server implementations may poorly distinguish between a\ndirectory which should not exist and a directory which contains no\nfiles; in order to refrain from creating empty directories a client\nshould both send the '-P' option to 'update' or 'co', and should also\ndetect the case in which the server asks to create a directory but not\nany files within it (in that case the client should remove the directory\nor refrain from creating it in the first place).  Note that servers\ncould clean this up greatly by only telling the client to create\ndirectories if the directory in question should exist, but until servers\ndo this, clients will need to offer the '-P' behavior described above.\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Responses,  Next: Text tags,  Prev: Response pathnames,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.11 Responses",
                    "content": "Here are the responses:\n\n'Valid-requests REQUEST-LIST \\n'\nIndicate what requests the server will accept.  REQUEST-LIST is a\nspace separated list of tokens.  If the server supports sending\npatches, it will include 'update-patches' in this list.  The\n'update-patches' request does not actually do anything.\n\n'Force-gzip \\n'\nResponse expected: no.  Indicates that the server requires\ncompression.  The client must send a 'Gzip-stream' request, though\nthe requested LEVEL may be '0'.\n\n'Referrer CVSROOT'\nRequest that the client store CVSROOT as the name of this server\nand that this name be passed via a 'Referrer' request to any\nsubsequent servers contacted as a result of a 'Redirect' response.\nThis can be useful to allow the secondary administrator to\nconfigure the 'CVSROOT' the primary should use to update the\nsecondary in case the client uses a non-standard name or even a\nname that is unique to the client for some reason.\n\n'Redirect CVSROOT'\nRequest that the client redirect its connection to CVSROOT and\nbegin again.  This response is only valid in response to a\n'Command-prep' request.  If a client receives this response, it is\nexpected to notify the write server it subsequently contacts of the\nCVSROOT of the server which redirected it using the 'Referrer'\nrequest.  This information makes it possible for primary servers to\nupdate the client's mirror first, hopefully minimizing race\nconditions on subsequent updates from the same client.\n\n'Checked-in PATHNAME \\n'\nAdditional data: New Entries line, \\n.  This means a file PATHNAME\nhas been successfully operated on (checked in, added, etc.).  name\nin the Entries line is the same as the last component of PATHNAME.\n\n'New-entry PATHNAME \\n'\nAdditional data: New Entries line, \\n.  Like 'Checked-in', but the\nfile is not up to date.\n\n'Updated PATHNAME \\n'\nAdditional data: New Entries line, \\n, mode, \\n, file transmission.\nA new copy of the file is enclosed.  This is used for a new\nrevision of an existing file, or for a new file, or for any other\ncase in which the local (client-side) copy of the file needs to be\nupdated, and after being updated it will be up to date.  If any\ndirectory in pathname does not exist, create it.  This response is\nnot used if 'Created' and 'Update-existing' are supported.\n\n'Created PATHNAME \\n'\nThis is just like 'Updated' and takes the same additional data, but\nis used only if no 'Entry', 'Modified', or 'Unchanged' request has\nbeen sent for the file in question.  The distinction between\n'Created' and 'Update-existing' is so that the client can give an\nerror message in several cases: (1) there is a file in the working\ndirectory, but not one for which 'Entry', 'Modified', or\n'Unchanged' was sent (for example, a file which was ignored, or a\nfile for which 'Questionable' was sent), (2) there is a file in the\nworking directory whose name differs from the one mentioned in\n'Created' in ways that the client is unable to use to distinguish\nfiles.  For example, the client is case-insensitive and the names\ndiffer only in case.\n\n'Update-existing PATHNAME \\n'\nThis is just like 'Updated' and takes the same additional data, but\nis used only if a 'Entry', 'Modified', or 'Unchanged' request has\nbeen sent for the file in question.\n\nThis response, or 'Merged', indicates that the server has\ndetermined that it is OK to overwrite the previous contents of the\nfile specified by PATHNAME.  Provided that the client has correctly\nsent 'Modified' or 'Is-modified' requests for a modified file, and\nthe file was not modified while CVS was running, the server can\nensure that a user's modifications are not lost.\n\n'Merged PATHNAME \\n'\nThis is just like 'Updated' and takes the same additional data,\nwith the one difference that after the new copy of the file is\nenclosed, it will still not be up to date.  Used for the results of\na merge, with or without conflicts.\n\nIt is useful to preserve an copy of what the file looked like\nbefore the merge.  This is basically handled by the server; before\nsending 'Merged' it will send a 'Copy-file' response.  For example,\nif the file is 'aa' and it derives from revision 1.3, the\n'Copy-file' response will tell the client to copy 'aa' to\n'.#aa.1.3'.  It is up to the client to decide how long to keep this\nfile around; traditionally clients have left it around forever,\nthus letting the user clean it up as desired.  But another answer,\nsuch as until the next commit, might be preferable.\n\n'Rcs-diff PATHNAME \\n'\nThis is just like 'Updated' and takes the same additional data,\nwith the one difference that instead of sending a new copy of the\nfile, the server sends an RCS change text.  This change text is\nproduced by 'diff -n' (the GNU diff '-a' option may also be used).\nThe client must apply this change text to the existing file.  This\nwill only be used when the client has an exact copy of an earlier\nrevision of a file.  This response is only used if the 'update'\ncommand is given the '-u' argument.\n\n'Patched PATHNAME \\n'\nThis is just like 'Rcs-diff' and takes the same additional data,\nexcept that it sends a standard patch rather than an RCS change\ntext.  The patch is produced by 'diff -c' for CVS 1.6 and later\n(see POSIX.2 for a description of this format), or 'diff -u' for\nprevious versions of CVS; clients are encouraged to accept either\nformat.  Like 'Rcs-diff', this response is only used if the\n'update' command is given the '-u' argument.\n\nThe 'Patched' response is deprecated in favor of the 'Rcs-diff'\nresponse.  However, older clients (CVS 1.9 and earlier) only\nsupport 'Patched'.\n\n'Edit-file PATHNAME \\n'\nDo the client-side portion of editing a file.\n\n'Mode MODE \\n'\nThis MODE applies to the next file mentioned in 'Checked-in'.\n'Mode' is a file update modifying response as described in *note\nResponse intro::.\n\n'Mod-time TIME \\n'\nSet the modification time of the next file sent to TIME.\n'Mod-time' is a file update modifying response as described in\n*note Response intro::.  The TIME is in the format specified by\nRFC822 as modified by RFC1123.  The server may specify any timezone\nit chooses; clients will want to convert that to their own timezone\nas appropriate.  An example of this format is:\n\n26 May 1997 13:01:40 -0400\n\nThere is no requirement that the client and server clocks be\nsynchronised.  The server just sends its recommendation for a\ntimestamp (based on its own clock, presumably), and the client\nshould just believe it (this means that the time might be in the\nfuture, for example).\n\nIf the server does not send 'Mod-time' for a given file, the client\nshould pick a modification time in the usual way (usually, just let\nthe operating system set the modification time to the time that the\nCVS command is running).\n\n'Checksum CHECKSUM\\n'\nThe CHECKSUM applies to the next file sent (that is, 'Checksum' is\na file update modifying response as described in *note Response\nintro::).  In the case of 'Patched', the checksum applies to the\nfile after being patched, not to the patch itself.  The client\nshould compute the checksum itself, after receiving the file or\npatch, and signal an error if the checksums do not match.  The\nchecksum is the 128 bit MD5 checksum represented as 32 hex digits\n(MD5 is described in RFC1321).  This response is optional, and is\nonly used if the client supports it (as judged by the\n'Valid-responses' request).\n\n'Copy-file PATHNAME \\n'\nAdditional data: NEWNAME \\n.  Copy file PATHNAME to NEWNAME in the\nsame directory where it already is.  This does not affect\n'CVS/Entries'.\n\nThis can optionally be implemented as a rename instead of a copy.\nThe only use for it which currently has been identified is prior to\na 'Merged' response as described under 'Merged'.  Clients can\nprobably assume that is how it is being used, if they want to worry\nabout things like how long to keep the NEWNAME file around.\n\n'Removed PATHNAME \\n'\nThe file has been removed from the repository (this is the case\nwhere cvs prints 'file foobar.c is no longer pertinent').\n\n'Remove-entry PATHNAME \\n'\nThe file needs its entry removed from 'CVS/Entries', but the file\nitself is already gone (this happens in response to a 'ci' request\nwhich involves committing the removal of a file).\n\n'Set-static-directory PATHNAME \\n'\nThis instructs the client to set the 'Entries.Static' flag, which\nit should then send back to the server in a 'Static-directory'\nrequest whenever the directory is operated on.  PATHNAME ends in a\nslash; its purpose is to specify a directory, not a file within a\ndirectory.\n\n'Clear-static-directory PATHNAME \\n'\nLike 'Set-static-directory', but clear, not set, the flag.\n\n'Set-sticky PATHNAME \\n'\nAdditional data: TAGSPEC \\n.  Tell the client to set a sticky tag\nor date, which should be supplied with the 'Sticky' request for\nfuture operations.  PATHNAME ends in a slash; its purpose is to\nspecify a directory, not a file within a directory.  The client\nshould store TAGSPEC and pass it back to the server as-is, to allow\nfor future expansion.  The first character of TAGSPEC is 'T' for a\ntag, 'D' for a date, or something else for future expansion.  The\nremainder of TAGSPEC contains the actual tag or date.\n\n'Clear-sticky PATHNAME \\n'\nClear any sticky tag or date set by 'Set-sticky'.\n\n'Template PATHNAME \\n'\nAdditional data: file transmission (note: compressed file\ntransmissions are not supported).  PATHNAME ends in a slash; its\npurpose is to specify a directory, not a file within a directory.\nTell the client to store the file transmission as the template log\nmessage, and then use that template in the future when prompting\nthe user for a log message.\n\n'Set-checkin-prog DIR \\n'\nAdditional data: PROG \\n.  Tell the client to set a checkin\nprogram, which should be supplied with the 'Checkin-prog' request\nfor future operations.\n\n'Set-update-prog DIR \\n'\nAdditional data: PROG \\n.  Tell the client to set an update\nprogram, which should be supplied with the 'Update-prog' request\nfor future operations.\n\n'Notified PATHNAME \\n'\nIndicate to the client that the notification for PATHNAME has been\ndone.  There should be one such response for every 'Notify'\nrequest; if there are several 'Notify' requests for a single file,\nthe requests should be processed in order; the first 'Notified'\nresponse pertains to the first 'Notify' request, etc.\n\n'Module-expansion PATHNAME \\n'\nReturn a file or directory which is included in a particular\nmodule.  PATHNAME is relative to cvsroot, unlike most pathnames in\nresponses.  PATHNAME should be used to look and see whether some or\nall of the module exists on the client side; it is not necessarily\nsuitable for passing as an argument to a 'co' request (for example,\nif the modules file contains the '-d' option, it will be the\ndirectory specified with '-d', not the name of the module).\n\n'Wrapper-rcsOption PATTERN -k 'OPTION' \\n'\nTransmit to the client a filename pattern which implies a certain\nkeyword expansion mode.  The PATTERN is a wildcard pattern (for\nexample, '*.exe'.  The OPTION is 'b' for binary, and so on.  Note\nthat although the syntax happens to resemble the syntax in certain\nCVS configuration files, it is more constrained; there must be\nexactly one space between PATTERN and '-k' and exactly one space\nbetween '-k' and ''', and no string is permitted in place of '-k'\n(extensions should be done with new responses, not by extending\nthis one, for graceful handling of 'Valid-responses').\n\n'M TEXT \\n'\nA one-line message for the user.  Note that the format of TEXT is\nnot designed for machine parsing.  Although sometimes scripts and\nclients will have little choice, the exact text which is output is\nsubject to vary at the discretion of the server and the example\noutput given in this document is just that, example output.\nServers are encouraged to use the 'MT' response, and future\nversions of this document will hopefully standardise more of the\n'MT' tags; see *note Text tags::.\n\n'LOGM TEXT \\n'\nExactly the same as 'M' but only sent if the client indicates\nsupporting it via 'Valid-responses', used exclusively for log\nmessage payload (that is, in 'cvs log' and 'cvs rlog', the text\nbody the user originally has entered with the '-m' option to the\n'ci' request).\n\n'Mbinary \\n'\nAdditional data: file transmission (note: compressed file\ntransmissions are not supported).  This is like 'M', except the\ncontents of the file transmission are binary and should be copied\nto standard output without translation to local text file\nconventions.  To transmit a text file to standard output, servers\nshould use a series of 'M' requests.\n\n'E TEXT \\n'\nSame as 'M' but send to stderr not stdout.\n\n'F \\n'\nFlush stderr.  That is, make it possible for the user to see what\nhas been written to stderr (it is up to the implementation to\ndecide exactly how far it should go to ensure this).\n\n'MT TAGNAME DATA \\n'\n\nThis response provides for tagged text.  It is similar to\nSGML/HTML/XML in that the data is structured and a naive\napplication can also make some sense of it without understanding\nthe structure.  The syntax is not SGML-like, however, in order to\nfit into the CVS protocol better and (more importantly) to make it\neasier to parse, especially in a language like perl or awk.\n\nThe TAGNAME can have several forms.  If it starts with 'a' to 'z'\nor 'A' to 'Z', then it represents tagged text.  If the\nimplementation recognises TAGNAME, then it may interpret DATA in\nsome particular fashion.  If the implementation does not recognise\nTAGNAME, then it should simply treat DATA as text to be sent to the\nuser (similar to an 'M' response).  There are two tags which are\ngeneral purpose.  The 'text' tag is similar to an unrecognised tag\nin that it provides text which will ordinarily be sent to the user.\nThe 'newline' tag is used without DATA and indicates that a newline\nwill ordinarily be sent to the user (there is no provision for\nembedding newlines in the DATA of other tagged text responses).\n\nIf TAGNAME starts with '+' it indicates a start tag and if it\nstarts with '-' it indicates an end tag.  The remainder of TAGNAME\nshould be the same for matching start and end tags, and tags should\nbe nested (for example one could have tags in the following order\n'+bold' '+italic' 'text' '-italic' '-bold' but not '+bold'\n'+italic' 'text' '-bold' '-italic').  A particular start and end\ntag may be documented to constrain the tagged text responses which\nare valid between them.\n\nNote that if DATA is present there will always be exactly one space\nbetween TAGNAME and DATA; if there is more than one space, then the\nspaces beyond the first are part of DATA.\n\nHere is an example of some tagged text responses.  Note that there\nis a trailing space after 'Checking in' and 'initial revision:' and\nthere are two trailing spaces after '<--'.  Such trailing spaces\nare, of course, part of DATA.\n\nMT +checking-in\nMT text Checking in\nMT fname gz.tst\nMT text ;\nMT newline\nMT rcsfile /home/kingdon/zwork/cvsroot/foo/gz.tst,v\nMT text   <--\nMT fname gz.tst\nMT newline\nMT text initial revision:\nMT init-rev 1.1\nMT newline\nMT text done\nMT newline\nMT -checking-in\n\nIf the client does not support the 'MT' response, the same\nresponses might be sent as:\n\nM Checking in gz.tst;\nM /home/kingdon/zwork/cvsroot/foo/gz.tst,v  <--  gz.tst\nM initial revision: 1.1\nM done\n\nFor a list of specific tags, see *note Text tags::.\n\n'error ERRNO-CODE ' ' TEXT \\n'\nThe command completed with an error.  ERRNO-CODE is a symbolic\nerror code (e.g.  'ENOENT'); if the server doesn't support this\nfeature, or if it's not appropriate for this particular message, it\njust omits the errno-code (in that case there are two spaces after\n'error').  Text is an error message such as that provided by\nstrerror(), or any other message the server wants to use.  The TEXT\nis like the 'M' response, in the sense that it is not particularly\nintended to be machine-parsed; servers may wish to print an error\nmessage with 'MT' responses, and then issue a 'error' response\nwithout TEXT (although it should be noted that 'MT' currently has\nno way of flagging the output as intended for standard error, the\nway that the 'E' response does).\n\n'ok \\n'\nThe command completed successfully.\n"
                }
            ]
        },
        "File: cvsclient.info,  Node: Text tags,  Next: Example,  Prev: Responses,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.12 Tags for the MT tagged text response",
                    "content": "The 'MT' response, as described in *note Responses::, offers a way for\nthe server to send tagged text to the client.  This section describes\nspecific tags.  The intention is to update this section as servers add\nnew tags.\n\nIn the following descriptions, 'text' and 'newline' tags are omitted."
                }
            ]
        },
        "Such tags contain information which is intended for users (or to be": {
            "content": "discarded), and are subject to change at the whim of the server.  To\navoid being vulnerable to such whim, clients should look for the tags\nlisted here, not 'text', 'newline', or other tags.\n\nThe following tag means to indicate to the user that a file has been\nupdated.  It is more or less redundant with the 'Created' and\n'Update-existing' responses, but we don't try to specify here whether it\noccurs in exactly the same circumstances as 'Created' and\n'Update-existing'.  The NAME is the pathname of the file being updated\nrelative to the directory in which the command is occurring (that is,\nthe last 'Directory' request which is sent before the command).\n\nMT +updated\nMT fname NAME\nMT -updated\n\nThe 'importmergecmd' tag is used when doing an import which has\nconflicts, or when doing an import with the '-X' flag.  The client can\nuse it to report how to merge in the newly imported changes.  The COUNT\nis the number of conflicts, or the string 'No' if no conflicts occurred.\n(The latter will only be sent for imports run with the '-X' flag.)  The\nnewly imported changes can be merged by running the following command:\ncvs checkout -j TAG1 -j TAG2 REPOSITORY\n\nMT +importmergecmd\nMT conflicts COUNT\nMT mergetag1 TAG1\nMT mergetag2 TAG2\nMT repository REPOSITORY\nMT -importmergecmd\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Example,  Next: Requirements,  Prev: Text tags,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.13 Example",
                    "content": ""
                }
            ]
        },
        "Here is an example; lines are prefixed by 'C: ' to indicate the client": {
            "content": "sends them or 'S: ' to indicate the server sends them.\n\nThe client starts by connecting, sending the root, and completing the\nprotocol negotiation.  In actual practice the lists of valid responses\nand requests would be longer.\n\nC: Root /u/cvsroot\nC: Valid-responses ok error Checked-in M E\nC: valid-requests\nS: Valid-requests Root Directory Entry Modified Argument Argumentx ci co\nS: ok\nC: UseUnchanged\n\nThe client wants to check out the 'supermunger' module into a fresh\nworking directory.  Therefore it first expands the 'supermunger' module;\nthis step would be omitted if the client was operating on a directory\nrather than a module.\n\nC: Argument supermunger\nC: Directory .\nC: .\nC: expand-modules\n\nThe server replies that the 'supermunger' module expands to the\ndirectory 'supermunger' (the simplest case):\n\nS: Module-expansion supermunger\nS: ok\n\nThe client then proceeds to check out the directory.  The fact that\nit sends only a single 'Directory' request which specifies '.' for the\nworking directory means that there is not already a 'supermunger'\ndirectory on the client.\n\nC: Argument -N\nC: Argument supermunger\nC: Directory .\nC: .\nC: co\n\nThe server replies with the requested files.  In this example, there\nis only one file, 'mungeall.c'.  The 'Clear-sticky' and\n'Clear-static-directory' requests are sent by the current implementation\nbut they have no effect because the default is for those settings to be\nclear when a directory is newly created.\n\nS: Clear-sticky supermunger/\nS: /u/cvsroot/supermunger/\nS: Clear-static-directory supermunger/\nS: /u/cvsroot/supermunger/\nS: E cvs server: Updating supermunger\nS: M U supermunger/mungeall.c\nS: Created supermunger/\nS: /u/cvsroot/supermunger/mungeall.c\nS: /mungeall.c/1.1///\nS: u=rw,g=r,o=r\nS: 26\nS: int mein () { abort (); }\nS: ok\n\nThe current client implementation would break the connection here and\nmake a new connection for the next command.  However, the protocol\nallows it to keep the connection open and continue, which is what we\nshow here.\n\nAfter the user modifies the file and instructs the client to check it\nback in.  The client sends arguments to specify the log message and file\nto check in:\n\nC: Argument -m\nC: Argument Well, you see, it took me hours and hours to find\nC: Argumentx this typo and I searched and searched and eventually\nC: Argumentx had to ask John for help.\nC: Argument mungeall.c\n\nIt also sends information about the contents of the working\ndirectory, including the new contents of the modified file.  Note that\nthe user has changed into the 'supermunger' directory before executing\nthis command; the top level directory is a user-visible concept because\nthe server should print filenames in 'M' and 'E' responses relative to\nthat directory.\n\nC: Directory .\nC: supermunger\nC: Entry /mungeall.c/1.1///\nC: Modified mungeall.c\nC: u=rw,g=r,o=r\nC: 26\nC: int main () { abort (); }\n\nAnd finally, the client issues the checkin command (which makes use\nof the data just sent):\n\nC: ci\n\nAnd the server tells the client that the checkin succeeded:\n\nS: M Checking in mungeall.c;\nS: E /u/cvsroot/supermunger/mungeall.c,v  <--  mungeall.c\nS: E new revision: 1.2; previous revision: 1.1\nS: E done\nS: Mode u=rw,g=r,o=r\nS: Checked-in ./\nS: /u/cvsroot/supermunger/mungeall.c\nS: /mungeall.c/1.2///\nS: ok\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Requirements,  Next: Obsolete,  Prev: Example,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.14 Required versus optional parts of the protocol",
                    "content": ""
                }
            ]
        },
        "The following are part of every known implementation of the CVS protocol": {
            "content": "(except obsolete, pre-1.5, versions of CVS) and it is considered\nreasonable behavior to completely fail to work if you are connected with\nan implementation which attempts to not support them.  Requests: 'Root',\n'Valid-responses', 'valid-requests', 'Directory', 'Entry', 'Modified',\n'Unchanged', 'Argument', 'Argumentx', 'ci', 'co', 'update'.  Responses:\n'ok', 'error', 'Valid-requests', 'Checked-in', 'Updated', 'Merged',\n'Removed', 'M', 'E'.\n\nA server need not implement 'Repository', but in order to\ninteroperate with CVS 1.5 through 1.9 it must claim to implement it (in\n'Valid-requests').  The client will not actually send the request.\n",
            "subsections": []
        },
        "File: cvsclient.info,  Node: Obsolete,  Prev: Requirements,  Up: Protocol": {
            "content": "",
            "subsections": [
                {
                    "name": "5.15 Obsolete protocol elements",
                    "content": "This section briefly describes protocol elements which are obsolete.\nThere is no attempt to document them in full detail.\n\nThere was a 'Repository' request which was like 'Directory' except it\nonly provided REPOSITORY, and the local directory was assumed to be\nsimilarly named.\n\nIf the 'UseUnchanged' request was not sent, there was a 'Lost'\nrequest which was sent to indicate that a file did not exist in the\nworking directory, and the meaning of sending 'Entries' without 'Lost'\nor 'Modified' was different.  All current clients (CVS 1.5 and later)\nwill send 'UseUnchanged' if it is supported.\n"
                }
            ]
        },
        "File: cvsclient.info,  Node: Protocol Notes,  Prev: Protocol,  Up: Top": {
            "content": "",
            "subsections": []
        },
        "6 Notes on the Protocol": {
            "content": "A number of enhancements are possible.  Also see the file TODO in the\nCVS source distribution, which has further ideas concerning various\naspects of CVS, some of which impact the protocol.  Similarly, the\n<http://www.nongnu.org/cvs/> site, in particular the 'Development'\npages.\n\n* The 'Modified' request could be speeded up by sending diffs rather\nthan entire files.  The client would need some way to keep the\nversion of the file which was originally checked out; probably\nrequiring the use of \"cvs edit\" in this case is the most sensible\ncourse (the \"cvs edit\" could be handled by a package like VC for\nemacs).  This would also allow local operation of 'cvs diff'\nwithout arguments.\n\n* The fact that 'pserver' requires an extra network turnaround in\norder to perform authentication would be nice to avoid.  This\nrelates to the issue of reporting errors; probably the clean\nsolution is to defer the error until the client has issued a\nrequest which expects a response.  To some extent this might relate\nto the next item (in terms of how easy it is to skip a whole bunch\nof requests until we get to one that expects a response).  I know\nthat the kerberos code doesn't wait in this fashion, but that\nprobably can cause network deadlocks and perhaps future problems\nrunning over a transport which is more transaction oriented than\nTCP. On the other hand I'm not sure it is wise to make the client\nconduct a lengthy upload only to find there is an authentication\nfailure.\n\n* The protocol uses an extra network turnaround for protocol\nnegotiation ('valid-requests').  It might be nice to avoid this by\nhaving the client be able to send requests and tell the server to\nignore them if they are unrecognised (different requests could\nproduce a fatal error if unrecognised).  To do this there should be\na standard syntax for requests.  For example, perhaps all future\nrequests should be a single line, with mechanisms analogous to\n'Argumentx', or several requests working together, to provide\ngreater amounts of information.  Or there might be a standard\nmechanism for counted data (analogous to that used by 'Modified')\nor continuation lines (like a generalised 'Argumentx').  It would\nbe useful to compare what HTTP is planning in this area; last I\nlooked they were contemplating something called Protocol Extension\nProtocol but I haven't looked at the relevant IETF documents in any\ndetail.  Obviously, we want something as simple as possible (but no\nsimpler).\n\n* The scrambling algorithm in the CVS client and server actually\nsupport more characters than those documented in *note Password\nscrambling::.  Someday we are going to either have to document them\nall (but this is not as easy as it may look, see below), or\n(gradually and with adequate process) phase out the support for\nother characters in the CVS implementation.  This business of\nhaving the feature partly undocumented isn't a desirable state\nlong-term.\n\nThe problem with documenting other characters is that unless we\nknow what character set is in use, there is no way to make a\npassword portable from one system to another.  For example, a with\na circle on top might have different encodings in different\ncharacter sets.\n\nIt almost works to say that the client picks an arbitrary,\nunknown character set (indeed, having the CVS client know what\ncharacter set the user has in mind is a hard problem otherwise),\nand scrambles according to a certain octet<->octet mapping.  There\nare two problems with this.  One is that the protocol has no way to\ntransmit character 10 decimal (linefeed), and the current server\nand clients have no way to handle 0 decimal (NUL). This may cause\nproblems with certain multibyte character sets, in which octets 10\nand 0 will appear in the middle of other characters.  The other\nproblem, which is more minor and possibly not worth worrying about,\nis that someone can type a password on one system and then go to\nanother system which uses a different encoding for the same\ncharacters, and have their password not work.\n\nThe restriction to the ISO646 invariant subset is the best approach\nfor strings which are not particularly significant to users.\nPasswords are visible enough that this is somewhat doubtful as\napplied here.  ISO646 does, however, have the virtue (!?)  of\noffending everyone.  It is easy to say \"But the $ is right on\npeople's keyboards!  Surely we can't forbid that\".  From a human\nfactors point of view, that makes quite a bit of sense.  The\ncontrary argument, of course, is that a with a circle on top, or\nsome of the characters poorly handled by Unicode, are on\nsomeone's keyboard.\n\n",
            "subsections": []
        }
    },
    "flags": [],
    "examples": [],
    "see_also": []
}