DROPBOX EX. 1005
`
`DROPBOX EX. 1005
`
`
`
`

`
`Version Management
`
`with
`
`CVS
`
`for cvs (cid:3) (cid:3)
`
`Per Cederqvist et al
`
`Dropbox Ex. 1005
`
`

`
`Copyright c(cid:0) (cid:8) Signum Support AB
`Permission is granted to make and distribute verbatim copies of this manual provided the
`copyright notice and this permission notice are preserved on all copies(cid:3)
`Permission is granted to copy and distribute modi(cid:9)ed versions of this manual under the
`conditions for verbatim copying(cid:8) provided also that the entire resulting derived work is
`distributed under the terms of a permission notice identical to this one(cid:3)
`Permission is granted to copy and distribute translations of this manual into another lan(cid:10)
`guage(cid:8) under the above conditions for modi(cid:9)ed versions(cid:8) except that this permission notice
`may be stated in a translation approved by the Free Software Foundation(cid:3)
`
`Dropbox Ex. 1005
`
`

`
`Chapter (cid:11) Overview
`
`
`
` Overview
`
`This chapter is for people who have never used cvs(cid:8) and perhaps have never used version
`control software before(cid:3)
`
`If you are already familiar with cvs and are just trying to learn a particular feature or
`remember a certain command(cid:8) you can probably skip everything here(cid:3)
`
` (cid:2) What is CVS(cid:3)
`
`cvs is a version control system(cid:3) Using it(cid:8) you can record the history of your source (cid:9)les(cid:3)
`
`For example(cid:8) bugs sometimes creep in when software is modi(cid:9)ed(cid:8) and you might not
`detect the bug until a long time after you make the modi(cid:9)cation(cid:3) With cvs(cid:8) you can easily
`retrieve old versions to see exactly which change caused the bug(cid:3) This can sometimes be a
`big help(cid:3)
`
`You could of course save every version of every (cid:9)le you have ever created(cid:3) This would
`however waste an enormous amount of disk space(cid:3) cvs stores all the versions of a (cid:9)le in a
`single (cid:9)le in a clever way that only stores the di(cid:12)erences between versions(cid:3)
`
`cvs also helps you if you are part of a group of people working on the same project(cid:3)
`It is all too easy to overwrite each others(cid:13) changes unless you are extremely careful(cid:3) Some
`editors(cid:8) like gnu Emacs(cid:8) try to make sure that the same (cid:9)le is never modi(cid:9)ed by two people
`at the same time(cid:3) Unfortunately(cid:8) if someone is using another editor(cid:8) that safeguard will
`not work(cid:3) cvs solves this problem by insulating the di(cid:12)erent developers from each other(cid:3)
`Every developer works in his own directory(cid:8) and cvs merges the work when each developer
`is done(cid:3)
`
`cvs started out as a bunch of shell scripts written by Dick Grune(cid:8) posted to the news(cid:10)
`group comp(cid:2)sources(cid:2)unix in the volume  release of December(cid:8) (cid:3) While no actual code
`from these shell scripts is present in the current version of cvs much of the cvs con(cid:16)ict
`resolution algorithms come from them(cid:3)
`
`In April(cid:8)  (cid:8) Brian Berliner designed and coded cvs(cid:3) Je(cid:12) Polk later helped Brian with
`the design of the cvs module and vendor branch support(cid:3)
`
`You can get cvs in a variety of ways(cid:8) including free download from the internet(cid:3) For
`more information on downloading cvs and other cvs topics(cid:8) see(cid:11)
`
`http(cid:3)(cid:4)(cid:4)www(cid:2)cyclic(cid:2)com(cid:4)
`http(cid:3)(cid:4)(cid:4)www(cid:2)loria(cid:2)fr(cid:4)(cid:5)molli(cid:4)cvs(cid:6)index(cid:2)html
`
`There is a mailing list(cid:8) known as info(cid:6)cvs(cid:8) devoted to cvs(cid:3) To subscribe or un(cid:10)
`subscribe write to info(cid:6)cvs(cid:6)request(cid:7)gnu(cid:2)org(cid:3)
`If you prefer a usenet group(cid:8) the right
`group is comp(cid:2)software(cid:2)config(cid:6)mgmt which is for cvs discussions (cid:17)along with other
`con(cid:9)guration management systems(cid:18)(cid:3)
`In the future(cid:8)
`it might be possible to create a
`comp(cid:2)software(cid:2)config(cid:6)mgmt(cid:2)cvs(cid:8) but probably only if there is su(cid:19)cient cvs tra(cid:19)c
`on comp(cid:2)software(cid:2)config(cid:6)mgmt(cid:3)
`
`You can also subscribe to the bug(cid:10)cvs mailing list(cid:8) described in more detail in Appendix H
`(cid:20)BUGS(cid:21)(cid:8) page  (cid:3) To subscribe send mail to bug(cid:10)cvs(cid:10)request(cid:7)gnu(cid:3)org(cid:3)
`
`Dropbox Ex. 1005
`
`

`
`
`
`CVS(cid:23)Concurrent Versions System
`
` (cid:2) What is CVS not(cid:3)
`
`cvs can do a lot of things for you(cid:8) but it does not try to be everything for everyone(cid:3)
`
`cvs is not a build system(cid:3)
`Though the structure of your repository and modules (cid:9)le interact with your
`build system (cid:17)e(cid:3)g(cid:3) (cid:24)Makefile(cid:13)s(cid:18)(cid:8) they are essentially independent(cid:3)
`
`cvs does not dictate how you build anything(cid:3) It merely stores (cid:9)les for retrieval
`in a tree structure you devise(cid:3)
`
`cvs does not dictate how to use disk space in the checked out working directo(cid:10)
`ries(cid:3) If you write your (cid:24)Makefile(cid:13)s or scripts in every directory so they have to
`know the relative positions of everything else(cid:8) you wind up requiring the entire
`repository to be checked out(cid:3)
`
`If you modularize your work(cid:8) and construct a build system that will share (cid:9)les
`(cid:17)via links(cid:8) mounts(cid:8) VPATH in (cid:24)Makefile(cid:13)s(cid:8) etc(cid:3)(cid:18)(cid:8) you can arrange your disk usage
`however you like(cid:3)
`
`But you have to remember that any such system is a lot of work to construct
`and maintain(cid:3) cvs does not address the issues involved(cid:3)
`
`Of course(cid:8) you should place the tools created to support such a build system
`(cid:17)scripts(cid:8) (cid:24)Makefile(cid:13)s(cid:8) etc(cid:18) under cvs(cid:3)
`
`Figuring out what (cid:9)les need to be rebuilt when something changes is(cid:8) again(cid:8)
`something to be handled outside the scope of cvs(cid:3) One traditional approach
`is to use make for building(cid:8) and use some automated tool for generating the
`dependencies which make uses(cid:3)
`
`See Chapter  (cid:20)Builds(cid:21)(cid:8) page (cid:8) for more information on doing builds in
`conjunction with cvs(cid:3)
`
`cvs is not a substitute for management(cid:3)
`Your managers and project leaders are expected to talk to you frequently enough
`to make certain you are aware of schedules(cid:8) merge points(cid:8) branch names and
`release dates(cid:3) If they don(cid:13)t(cid:8) cvs can(cid:13)t help(cid:3)
`
`cvs is an instrument for making sources dance to your tune(cid:3) But you are the
`piper and the composer(cid:3) No instrument plays itself or writes its own music(cid:3)
`
`cvs is not a substitute for developer communication(cid:3)
`When faced with con(cid:16)icts within a single (cid:9)le(cid:8) most developers manage to re(cid:10)
`solve them without too much e(cid:12)ort(cid:3) But a more general de(cid:9)nition of (cid:27)con(cid:16)ict(cid:28)
`includes problems too di(cid:19)cult to solve without communication between devel(cid:10)
`opers(cid:3)
`
`cvs cannot determine when simultaneous changes within a single (cid:9)le(cid:8) or across
`a whole collection of (cid:9)les(cid:8) will logically con(cid:16)ict with one another(cid:3) Its concept
`of a con(cid:2)ict is purely textual(cid:8) arising when two changes to the same base (cid:9)le
`are near enough to spook the merge (cid:17)i(cid:3)e(cid:3) diff (cid:18) command(cid:3)
`
`cvs does not claim to help at all in (cid:9)guring out non(cid:10)textual or distributed
`con(cid:16)icts in program logic(cid:3)
`
`Dropbox Ex. 1005
`
`

`
`Chapter (cid:11) Overview
`
`
`
`For example(cid:11) Say you change the arguments to function X de(cid:9)ned in (cid:9)le (cid:24)A(cid:13)(cid:3) At
`the same time(cid:8) someone edits (cid:9)le (cid:24)B(cid:13)(cid:8) adding new calls to function X using the
`old arguments(cid:3) You are outside the realm of cvs(cid:13)s competence(cid:3)
`
`Acquire the habit of reading specs and talking to your peers(cid:3)
`
`cvs does not have change control
`Change control refers to a number of things(cid:3) First of all it can mean bug(cid:3)
`tracking(cid:8) that is being able to keep a database of reported bugs and the sta(cid:10)
`tus of each one (cid:17)is it (cid:9)xed(cid:29) in what release(cid:29) has the bug submitter agreed
`that it is (cid:9)xed(cid:29)(cid:18)(cid:3) For interfacing cvs to an external bug(cid:10)tracking system(cid:8) see
`the (cid:24)rcsinfo(cid:13) and (cid:24)verifymsg(cid:13) (cid:9)les (cid:17)see Appendix C (cid:20)Administrative (cid:9)les(cid:21)(cid:8)
`page (cid:18)(cid:3)
`
`Another aspect of change control is keeping track of the fact that changes to
`several (cid:9)les were in fact changed together as one logical change(cid:3) If you check in
`several (cid:9)les in a single cvs commit operation(cid:8) cvs then forgets that those (cid:9)les
`were checked in together(cid:8) and the fact that they have the same log message is
`the only thing tying them together(cid:3) Keeping a gnu style (cid:24)ChangeLog(cid:13) can help
`somewhat(cid:3)
`
`Another aspect of change control(cid:8) in some systems(cid:8) is the ability to keep track
`of the status of each change(cid:3) Some changes have been written by a developer(cid:8)
`others have been reviewed by a second developer(cid:8) and so on(cid:3) Generally(cid:8) the way
`to do this with cvs is to generate a di(cid:12) (cid:17)using cvs diff or diff(cid:18) and email it
`to someone who can then apply it using the patch utility(cid:3) This is very (cid:16)exible(cid:8)
`but depends on mechanisms outside cvs to make sure nothing falls through the
`cracks(cid:3)
`
`cvs is not an automated testing program
`It should be possible to enforce mandatory use of a testsuite using the
`commitinfo (cid:9)le(cid:3)
`I haven(cid:13)t heard a lot about projects trying to do that or
`whether there are subtle gotchas(cid:8) however(cid:3)
`
`cvs does not have a builtin process model
`Some systems provide ways to ensure that changes or releases go through various
`steps(cid:8) with various approvals as needed(cid:3) Generally(cid:8) one can accomplish this
`with cvs but it might be a little more work(cid:3)
`In some cases you(cid:13)ll want to
`use the (cid:24)commitinfo(cid:13)(cid:8) (cid:24)loginfo(cid:13)(cid:8) (cid:24)rcsinfo(cid:13)(cid:8) or (cid:24)verifymsg(cid:13) (cid:9)les(cid:8) to require
`that certain steps be performed before cvs will allow a checkin(cid:3) Also consider
`whether features such as branches and tags can be used to perform tasks such
`as doing work in a development tree and then merging certain changes over to
`a stable tree only once they have been proven(cid:3)
`
` (cid:2) A sample session
`
`As a way of introducing cvs(cid:8) we(cid:13)ll go through a typical work(cid:10)session using cvs(cid:3) The (cid:9)rst
`thing to understand is that cvs stores all (cid:9)les in a centralized repository (cid:17)see Chapter 
`(cid:20)Repository(cid:21)(cid:8) page (cid:18)(cid:30) this section assumes that a repository is set up(cid:3)
`
`Dropbox Ex. 1005
`
`

`
`
`
`CVS(cid:23)Concurrent Versions System
`
`Suppose you are working on a simple compiler(cid:3) The source consists of a handful of C
`(cid:9)les and a (cid:24)Makefile(cid:13)(cid:3) The compiler is called (cid:24)tc(cid:13) (cid:17)Trivial Compiler(cid:18)(cid:8) and the repository is
`set up so that there is a module called (cid:24)tc(cid:13)(cid:3)
`
` (cid:2) (cid:2) Getting the source
`
`The (cid:9)rst thing you must do is to get your own working copy of the source for (cid:24)tc(cid:13)(cid:3) For
`this(cid:8) you use the checkout command(cid:11)
`
`(cid:9) cvs checkout tc
`
`This will create a new directory called (cid:24)tc(cid:13) and populate it with the source (cid:9)les(cid:3)
`
`(cid:9) cd tc
`(cid:9) ls
`CVS
`
`Makefile
`
`backend(cid:2)c
`
`driver(cid:2)c
`
`frontend(cid:2)c parser(cid:2)c
`
`The (cid:24)CVS(cid:13) directory is used internally by cvs(cid:3) Normally(cid:8) you should not modify or remove
`any of the (cid:9)les in it(cid:3)
`
`You start your favorite editor(cid:8) hack away at (cid:24)backend(cid:2)c(cid:13)(cid:8) and a couple of hours later
`you have added an optimization pass to the compiler(cid:3) A note to rcs and sccs users(cid:11) There
`is no need to lock the (cid:9)les that you want to edit(cid:3) See Chapter (cid:20)Multiple developers(cid:21)(cid:8)
`page (cid:8) for an explanation(cid:3)
`
` (cid:2) (cid:2) Committing your changes
`
`When you have checked that the compiler is still compilable you decide to make a new
`version of (cid:24)backend(cid:2)c(cid:13)(cid:3) This will store your new (cid:24)backend(cid:2)c(cid:13) in the repository and make it
`available to anyone else who is using that same repository(cid:3)
`
`(cid:9) cvs commit backend(cid:2)c
`
`cvs starts an editor(cid:8) to allow you to enter a log message(cid:3) You type in (cid:27)Added an optimiza(cid:10)
`tion pass(cid:3)(cid:28)(cid:8) save the temporary (cid:9)le(cid:8) and exit the editor(cid:3)
`
`The environment variable (cid:9)CVSEDITOR determines which editor is started(cid:3) If (cid:9)CVSEDITOR
`is not set(cid:8) then if the environment variable (cid:9)EDITOR is set(cid:8)
`it will be used(cid:3)
`If both
`(cid:9)CVSEDITOR and (cid:9)EDITOR are not set then there is a default which will vary with your
`operating system(cid:8) for example vi for unix or notepad for Windows NT(cid:31) (cid:3)
`
`In addition(cid:8) cvs checks the (cid:9)VISUAL environment variable(cid:3) Opinions vary on whether
`this behavior is desirable and whether future releases of cvs should check (cid:9)VISUAL or ignore
`it(cid:3) You will be OK either way if you make sure that (cid:9)VISUAL is either unset or set to the
`same thing as (cid:9)EDITOR(cid:3)
`
`When cvs starts the editor(cid:8) it includes a list of (cid:9)les which are modi(cid:9)ed(cid:3) For the cvs
`client(cid:8) this list is based on comparing the modi(cid:9)cation time of the (cid:9)le against the mod(cid:10)
`i(cid:9)cation time that the (cid:9)le had when it was last gotten or updated(cid:3) Therefore(cid:8) if a (cid:9)le(cid:13)s
`modi(cid:9)cation time has changed but its contents have not(cid:8) it will show up as modi(cid:9)ed(cid:3) The
`simplest way to handle this is simply not to worry about it(cid:23)if you proceed with the commit
`cvs will detect that the contents are not modi(cid:9)ed and treat it as an unmodi(cid:9)ed (cid:9)le(cid:3) The
`next update will clue cvs in to the fact that the (cid:9)le is unmodi(cid:9)ed(cid:8) and it will reset its
`stored timestamp so that the (cid:9)le will not show up in future editor sessions(cid:3)
`
`Dropbox Ex. 1005
`
`

`
`Chapter (cid:11) Overview
`
`
`
`If you want to avoid starting an editor you can specify the log message on the command
`line using the (cid:24)(cid:6)m(cid:13) (cid:16)ag instead(cid:8) like this(cid:11)
`
`(cid:9) cvs commit (cid:6)m (cid:10)Added an optimization pass(cid:10) backend(cid:2)c
`
` (cid:2) (cid:2) Cleaning up
`
`Before you turn to other tasks you decide to remove your working copy of tc(cid:3) One
`acceptable way to do that is of course
`
`(cid:9) cd (cid:2)(cid:2)
`(cid:9) rm (cid:6)r tc
`
`but a better way is to use the release command (cid:17)see Section A(cid:3)  (cid:20)release(cid:21)(cid:8) page (cid:18)(cid:11)
`
`(cid:9) cd (cid:2)(cid:2)
`(cid:9) cvs release (cid:6)d tc
`M driver(cid:2)c
`(cid:11) tc
`You have (cid:12) (cid:14) altered files in this repository(cid:2)
`Are you sure you want to release (cid:15)and delete(cid:16) module (cid:17)tc(cid:18)(cid:3) n
`(cid:19)(cid:19) (cid:17)release(cid:18) aborted by user choice(cid:2)
`
`If
`The release command checks that all your modi(cid:9)cations have been committed(cid:3)
`history logging is enabled it also makes a note in the history (cid:9)le(cid:3) See Section C(cid:3) (cid:20)history
`(cid:9)le(cid:21)(cid:8) page (cid:3)
`
`When you use the (cid:24)(cid:6)d(cid:13) (cid:16)ag with release(cid:8) it also removes your working copy(cid:3)
`
`In the example above(cid:8) the release command wrote a couple of lines of output(cid:3) (cid:24)(cid:11) tc(cid:13)
`means that the (cid:9)le (cid:24)tc(cid:13) is unknown to cvs(cid:3) That is nothing to worry about(cid:11) (cid:24)tc(cid:13) is the exe(cid:10)
`cutable compiler(cid:8) and it should not be stored in the repository(cid:3) See Section C(cid:3) (cid:20)cvsignore(cid:21)(cid:8)
`page (cid:8) for information about how to make that warning go away(cid:3) See Section A(cid:3) (cid:3)
`(cid:20)release output(cid:21)(cid:8) page (cid:8) for a complete explanation of all possible output from release(cid:3)
`
`(cid:24)M driver(cid:2)c(cid:13) is more serious(cid:3) It means that the (cid:9)le (cid:24)driver(cid:2)c(cid:13) has been modi(cid:9)ed since
`it was checked out(cid:3)
`
`The release command always (cid:9)nishes by telling you how many modi(cid:9)ed (cid:9)les you have
`in your working copy of the sources(cid:8) and then asks you for con(cid:9)rmation before deleting any
`(cid:9)les or making any note in the history (cid:9)le(cid:3)
`
`You decide to play it safe and answer n hRETi when release asks for con(cid:9)rmation(cid:3)
`
` (cid:2) (cid:2) Viewing di(cid:6)erences
`
`You do not remember modifying (cid:24)driver(cid:2)c(cid:13)(cid:8) so you want to see what has happened to
`that (cid:9)le(cid:3)
`
`(cid:9) cd tc
`(cid:9) cvs diff driver(cid:2)c
`
`This command runs diff to compare the version of (cid:24)driver(cid:2)c(cid:13) that you checked out with
`your working copy(cid:3) When you see the output you remember that you added a command
`line option that enabled the optimization pass(cid:3) You check it in(cid:8) and release the module(cid:3)
`
`Dropbox Ex. 1005
`
`

`
`
`
`CVS(cid:23)Concurrent Versions System
`
`(cid:9) cvs commit (cid:6)m (cid:10)Added an optimization pass(cid:10) driver(cid:2)c
`Checking in driver(cid:2)c(cid:20)
`(cid:4)usr(cid:4)local(cid:4)cvsroot(cid:4)tc(cid:4)driver(cid:2)c(cid:21)v (cid:22)(cid:6)(cid:6) driver(cid:2)c
`new revision(cid:3) (cid:2)(cid:20) previous revision(cid:3) (cid:2)
`done
`(cid:9) cd (cid:2)(cid:2)
`(cid:9) cvs release (cid:6)d tc
`(cid:11) tc
`You have (cid:12)(cid:14) altered files in this repository(cid:2)
`Are you sure you want to release (cid:15)and delete(cid:16) module (cid:17)tc(cid:18)(cid:3) y
`
`Dropbox Ex. 1005
`
`

`
`Chapter (cid:11) The Repository
`
`
`
` The Repository
`
`The cvs repository stores a complete copy of all the (cid:9)les and directories which are under
`version control(cid:3)
`Normally(cid:8) you never access any of the (cid:9)les in the repository directly(cid:3) Instead(cid:8) you use
`cvs commands to get your own copy of the (cid:9)les into a working directory(cid:8) and then work
`on that copy(cid:3) When you(cid:13)ve (cid:9)nished a set of changes(cid:8) you check (cid:17)or commit(cid:18) them back
`into the repository(cid:3) The repository then contains the changes which you have made(cid:8) as well
`as recording exactly what you changed(cid:8) when you changed it(cid:8) and other such information(cid:3)
`Note that the repository is not a subdirectory of the working directory(cid:8) or vice versa(cid:30) they
`should be in separate locations(cid:3)
`Cvs can access a repository by a variety of means(cid:3) It might be on the local computer(cid:8)
`or it might be on a computer across the room or across the world(cid:3) To distinguish various
`ways to access a repository(cid:8) the repository name can start with an access method(cid:3) For
`example(cid:8) the access method (cid:3)local(cid:3) means to access a repository directory(cid:8) so the reposi(cid:10)
`tory (cid:3)local(cid:3)(cid:4)usr(cid:4)local(cid:4)cvsroot means that the repository is in (cid:24)(cid:4)usr(cid:4)local(cid:4)cvsroot(cid:13)
`on the computer running cvs(cid:3) For information on other access methods(cid:8) see Section (cid:3)
`(cid:20)Remote repositories(cid:21)(cid:8) page (cid:3)
`If the access method is omitted(cid:8) then if the repository does not contain (cid:24)(cid:3)(cid:13)(cid:8) then (cid:3)local(cid:3)
`is assumed(cid:3) If it does contain (cid:24)(cid:3)(cid:13) then either (cid:3)ext(cid:3) or (cid:3)server(cid:3) is assumed(cid:3) For example(cid:8)
`if you have a local repository in (cid:24)(cid:4)usr(cid:4)local(cid:4)cvsroot(cid:13)(cid:8) you can use (cid:4)usr(cid:4)local(cid:4)cvsroot
`instead of (cid:3)local(cid:3)(cid:4)usr(cid:4)local(cid:4)cvsroot(cid:3) But if (cid:17)under Windows NT(cid:8) for example(cid:18) your
`local repository is (cid:24)c(cid:3)(cid:25)src(cid:25)cvsroot(cid:13)(cid:8) then you must specify the access method(cid:8) as in
`(cid:3)local(cid:3)c(cid:3)(cid:25)src(cid:25)cvsroot(cid:3)
`(cid:24)(cid:9)CVSROOT(cid:4)CVSROOT(cid:13) contains administrative (cid:9)les
`The repository is split in two parts(cid:3)
`for cvs(cid:3) The other directories contain the actual user(cid:10)de(cid:9)ned modules(cid:3)
`
`(cid:2) Telling CVS where your repository is
`
`There are several ways to tell cvs where to (cid:9)nd the repository(cid:3) You can name the
`repository on the command line explicitly(cid:8) with the (cid:6)d (cid:17)for (cid:10)directory(cid:10)(cid:18) option(cid:11)
`cvs (cid:6)d (cid:4)usr(cid:4)local(cid:4)cvsroot checkout yoyodyne(cid:4)tc
`Or you can set the (cid:9)CVSROOT environment variable to an absolute path to the root of the
`repository(cid:8) (cid:24)(cid:4)usr(cid:4)local(cid:4)cvsroot(cid:13) in this example(cid:3) To set (cid:9)CVSROOT(cid:8) csh and tcsh users
`should have this line in their (cid:24)(cid:2)cshrc(cid:13) or (cid:24)(cid:2)tcshrc(cid:13) (cid:9)les(cid:11)
`setenv CVSROOT (cid:4)usr(cid:4)local(cid:4)cvsroot
`sh and bash users should instead have these lines in their (cid:24)(cid:2)profile(cid:13) or (cid:24)(cid:2)bashrc(cid:13)(cid:11)
`CVSROOT(cid:26)(cid:4)usr(cid:4)local(cid:4)cvsroot
`export CVSROOT
`A repository speci(cid:9)ed with (cid:6)d will override the (cid:9)CVSROOT environment variable(cid:3) Once
`you(cid:13)ve checked a working copy out from the repository(cid:8) it will remember where its repository
`is (cid:17)the information is recorded in the (cid:24)CVS(cid:4)Root(cid:13) (cid:9)le in the working copy(cid:18)(cid:3)
`The (cid:6)d option and the (cid:24)CVS(cid:4)Root(cid:13) (cid:9)le both override the (cid:9)CVSROOT environment variable(cid:3)
`If (cid:6)d option di(cid:12)ers from (cid:24)CVS(cid:4)Root(cid:13)(cid:8) the former is used(cid:3) Of course(cid:8) for proper operation
`they should be two ways of referring to the same repository(cid:3)
`
`Dropbox Ex. 1005
`
`

`
`
`
`CVS(cid:23)Concurrent Versions System
`
`(cid:2) How data is stored in the repository
`
`For most purposes it isn(cid:13)t important how cvs stores information in the repository(cid:3) In
`fact(cid:8) the format has changed in the past(cid:8) and is likely to change in the future(cid:3) Since in
`almost all cases one accesses the repository via cvs commands(cid:8) such changes need not be
`disruptive(cid:3)
`
`However(cid:8) in some cases it may be necessary to understand how cvs stores data in
`the repository(cid:8) for example you might need to track down cvs locks (cid:17)see Section (cid:3)
`(cid:20)Concurrency(cid:21)(cid:8) page  (cid:18) or you might need to deal with the (cid:9)le permissions appropriate for
`the repository(cid:3)
`
`(cid:2)(cid:2) Where (cid:7)les are stored within the repository
`
`The overall structure of the repository is a directory tree corresponding to the directories
`in the working directory(cid:3) For example(cid:8) supposing the repository is in
`
`(cid:4)usr(cid:4)local(cid:4)cvsroot
`
`here is a possible directory tree (cid:17)showing only the directories(cid:18)(cid:11)
`
`(cid:4)usr
`
`(cid:27) (cid:28)
`
`(cid:27)
`(cid:27)
`(cid:27)
`(cid:27)
`
`(cid:6)(cid:6)local
`(cid:27)
`(cid:28)(cid:6)(cid:6)cvsroot
`(cid:27)
`(cid:27)
`(cid:27)
`(cid:28)(cid:6)(cid:6)CVSROOT
`(cid:27)
`(cid:15)administrative files(cid:16)
`
`(cid:27) (cid:28)
`
`(cid:27)
`(cid:27)
`(cid:27)
`(cid:27)
`(cid:27)
`(cid:27)
`(cid:27)
`(cid:27)
`(cid:27)
`
`(cid:6)(cid:6)gnu
`(cid:27)
`(cid:28)(cid:6)(cid:6)diff
`(cid:15)source code to gnu diff(cid:16)
`(cid:27)
`(cid:27)
`(cid:28)(cid:6)(cid:6)rcs
`(cid:15)source code to rcs(cid:16)
`(cid:27)
`(cid:27)
`(cid:28)(cid:6)(cid:6)cvs
`(cid:15)source code to cvs(cid:16)
`
`(cid:27) (cid:28)
`
`(cid:6)(cid:6)yoyodyne
`
`(cid:27) (cid:28)
`
`(cid:27)
`(cid:27)
`(cid:27)
`(cid:27)
`
`(cid:27) (cid:28)
`
`(cid:6)(cid:6)tc
`(cid:27)
`(cid:28)(cid:6)(cid:6)man
`(cid:27)
`(cid:28)(cid:6)(cid:6)testing
`
`(cid:6)(cid:6)(cid:15)other Yoyodyne software(cid:16)
`
`Dropbox Ex. 1005
`
`

`
`Chapter (cid:11) The Repository
`
`
`
`With the directories are history (cid:4)les for each (cid:9)le under version control(cid:3) The name of
`the history (cid:9)le is the name of the corresponding (cid:9)le with (cid:24)(cid:21)v(cid:13) appended to the end(cid:3) Here is
`what the repository for the (cid:24)yoyodyne(cid:4)tc(cid:13) directory might look like(cid:11)
`
`(cid:9)CVSROOT
`
`(cid:27) (cid:28)
`
`(cid:27)
`(cid:27)
`(cid:27)
`
`(cid:6)(cid:6)yoyodyne
`(cid:27)
`(cid:28)(cid:6)(cid:6)tc
`(cid:27)
`
`(cid:27) (cid:28)
`
`(cid:6)(cid:6)Makefile(cid:21)v
`(cid:28)(cid:6)(cid:6)backend(cid:2)c(cid:21)v
`(cid:28)(cid:6)(cid:6)driver(cid:2)c(cid:21)v
`(cid:28)(cid:6)(cid:6)frontend(cid:2)c(cid:21)v
`(cid:28)(cid:6)(cid:6)parser(cid:2)c(cid:21)v
`(cid:28)(cid:6)(cid:6)man
`(cid:27)
`(cid:27)
`(cid:27)
`(cid:28)(cid:6)(cid:6)tc(cid:2) (cid:21)v
`
`(cid:27) (cid:28)
`
`(cid:6)(cid:6)testing
`
`(cid:27) (cid:28)
`
`(cid:6)(cid:6)testpgm(cid:2)t(cid:21)v
`(cid:28)(cid:6)(cid:6)test(cid:2)t(cid:21)v
`
`The history (cid:9)les contain(cid:8) among other things(cid:8) enough information to recreate any revision
`of the (cid:9)le(cid:8) a log of all commit messages and the user(cid:10)name of the person who committed
`the revision(cid:3) The history (cid:9)les are known as RCS (cid:4)les(cid:8) because the (cid:9)rst program to store
`(cid:9)les in that format was a version control system known as rcs(cid:3) For a full description of
`the (cid:9)le format(cid:8) see the man page rcs(cid:4)le(cid:5)(cid:7)(cid:8) distributed with rcs(cid:8) or the (cid:9)le (cid:24)doc(cid:4)RCSFILES(cid:13)
`in the cvs source distribution(cid:3) This (cid:9)le format has become very common(cid:23)many systems
`other than cvs or rcs can at least import history (cid:9)les in this format(cid:3)
`
`The rcs (cid:9)les used in cvs di(cid:12)er in a few ways from the standard format(cid:3) The biggest
`di(cid:12)erence is magic branches(cid:30) for more information see Section (cid:3) (cid:20)Magic branch numbers(cid:21)(cid:8)
`page (cid:3) Also in cvs the valid tag names are a subset of what rcs accepts(cid:30) for cvs(cid:13)s rules
`see Section (cid:3) (cid:20)Tags(cid:21)(cid:8) page (cid:3)
`
`(cid:2)(cid:2) File permissions
`
`All (cid:24)(cid:21)v(cid:13) (cid:9)les are created read(cid:10)only(cid:8) and you should not change the permission of those
`(cid:9)les(cid:3) The directories inside the repository should be writable by the persons that have
`permission to modify the (cid:9)les in each directory(cid:3) This normally means that you must create
`a UNIX group (cid:17)see group(cid:17)(cid:18)(cid:18) consisting of the persons that are to edit the (cid:9)les in a project(cid:8)
`and set up the repository so that it is that group that owns the directory(cid:3)
`
`This means that you can only control access to (cid:9)les on a per(cid:10)directory basis(cid:3)
`
`Note that users must also have write access to check out (cid:9)les(cid:8) because cvs needs to
`create lock (cid:9)les (cid:17)see Section (cid:3) (cid:20)Concurrency(cid:21)(cid:8) page  (cid:18)(cid:3)
`
`Dropbox Ex. 1005
`
`

`
`
`
`CVS(cid:23)Concurrent Versions System
`
`Also note that users must have write access to the (cid:24)CVSROOT(cid:4)val(cid:6)tags(cid:13) (cid:9)le(cid:3) Cvs uses
`it to keep track of what tags are valid tag names (cid:17)it is sometimes updated when tags are
`used(cid:8) as well as when they are created(cid:18)(cid:3)
`
`Each rcs (cid:9)le will be owned by the user who last checked it in(cid:3) This has little signi(cid:9)cance(cid:30)
`what really matters is who owns the directories(cid:3)
`
`cvs tries to set up reasonable (cid:9)le permissions for new directories that are added inside the
`tree(cid:8) but you must (cid:9)x the permissions manually when a new directory should have di(cid:12)erent
`permissions than its parent directory(cid:3) If you set the CVSUMASK environment variable that
`will control the (cid:9)le permissions which cvs uses in creating directories and(cid:31)or (cid:9)les in the
`repository(cid:3) CVSUMASK does not a(cid:12)ect the (cid:9)le permissions in the working directory(cid:30) such
`(cid:9)les have the permissions which are typical for newly created (cid:9)les(cid:8) except that sometimes
`cvs creates them read(cid:10)only (cid:17)see the sections on watches(cid:8) Section (cid:3)(cid:3) (cid:20)Setting a watch(cid:21)(cid:8)
`page (cid:30) (cid:10)r(cid:8) Section A(cid:3) (cid:20)Global options(cid:21)(cid:8) page (cid:30) or CVSREAD(cid:8) Appendix D (cid:20)Environment
`variables(cid:21)(cid:8) page (cid:18)(cid:3)
`
`Note that using the client(cid:31)server cvs (cid:17)see Section (cid:3) (cid:20)Remote repositories(cid:21)(cid:8) page (cid:18)(cid:8)
`there is no good way to set CVSUMASK(cid:30) the setting on the client machine has no e(cid:12)ect(cid:3) If you
`are connecting with rsh(cid:8) you can set CVSUMASK in (cid:24)(cid:2)bashrc(cid:13) or (cid:24)(cid:2)cshrc(cid:13)(cid:8) as described in the
`documentation for your operating system(cid:3) This behavior might change in future versions
`of cvs(cid:30) do not rely on the setting of CVSUMASK on the client having no e(cid:12)ect(cid:3)
`
`Using pserver(cid:8) you will generally need stricter permissions on the cvsroot directory
`and directories above it in the tree(cid:30) see Section (cid:3) (cid:3) (cid:3) (cid:20)Password authentication security(cid:21)(cid:8)
`page (cid:3)
`
`Some operating systems have features which allow a particular program to run with the
`ability to perform operations which the caller of the program could not(cid:3) For example(cid:8) the
`set user ID (cid:17)setuid(cid:18) or set group ID (cid:17)setgid(cid:18) features of unix or the installed image feature
`of VMS(cid:3) CVS was not written to use such features and therefore attempting to install CVS
`in this fashion will provide protection against only accidental lapses(cid:30) anyone who is trying
`to circumvent the measure will be able to do so(cid:8) and depending on how you have set it
`up may gain access to more than just CVS(cid:3) You may wish to instead consider pserver(cid:3) It
`shares some of the same attributes(cid:8) in terms of possibly providing a false sense of security or
`opening security holes wider than the ones you are trying to (cid:9)x(cid:8) so read the documentation
`on pserver security carefully if you are considering this option (cid:17)Section (cid:3) (cid:3) (cid:3) (cid:20)Password
`authentication security(cid:21)(cid:8) page (cid:18)(cid:3)
`
`(cid:2)(cid:2) File Permission issues speci(cid:7)c to Windows
`
`Some (cid:9)le permission issues are speci(cid:9)c to Windows operating systems (cid:17)Windows (cid:8)
`Windows NT(cid:8) and presumably future operating systems in this family(cid:3) Some of the following
`might apply to OS(cid:31) but I(cid:13)m not sure(cid:18)(cid:3)
`
`If you are using local CVS and the repository is on a networked (cid:9)le system which is
`served by the Samba SMB server(cid:8) some people have reported problems with permissions(cid:3)
`Enabling WRITE YES in the samba con(cid:9)guration is said to (cid:9)x(cid:31)workaround it(cid:3) Disclaimer(cid:11)
`I haven(cid:13)t investigated enough to know the implications of enabling that option(cid:8) nor do I
`know whether there is something which CVS could be doing di(cid:12)erently in order to avoid
`
`Dropbox Ex. 1005
`
`

`
`Chapter (cid:11) The Repository
`
`
`
`the problem(cid:3) If you (cid:9)nd something out(cid:8) please let us know as described in Appendix H
`(cid:20)BUGS(cid:21)(cid:8) page  (cid:3)
`
`(cid:2)(cid:2) The attic
`
`You will notice that sometimes cvs stores an rcs (cid:9)le in the Attic(cid:3) For example(cid:8) if the
`cvsroot is (cid:24)(cid:4)usr(cid:4)local(cid:4)cvsroot(cid:13) and we are talking about the (cid:9)le (cid:24)backend(cid:2)c(cid:13) in the
`directory (cid:24)yoyodyne(cid:4)tc(cid:13)(cid:8) then the (cid:9)le normally would be in
`(cid:4)usr(cid:4)local(cid:4)cvsroot(cid:4)yoyodyne(cid:4)tc(cid:4)backend(cid:2)c(cid:21)v
`but if it goes in the attic(cid:8) it would be in
`(cid:4)usr(cid:4)local(cid:4)cvsroot(cid:4)yoyodyne(cid:4)tc(cid:4)Attic(cid:4)backend(cid:2)c(cid:21)v
`instead(cid:3) It should not matter from a user point of view whether a (cid:9)le is in the attic(cid:30)
`cvs keeps track of this and looks in the attic when it ne