/*
* save_file() adds file name and associated module to the file list to select.
*
* If "dir" is null, store a file name as is.
* If "name" is null, store a directory name with a '*' on the front.
* Else, store concatenated "dir/name".
*
* Later, in the "select" stage:
* - if it starts with '*', it is prefix-matched against the repository.
* - if it has a '/' in it, it is matched against the repository/file.
* - else it is matched against the file name.
*/
static void
save_file (char *dir, char *name, char *module)
{
struct file_list_str *fl;
if (file_count == file_max)
{
file_max = xsum (file_max, FILE_INCREMENT);
if (size_overflow_p (xtimes (file_max, sizeof (*fl))))
{
error (0, 0, "save_file: too many files");
return;
}
file_list = xnrealloc (file_list, file_max, sizeof (*fl));
}
fl = &file_list[file_count++];
fl->l_module = module;
if (dir && *dir)
{
if (name && *name)
fl->l_file = Xasprintf ("%s/%s", dir, name);
else
fl->l_file = Xasprintf ("*%s", dir);
}
else
{
if (name && *name)
fl->l_file = xstrdup (name);
else
error (0, 0, "save_file: null dir and file name");
}
}
/*
* Write the CVS/Root file so that the environment variable CVSROOT
* and/or the -d option to cvs will be validated or not necessary for
* future work.
*/
void
Create_Root (const char *dir, const char *rootdir)
{
FILE *fout;
char *tmp;
if (noexec)
return;
/* record the current cvs root */
if (rootdir != NULL)
{
if (dir != NULL)
tmp = Xasprintf ("%s/%s", dir, CVSADM_ROOT);
else
tmp = xstrdup (CVSADM_ROOT);
fout = xfopen (tmp, "w+");
if (fprintf (fout, "%s\n", rootdir) < 0)
error (1, errno, "write to %s failed", tmp);
if (fclose (fout) == EOF)
error (1, errno, "cannot close %s", tmp);
free (tmp);
}
}
/* Generate a unique temporary filename and return an open file stream
* to the truncated file by that name
*
* INPUTS
* filename where to place the pointer to the newly allocated file
* name string
*
* OUTPUTS
* filename dereferenced, will point to the newly allocated file
* name string. This value is undefined if the function
* returns an error.
*
* RETURNS
* An open file pointer to a read/write mode empty temporary file with the
* unique file name or NULL on failure.
*
* ERRORS
* On error, errno will be set to some value either by CVS_FOPEN or
* whatever system function is called to generate the temporary file name.
* The value of filename is undefined on error.
*/
FILE *
cvs_temp_file (char **filename)
{
char *fn;
FILE *fp;
int fd;
/* FIXME - I'd like to be returning NULL here in noexec mode, but I think
* some of the rcs & diff functions which rely on a temp file run in
* noexec mode too.
*/
assert (filename != NULL);
fn = Xasprintf ("%s/%s", get_cvs_tmp_dir (), "cvsXXXXXX");
fd = mkstemp (fn);
/* a NULL return will be interpreted by callers as an error and
* errno should still be set
*/
if (fd == -1)
fp = NULL;
else if ((fp = CVS_FDOPEN (fd, "w+")) == NULL)
{
/* Attempt to close and unlink the file since mkstemp returned
* sucessfully and we believe it's been created and opened.
*/
int save_errno = errno;
if (close (fd))
error (0, errno, "Failed to close temporary file %s", fn);
if (CVS_UNLINK (fn))
error (0, errno, "Failed to unlink temporary file %s", fn);
errno = save_errno;
}
if (fp == NULL)
free (fn);
/* mkstemp is defined to open mode 0600 using glibc 2.0.7+. There used
* to be a complicated #ifdef checking the library versions here and then
* a chmod 0600 on the temp file for versions of glibc less than 2.1. This
* is rather a special case, leaves a race condition open regardless, and
* one could hope that sysadmins have read the relevant security
* announcements and upgraded by now to a version with a fix committed in
* January of 1999.
*
* If it is decided at some point that old, buggy versions of glibc should
* still be catered to, a umask of 0600 should be set before file creation
* instead then reset after file creation since this would avoid the race
* condition that the chmod left open to exploitation.
*/
*filename = fn;
return fp;
}
/*
* Open the modules file, and die if the CVSROOT environment variable
* was not set. If the modules file does not exist, that's fine, and
* a warning message is displayed and a NULL is returned.
*/
DBM *
open_module (void)
{
char *mfile;
DBM *retval;
if (current_parsed_root == NULL)
{
error (0, 0, "must set the CVSROOT environment variable");
error (1, 0, "or specify the '-d' global option");
}
mfile = Xasprintf ("%s/%s/%s", current_parsed_root->directory,
CVSROOTADM, CVSROOTADM_MODULES);
retval = dbm_open (mfile, O_RDONLY, 0666);
free (mfile);
return retval;
}
/* Add an argument. OPT is the option letter, e.g. 'a'. ARG is the
argument to that option, or NULL if omitted (whether NULL can actually
happen depends on whether the option was specified as optional to
getopt). */
static void
arg_add (struct admin_data *dat, int opt, char *arg)
{
char *newelt = Xasprintf ("-%c%s", opt, arg ? arg : "");
if (dat->av_alloc == 0)
{
dat->av_alloc = 1;
dat->av = xnmalloc (dat->av_alloc, sizeof (*dat->av));
}
else if (dat->ac >= dat->av_alloc)
{
dat->av_alloc *= 2;
dat->av = xnrealloc (dat->av, dat->av_alloc, sizeof (*dat->av));
}
dat->av[dat->ac++] = newelt;
}
/*
* To the "ignore list", add the hard-coded default ignored wildcards above,
* the wildcards found in $CVSROOT/CVSROOT/cvsignore, the wildcards found in
* ~/.cvsignore and the wildcards found in the CVSIGNORE environment
* variable.
*/
void
ign_setup (void)
{
char *home_dir;
char *tmp;
ign_inhibit_server = 0;
/* Start with default list and special case */
tmp = xstrdup (ign_default);
ign_add (tmp, 0);
free (tmp);
/* The client handles another way, by (after it does its own ignore file
processing, and only if !ign_inhibit_server), letting the server
know about the files and letting it decide whether to ignore
them based on CVSROOOTADM_IGNORE. */
if (!current_parsed_root->isremote)
{
char *file = Xasprintf ("%s/%s/%s", current_parsed_root->directory,
CVSROOTADM, CVSROOTADM_IGNORE);
/* Then add entries found in repository, if it exists */
ign_add_file (file, 0);
free (file);
}
/* Then add entries found in home dir, (if user has one) and file exists */
home_dir = get_homedir ();
/* If we can't find a home directory, ignore ~/.cvsignore. This may
make tracking down problems a bit of a pain, but on the other
hand it might be obnoxious to complain when CVS will function
just fine without .cvsignore (and many users won't even know what
.cvsignore is). */
if (home_dir)
{
char *file = strcat_filename_onto_homedir (home_dir, CVSDOTIGNORE);
ign_add_file (file, 0);
free (file);
}
/* Then add entries found in CVSIGNORE environment variable. */
ign_add (getenv (IGNORE_ENV), 0);
/* Later, add ignore entries found in -I arguments */
}
/* Given a UNIX seconds since the epoch, return a string in the format used by
* the Entries file.
*
*
* INPUTS
* UNIXTIME The timestamp to be formatted.
*
* RETURNS
* A freshly allocated string the caller is responsible for disposing of.
*/
char *
entries_time (time_t unixtime)
{
struct tm *tm_p;
char *cp;
/* We want to use the same timestamp format as is stored in the
st_mtime. For unix (and NT I think) this *must* be universal
time (UT), so that files don't appear to be modified merely
because the timezone has changed. For VMS, or hopefully other
systems where gmtime returns NULL, the modification time is
stored in local time, and therefore it is not possible to cause
st_mtime to be out of sync by changing the timezone. */
tm_p = gmtime (&unixtime);
cp = tm_p ? asctime (tm_p) : ctime (&unixtime);
/* Get rid of the EOL */
cp[24] = '\0';
/* Fix non-standard format. */
if (cp[8] == '0') cp[8] = ' ';
return Xasprintf ("%s", cp);
}
static int
deep_remove_dir (const char *path)
{
DIR *dirp;
struct dirent *dp;
if (rmdir (path) != 0)
{
if (errno == ENOTEMPTY
|| errno == EEXIST
/* Ugly workaround for ugly AIX 4.1 (and 3.2) header bug
(it defines ENOTEMPTY and EEXIST to 17 but actually
returns 87). */
|| (ENOTEMPTY == 17 && EEXIST == 17 && errno == 87))
{
if ((dirp = CVS_OPENDIR (path)) == NULL)
/* If unable to open the directory return
* an error
*/
return -1;
errno = 0;
while ((dp = CVS_READDIR (dirp)) != NULL)
{
char *buf;
if (strcmp (dp->d_name, ".") == 0 ||
strcmp (dp->d_name, "..") == 0)
continue;
buf = Xasprintf ("%s/%s", path, dp->d_name);
/* See comment in unlink_file_dir explanation of why we use
isdir instead of just calling unlink and checking the
status. */
if (isdir (buf))
{
if (deep_remove_dir (buf))
{
CVS_CLOSEDIR (dirp);
free (buf);
return -1;
}
}
else
{
if (CVS_UNLINK (buf) != 0)
{
CVS_CLOSEDIR (dirp);
free (buf);
return -1;
}
}
free (buf);
errno = 0;
}
if (errno != 0)
{
int save_errno = errno;
CVS_CLOSEDIR (dirp);
errno = save_errno;
return -1;
}
CVS_CLOSEDIR (dirp);
return rmdir (path);
}
else
return -1;
}
/* Was able to remove the directory return 0 */
return 0;
}
/*
* Process the current directory, looking for files not in ILIST and
* not on the global ignore list for this directory. If we find one,
* call PROC passing it the name of the file and the update dir.
* ENTRIES is the entries list, which is used to identify known
* directories. ENTRIES may be NULL, in which case we assume that any
* directory with a CVS administration directory is known.
*/
void
ignore_files (List *ilist, List *entries, const char *update_dir,
Ignore_proc proc)
{
int subdirs;
DIR *dirp;
struct dirent *dp;
struct stat sb;
char *file;
const char *xdir;
List *files;
Node *p;
/* Set SUBDIRS if we have subdirectory information in ENTRIES. */
if (entries == NULL)
subdirs = 0;
else
{
struct stickydirtag *sdtp = entries->list->data;
subdirs = sdtp == NULL || sdtp->subdirs;
}
/* we get called with update_dir set to "." sometimes... strip it */
if (strcmp (update_dir, ".") == 0)
xdir = "";
else
xdir = update_dir;
dirp = CVS_OPENDIR (".");
if (dirp == NULL)
{
error (0, errno, "cannot open current directory");
return;
}
ign_add_file (CVSDOTIGNORE, 1);
wrap_add_file (CVSDOTWRAPPER, 1);
/* Make a list for the files. */
files = getlist ();
while (errno = 0, (dp = CVS_READDIR (dirp)) != NULL)
{
file = dp->d_name;
if (strcmp (file, ".") == 0 || strcmp (file, "..") == 0)
continue;
if (findnode_fn (ilist, file) != NULL)
continue;
if (subdirs)
{
Node *node;
node = findnode_fn (entries, file);
if (node != NULL
&& ((Entnode *) node->data)->type == ENT_SUBDIR)
{
char *p;
int dir;
/* For consistency with past behaviour, we only ignore
this directory if there is a CVS subdirectory.
This will normally be the case, but the user may
have messed up the working directory somehow. */
p = Xasprintf ("%s/%s", file, CVSADM);
dir = isdir (p);
free (p);
if (dir)
continue;
}
}
/* We could be ignoring FIFOs and other files which are neither
regular files nor directories here. */
if (ign_name (file))
continue;
if (
#ifdef DT_DIR
dp->d_type != DT_UNKNOWN ||
#endif
lstat (file, &sb) != -1)
{
if (
#ifdef DT_DIR
dp->d_type == DT_DIR
|| (dp->d_type == DT_UNKNOWN && S_ISDIR (sb.st_mode))
#else
S_ISDIR (sb.st_mode)
#endif
)
{
if (!subdirs)
{
char *temp = Xasprintf ("%s/%s", file, CVSADM);
if (isdir (temp))
{
free (temp);
continue;
}
free (temp);
}
}
#ifdef S_ISLNK
else if (
#ifdef DT_DIR
dp->d_type == DT_LNK
|| (dp->d_type == DT_UNKNOWN && S_ISLNK (sb.st_mode))
#else
S_ISLNK (sb.st_mode)
#endif
)
{
continue;
}
#endif
}
p = getnode ();
p->type = FILES;
p->key = xstrdup (file);
(void) addnode (files, p);
}
if (errno != 0)
error (0, errno, "error reading current directory");
(void) CVS_CLOSEDIR (dirp);
sortlist (files, fsortcmp);
for (p = files->list->next; p != files->list; p = p->next)
(*proc) (p->key, xdir);
dellist (&files);
}
/* An empty LogHistory string in CVSROOT/config will turn logging off.
*/
void
history_write (int type, const char *update_dir, const char *revs,
const char *name, const char *repository)
{
const char *fname;
char *workdir;
char *username = getcaller ();
int fd;
char *line;
char *slash = "", *cp;
const char *cp2, *repos;
int i;
static char *tilde = "";
static char *PrCurDir = NULL;
time_t now;
if (logoff) /* History is turned off by noexec or
* readonlyfs.
*/
return;
if (!strchr (config->logHistory, type))
return;
if (nolock)
goto out;
repos = Short_Repository (repository);
if (!PrCurDir)
{
char *pwdir;
pwdir = get_homedir ();
PrCurDir = CurDir;
if (pwdir != NULL)
{
/* Assumes neither CurDir nor pwdir ends in '/' */
i = strlen (pwdir);
if (!strncmp (CurDir, pwdir, i))
{
PrCurDir += i; /* Point to '/' separator */
tilde = "~";
}
else
{
/* Try harder to find a "homedir" */
struct saved_cwd cwd;
char *homedir;
if (save_cwd (&cwd))
error (1, errno, "Failed to save current directory.");
if (CVS_CHDIR (pwdir) < 0 || (homedir = xgetcwd ()) == NULL)
homedir = pwdir;
if (restore_cwd (&cwd))
error (1, errno,
"Failed to restore current directory, `%s'.",
cwd.name);
free_cwd (&cwd);
i = strlen (homedir);
if (!strncmp (CurDir, homedir, i))
{
PrCurDir += i; /* Point to '/' separator */
tilde = "~";
}
if (homedir != pwdir)
free (homedir);
}
}
}
if (type == 'T')
{
repos = update_dir;
update_dir = "";
}
else if (update_dir && *update_dir)
slash = "/";
else
update_dir = "";
workdir = Xasprintf ("%s%s%s%s", tilde, PrCurDir, slash, update_dir);
/*
* "workdir" is the directory where the file "name" is. ("^~" == $HOME)
* "repos" is the Repository, relative to $CVSROOT where the RCS file is.
*
* "$workdir/$name" is the working file name.
* "$CVSROOT/$repos/$name,v" is the RCS file in the Repository.
*
* First, note that the history format was intended to save space, not
* to be human readable.
*
* The working file directory ("workdir") and the Repository ("repos")
* usually end with the same one or more directory elements. To avoid
* duplication (and save space), the "workdir" field ends with
* an integer offset into the "repos" field. This offset indicates the
* beginning of the "tail" of "repos", after which all characters are
* duplicates.
*
* In other words, if the "workdir" field has a '*' (a very stupid thing
* to put in a filename) in it, then every thing following the last '*'
* is a hex offset into "repos" of the first character from "repos" to
* append to "workdir" to finish the pathname.
*
* It might be easier to look at an example:
*
* M273b3463|dgg|~/work*9|usr/local/cvs/examples|1.2|loginfo
*
* Indicates that the workdir is really "~/work/cvs/examples", saving
* 10 characters, where "~/work*d" would save 6 characters and mean that
* the workdir is really "~/work/examples". It will mean more on
* directories like: usr/local/gnu/emacs/dist-19.17/lisp/term
*
* "workdir" is always an absolute pathname (~/xxx is an absolute path)
* "repos" is always a relative pathname. So we can assume that we will
* never run into the top of "workdir" -- there will always be a '/' or
* a '~' at the head of "workdir" that is not matched by anything in
* "repos". On the other hand, we *can* run off the top of "repos".
*
* Only "compress" if we save characters.
*/
cp = workdir + strlen (workdir) - 1;
cp2 = repos + strlen (repos) - 1;
for (i = 0; cp2 >= repos && cp > workdir && *cp == *cp2--; cp--)
i++;
if (i > 2)
{
i = strlen (repos) - i;
(void) sprintf ((cp + 1), "*%x", i);
}
if (!revs)
revs = "";
now = time (NULL);
line = Xasprintf ("%c%08lx|%s|%s|%s|%s|%s\n", type, (long) now,
username, workdir, repos, revs, name);
fname = get_history_log_name (now);
if (!history_lock (current_parsed_root->directory))
/* history_lock() will already have printed an error on failure. */
goto out;
fd = CVS_OPEN (fname, O_WRONLY | O_APPEND | O_CREAT | OPEN_BINARY, 0666);
if (fd < 0)
{
if (!really_quiet)
error (0, errno,
"warning: cannot open history file `%s' for write", fname);
goto out;
}
TRACE (TRACE_FUNCTION, "open (`%s', a)", fname);
/* Lessen some race conditions on non-Posix-compliant hosts.
*
* FIXME: I'm guessing the following was necessary for NFS when multiple
* simultaneous writes to the same file are possible, since NFS does not
* natively support append mode and it must be emulated via lseek(). Now
* that the history file is locked for write, the following lseek() may be
* unnecessary.
*/
if (lseek (fd, (off_t) 0, SEEK_END) == -1)
error (1, errno, "cannot seek to end of history file: %s", fname);
if (write (fd, line, strlen (line)) < 0)
error (1, errno, "cannot write to history file: %s", fname);
free (line);
if (close (fd) != 0)
error (1, errno, "cannot close history file: %s", fname);
free (workdir);
out:
clear_history_lock ();
}
/* The purpose of "select_hrec" is to apply the selection criteria based on
* the command arguments and defaults and return a flag indicating whether
* this record should be remembered for printing.
*/
static int
select_hrec (struct hrec *hr)
{
char **cpp, *cp, *cp2;
struct file_list_str *fl;
int count;
/* basic validity checking */
if (!hr->type || !hr->user || !hr->dir || !hr->repos || !hr->rev ||
!hr->file || !hr->end)
{
error (0, 0, "warning: history line %ld invalid", hr->idx);
return 0;
}
/* "Since" checking: The argument parser guarantees that only one of the
* following four choices is set:
*
* 1. If "since_date" is set, it contains the date specified on the
* command line. hr->date fields earlier than "since_date" are ignored.
* 2. If "since_rev" is set, it contains either an RCS "dotted" revision
* number (which is of limited use) or a symbolic TAG. Each RCS file
* is examined and the date on the specified revision (or the revision
* corresponding to the TAG) in the RCS file (CVSROOT/repos/file) is
* compared against hr->date as in 1. above.
* 3. If "since_tag" is set, matching tag records are saved. The field
* "last_since_tag" is set to the last one of these. Since we don't
* know where the last one will be, all records are saved from the
* first occurrence of the TAG. Later, at the end of "select_hrec"
* records before the last occurrence of "since_tag" are skipped.
* 4. If "backto" is set, all records with a module name or file name
* matching "backto" are saved. In addition, all records with a
* repository field with a *prefix* matching "backto" are saved.
* The field "last_backto" is set to the last one of these. As in
* 3. above, "select_hrec" adjusts to include the last one later on.
*/
if (since_date)
{
char *ourdate = date_from_time_t (hr->date);
count = RCS_datecmp (ourdate, since_date);
free (ourdate);
if (count < 0)
return 0;
}
else if (*since_rev)
{
Vers_TS *vers;
time_t t;
struct file_info finfo;
memset (&finfo, 0, sizeof finfo);
finfo.file = hr->file;
/* Not used, so don't worry about it. */
finfo.update_dir = NULL;
finfo.fullname = finfo.file;
finfo.repository = hr->repos;
finfo.entries = NULL;
finfo.rcs = NULL;
vers = Version_TS (&finfo, NULL, since_rev, NULL, 1, 0);
if (vers->vn_rcs)
{
if ((t = RCS_getrevtime (vers->srcfile, vers->vn_rcs, NULL, 0))
!= (time_t) 0)
{
if (hr->date < t)
{
freevers_ts (&vers);
return 0;
}
}
}
freevers_ts (&vers);
}
else if (*since_tag)
{
if (*(hr->type) == 'T')
{
/*
* A 'T'ag record, the "rev" field holds the tag to be set,
* while the "repos" field holds "D"elete, "A"dd or a rev.
*/
if (within (since_tag, hr->rev))
{
last_since_tag = hr;
return 1;
}
else
return 0;
}
if (!last_since_tag)
return 0;
}
else if (*backto)
{
if (within (backto, hr->file) || within (backto, hr->mod) ||
within (backto, hr->repos))
last_backto = hr;
else
return 0;
}
/* User checking:
*
* Run down "user_list", match username ("" matches anything)
* If "" is not there and actual username is not there, return failure.
*/
if (user_list && hr->user)
{
for (cpp = user_list, count = user_count; count; cpp++, count--)
{
if (!**cpp)
break; /* null user == accept */
if (!strcmp (hr->user, *cpp)) /* found listed user */
break;
}
if (!count)
return 0; /* Not this user */
}
/* Record type checking:
*
* 1. If Record type is not in rec_types field, skip it.
* 2. If mod_list is null, keep everything. Otherwise keep only modules
* on mod_list.
* 3. If neither a 'T', 'F' nor 'O' record, run through "file_list". If
* file_list is null, keep everything. Otherwise, keep only files on
* file_list, matched appropriately.
*/
if (!strchr (rec_types, *(hr->type)))
return 0;
if (!strchr ("TFOE", *(hr->type))) /* Don't bother with "file" if "TFOE" */
{
if (file_list) /* If file_list is null, accept all */
{
for (fl = file_list, count = file_count; count; fl++, count--)
{
/* 1. If file_list entry starts with '*', skip the '*' and
* compare it against the repository in the hrec.
* 2. If file_list entry has a '/' in it, compare it against
* the concatenation of the repository and file from hrec.
* 3. Else compare the file_list entry against the hrec file.
*/
char *cmpfile = NULL;
if (*(cp = fl->l_file) == '*')
{
cp++;
/* if argument to -p is a prefix of repository */
if (!strncmp (cp, hr->repos, strlen (cp)))
{
hr->mod = fl->l_module;
break;
}
}
else
{
if (strchr (cp, '/'))
{
cmpfile = Xasprintf ("%s/%s", hr->repos, hr->file);
cp2 = cmpfile;
}
else
{
cp2 = hr->file;
}
/* if requested file is found within {repos}/file fields */
if (within (cp, cp2))
{
hr->mod = fl->l_module;
if (cmpfile != NULL)
free (cmpfile);
break;
}
if (cmpfile != NULL)
free (cmpfile);
}
}
if (!count)
return 0; /* String specified and no match */
}
}
if (mod_list)
{
for (cpp = mod_list, count = mod_count; count; cpp++, count--)
{
if (hr->mod && !strcmp (hr->mod, *cpp)) /* found module */
break;
}
if (!count)
return 0; /* Module specified & this record is not one of them. */
}
return 1; /* Select this record unless rejected above. */
}
static int
ls_proc (int argc, char **argv, char *xwhere, char *mwhere, char *mfile,
int shorten, int local, char *mname, char *msg)
{
char *repository;
int err = 0;
int which;
char *where;
int i;
if (is_rls)
{
char *myargv[2];
if (!quiet)
error (0, 0, "Listing module: `%s'",
strcmp (mname, "") ? mname : ".");
repository = xmalloc (strlen (current_parsed_root->directory)
+ strlen (argv[0])
+ (mfile == NULL ? 0 : strlen (mfile) + 1)
+ 2);
(void)sprintf (repository, "%s/%s", current_parsed_root->directory,
argv[0]);
where = xmalloc (strlen (argv[0])
+ (mfile == NULL ? 0 : strlen (mfile) + 1)
+ 1);
(void)strcpy (where, argv[0]);
/* If mfile isn't null, we need to set up to do only part of the
* module.
*/
if (mfile != NULL)
{
char *cp;
char *path;
/* If the portion of the module is a path, put the dir part on
* repos.
*/
if ((cp = strrchr (mfile, '/')) != NULL)
{
*cp = '\0';
(void)strcat (repository, "/");
(void)strcat (repository, mfile);
(void)strcat (where, "/");
(void)strcat (where, mfile);
mfile = cp + 1;
}
/* take care of the rest */
path = Xasprintf ("%s/%s", repository, mfile);
if (isdir (path))
{
/* directory means repository gets the dir tacked on */
(void)strcpy (repository, path);
(void)strcat (where, "/");
(void)strcat (where, mfile);
}
else
{
myargv[1] = mfile;
argc = 2;
argv = myargv;
}
free (path);
}
/* cd to the starting repository */
if (CVS_CHDIR (repository) < 0)
{
error (0, errno, "cannot chdir to %s", repository);
free (repository);
free (where);
return 1;
}
which = W_REPOS;
}
else /* !is_rls */
{
repository = NULL;
where = NULL;
which = W_LOCAL | W_REPOS;
}
if (show_tag || show_date || show_dead_revs)
which |= W_ATTIC;
if (show_tag != NULL && !tag_validated)
{
tag_check_valid (show_tag, argc - 1, argv + 1, local, 0, repository,
false);
tag_validated = true;
}
/* Loop on argc so that we are guaranteed that any directory passed to
* ls_direntproc should be processed if its parent is not yet in DIRS.
*/
if (argc == 1)
{
List *dirs = getlist ();
err = start_recursion (ls_fileproc, NULL, ls_direntproc,
ls_dirleaveproc, dirs, 0, NULL, local, which, 0,
CVS_LOCK_READ, where, 1, repository);
walklist (dirs, ls_print_dir, NULL);
dellist (&dirs);
}
else
{
for (i = 1; i < argc; i++)
{
List *dirs = getlist ();
err = start_recursion (ls_fileproc, NULL, ls_direntproc,
NULL, dirs, 1, argv + i, local, which, 0,
CVS_LOCK_READ, where, 1, repository);
walklist (dirs, ls_print_dir, NULL);
dellist (&dirs);
}
}
if (!(which & W_LOCAL)) free (repository);
if (where) free (where);
return err;
}
/*
* Add this directory to the list of data to be printed for a directory and
* decide whether to tell the recursion processor whether to continue
* recursing or not.
*/
static Dtype
ls_direntproc (void *callerdat, const char *dir, const char *repos,
const char *update_dir, List *entries)
{
Dtype retval;
Node *p;
/* Due to the way we called start_recursion() from ls_proc() with a single
* argument at a time, we can assume that if we don't yet have a parent
* directory in DIRS then this directory should be processed.
*/
if (strcmp (dir, "."))
{
/* Search for our parent directory. */
char *parent;
parent = xmalloc (strlen (update_dir) - strlen (dir) + 1);
strncpy (parent, update_dir, strlen (update_dir) - strlen (dir));
parent[strlen (update_dir) - strlen (dir)] = '\0';
strip_trailing_slashes (parent);
p = findnode (callerdat, parent);
}
else
p = NULL;
if (p)
{
/* Push this dir onto our parent directory's listing. */
Node *n = getnode();
if (entries_format)
n->data = Xasprintf ("D/%s////\n", dir);
else if (long_format)
{
struct long_format_data *out =
xmalloc (sizeof (struct long_format_data));
out->header = xstrdup ("d--- ");
out->time = gmformat_time_t (unix_time_stamp (repos));
out->footer = Xasprintf ("%12s%s%s", "",
show_dead_revs ? " " : "", dir);
n->data = out;
n->delproc = long_format_data_delproc;
}
else
n->data = Xasprintf ("%s\n", dir);
addnode (p->data, n);
}
if (!p || recurse)
{
/* Create a new list for this directory. */
p = getnode ();
p->key = xstrdup (strcmp (update_dir, ".") ? update_dir : "");
p->data = getlist ();
p->delproc = ls_delproc;
addnode (callerdat, p);
/* Create a local directory and mark it as needing deletion. This is
* the behavior the recursion processor relies upon, a la update &
* checkout.
*/
if (!isdir (dir))
{
int nonbranch;
if (show_tag == NULL && show_date == NULL)
{
ParseTag (&show_tag, &show_date, &nonbranch);
set_tag = true;
}
if (!created_dir)
created_dir = xstrdup (update_dir);
make_directory (dir);
Create_Admin (dir, update_dir, repos, show_tag, show_date,
nonbranch, 0, 0);
Subdir_Register (entries, NULL, dir);
}
/* Tell do_recursion to keep going. */
retval = R_PROCESS;
}
else
retval = R_SKIP_ALL;
return retval;
}
/* ARGSUSED */
static int
ls_fileproc (void *callerdat, struct file_info *finfo)
{
Vers_TS *vers;
char *regex_err;
Node *p, *n;
bool isdead;
const char *filename;
if (regexp_match)
{
#ifdef FILENAMES_CASE_INSENSITIVE
re_set_syntax (REG_ICASE|RE_SYNTAX_EGREP);
#else
re_set_syntax (RE_SYNTAX_EGREP);
#endif
if ((regex_err = re_comp (regexp_match)) != NULL)
{
error (1, 0, "bad regular expression passed to 'ls': %s",
regex_err);
}
if (re_exec (finfo->file) == 0)
return 0; /* no match */
}
vers = Version_TS (finfo, NULL, show_tag, show_date, 1, 0);
/* Skip dead revisions unless specifically requested to do otherwise.
* We also bother to check for long_format so we can print the state.
*/
if (vers->vn_rcs && (!show_dead_revs || long_format))
isdead = RCS_isdead (finfo->rcs, vers->vn_rcs);
else
isdead = false;
if (!vers->vn_rcs || (!show_dead_revs && isdead))
{
freevers_ts (&vers);
return 0;
}
p = findnode (callerdat, finfo->update_dir);
if (!p)
{
/* This only occurs when a complete path to a file is specified on the
* command line. Put the file in the root list.
*/
filename = finfo->fullname;
/* Add update_dir node. */
p = findnode (callerdat, ".");
if (!p)
{
p = getnode ();
p->key = xstrdup (".");
p->data = getlist ();
p->delproc = ls_delproc;
addnode (callerdat, p);
}
}
else
filename = finfo->file;
n = getnode();
if (entries_format)
{
char *outdate = entries_time (RCS_getrevtime (finfo->rcs, vers->vn_rcs,
0, 0));
n->data = Xasprintf ("/%s/%s/%s/%s/%s%s\n",
filename, vers->vn_rcs,
outdate, vers->options,
show_tag ? "T" : "", show_tag ? show_tag : "");
free (outdate);
}
else if (long_format)
{
struct long_format_data *out =
xmalloc (sizeof (struct long_format_data));
out->header = Xasprintf ("%-5.5s",
vers->options[0] != '\0' ? vers->options
: "----");
/* FIXME: Do we want to mimc the real `ls' command's date format? */
out->time = gmformat_time_t (RCS_getrevtime (finfo->rcs, vers->vn_rcs,
0, 0));
out->footer = Xasprintf (" %-9.9s%s %s%s", vers->vn_rcs,
strlen (vers->vn_rcs) > 9 ? "+" : " ",
show_dead_revs ? (isdead ? "dead " : " ")
: "",
filename);
n->data = out;
n->delproc = long_format_data_delproc;
}
else
n->data = Xasprintf ("%s\n", filename);
addnode (p->data, n);
freevers_ts (&vers);
return 0;
}
cvsroot_t *
Name_Root (const char *dir, const char *update_dir)
{
FILE *fpin;
cvsroot_t *ret;
const char *xupdate_dir;
char *root = NULL;
size_t root_allocated = 0;
char *tmp;
char *cvsadm;
char *cp;
int len;
TRACE (TRACE_FLOW, "Name_Root (%s, %s)",
dir ? dir : "(null)",
update_dir ? update_dir : "(null)");
if (update_dir && *update_dir)
xupdate_dir = update_dir;
else
xupdate_dir = ".";
if (dir != NULL)
{
cvsadm = Xasprintf ("%s/%s", dir, CVSADM);
tmp = Xasprintf ("%s/%s", dir, CVSADM_ROOT);
}
else
{
cvsadm = xstrdup (CVSADM);
tmp = xstrdup (CVSADM_ROOT);
}
/*
* Do not bother looking for a readable file if there is no cvsadm
* directory present.
*
* It is possible that not all repositories will have a CVS/Root
* file. This is ok, but the user will need to specify -d
* /path/name or have the environment variable CVSROOT set in
* order to continue. */
if ((!isdir (cvsadm)) || (!isreadable (tmp)))
{
ret = NULL;
goto out;
}
/*
* The assumption here is that the CVS Root is always contained in the
* first line of the "Root" file.
*/
fpin = xfopen (tmp, "r");
if ((len = getline (&root, &root_allocated, fpin)) < 0)
{
int saved_errno = errno;
/* FIXME: should be checking for end of file separately; errno
is not set in that case. */
error (0, 0, "in directory %s:", xupdate_dir);
error (0, saved_errno, "cannot read %s", CVSADM_ROOT);
error (0, 0, "please correct this problem");
ret = NULL;
goto out;
}
fclose (fpin);
cp = root + len - 1;
if (*cp == '\n')
*cp = '\0'; /* strip the newline */
/*
* root now contains a candidate for CVSroot. It must be an
* absolute pathname or specify a remote server.
*/
ret = parse_cvsroot (root);
if (ret == NULL)
{
error (0, 0, "in directory %s:", xupdate_dir);
error (0, 0,
"ignoring %s because it does not contain a valid root.",
CVSADM_ROOT);
goto out;
}
if (!ret->isremote && !isdir (ret->directory))
{
error (0, 0, "in directory %s:", xupdate_dir);
error (0, 0,
"ignoring %s because it specifies a non-existent repository %s",
CVSADM_ROOT, root);
ret = NULL;
goto out;
}
out:
free (cvsadm);
free (tmp);
if (root != NULL)
free (root);
return ret;
}
int
history (int argc, char **argv)
{
int i, c;
const char *fname = NULL;
List *flist;
if (argc == -1)
usage (history_usg);
since_rev = xstrdup ("");
since_tag = xstrdup ("");
backto = xstrdup ("");
rec_types = xstrdup ("");
getoptreset ();
while ((c = getopt (argc, argv, "+Tacelow?D:b:f:m:n:p:r:t:u:x:X:z:")) != -1)
{
switch (c)
{
case 'T': /* Tag list */
report_count++;
tag_report++;
break;
case 'a': /* For all usernames */
all_users++;
break;
case 'c':
report_count++;
modified = 1;
break;
case 'e':
report_count++;
extract_all++;
free (rec_types);
rec_types = xstrdup (ALL_HISTORY_REC_TYPES);
break;
case 'l': /* Find Last file record */
last_entry = 1;
break;
case 'o':
report_count++;
v_checkout = 1;
break;
case 'w': /* Match Working Dir (CurDir) fields */
working = 1;
break;
case 'X': /* Undocumented debugging flag */
#ifdef DEBUG
fname = optarg;
#endif
break;
case 'D': /* Since specified date */
if (*since_rev || *since_tag || *backto)
{
error (0, 0, "date overriding rev/tag/backto");
*since_rev = *since_tag = *backto = '\0';
}
since_date = Make_Date (optarg);
break;
case 'b': /* Since specified file/Repos */
if (since_date || *since_rev || *since_tag)
{
error (0, 0, "backto overriding date/rev/tag");
*since_rev = *since_tag = '\0';
if (since_date != NULL)
free (since_date);
since_date = NULL;
}
free (backto);
backto = xstrdup (optarg);
break;
case 'f': /* For specified file */
save_file (NULL, optarg, NULL);
break;
case 'm': /* Full module report */
if (!module_report++) report_count++;
/* fall through */
case 'n': /* Look for specified module */
save_module (optarg);
break;
case 'p': /* For specified directory */
save_file (optarg, NULL, NULL);
break;
case 'r': /* Since specified Tag/Rev */
if (since_date || *since_tag || *backto)
{
error (0, 0, "rev overriding date/tag/backto");
*since_tag = *backto = '\0';
if (since_date != NULL)
free (since_date);
since_date = NULL;
}
free (since_rev);
since_rev = xstrdup (optarg);
break;
case 't': /* Since specified Tag/Rev */
if (since_date || *since_rev || *backto)
{
error (0, 0, "tag overriding date/marker/file/repos");
*since_rev = *backto = '\0';
if (since_date != NULL)
free (since_date);
since_date = NULL;
}
free (since_tag);
since_tag = xstrdup (optarg);
break;
case 'u': /* For specified username */
save_user (optarg);
break;
case 'x':
report_count++;
extract++;
{
char *cp;
for (cp = optarg; *cp; cp++)
if (!strchr (ALL_HISTORY_REC_TYPES, *cp))
error (1, 0, "%c is not a valid report type", *cp);
}
free (rec_types);
rec_types = xstrdup (optarg);
break;
case 'z':
tz_local =
(optarg[0] == 'l' || optarg[0] == 'L')
&& (optarg[1] == 't' || optarg[1] == 'T')
&& !optarg[2];
if (tz_local)
tz_name = optarg;
else
{
/*
* Convert a known time with the given timezone to time_t.
* Use the epoch + 23 hours, so timezones east of GMT work.
*/
struct timespec t;
char *buf = Xasprintf ("1/1/1970 23:00 %s", optarg);
if (get_date (&t, buf, NULL))
{
/*
* Convert to seconds east of GMT, removing the
* 23-hour offset mentioned above.
*/
tz_seconds_east_of_GMT = (time_t)23 * 60 * 60
- t.tv_sec;
tz_name = optarg;
}
else
error (0, 0, "%s is not a known time zone", optarg);
free (buf);
}
break;
case '?':
default:
usage (history_usg);
break;
}
}
argc -= optind;
argv += optind;
for (i = 0; i < argc; i++)
save_file (NULL, argv[i], NULL);
/* ================ Now analyze the arguments a bit */
if (!report_count)
v_checkout++;
else if (report_count > 1)
error (1, 0, "Only one report type allowed from: \"-Tcomxe\".");
#ifdef CLIENT_SUPPORT
if (current_parsed_root->isremote)
{
struct file_list_str *f1;
char **mod;
/* We're the client side. Fire up the remote server. */
start_server ();
ign_setup ();
if (tag_report)
send_arg ("-T");
if (all_users)
send_arg ("-a");
if (modified)
send_arg ("-c");
if (last_entry)
send_arg ("-l");
if (v_checkout)
send_arg ("-o");
if (working)
send_arg ("-w");
if (fname)
option_with_arg ("-X", fname);
if (since_date)
client_senddate (since_date);
if (backto[0] != '\0')
option_with_arg ("-b", backto);
for (f1 = file_list; f1 < &file_list[file_count]; ++f1)
{
if (f1->l_file[0] == '*')
option_with_arg ("-p", f1->l_file + 1);
else
option_with_arg ("-f", f1->l_file);
}
if (module_report)
send_arg ("-m");
for (mod = mod_list; mod < &mod_list[mod_count]; ++mod)
option_with_arg ("-n", *mod);
if (*since_rev)
option_with_arg ("-r", since_rev);
if (*since_tag)
option_with_arg ("-t", since_tag);
for (mod = user_list; mod < &user_list[user_count]; ++mod)
option_with_arg ("-u", *mod);
if (extract_all)
send_arg ("-e");
if (extract)
option_with_arg ("-x", rec_types);
option_with_arg ("-z", tz_name);
send_to_server ("history\012", 0);
return get_responses_and_close ();
}
#endif
if (all_users)
save_user ("");
if (mod_list)
expand_modules ();
if (tag_report)
{
if (!strchr (rec_types, 'T'))
{
rec_types = xrealloc (rec_types, strlen (rec_types) + 5);
(void) strcat (rec_types, "T");
}
}
else if (extract || extract_all)
{
if (user_list)
user_sort++;
}
else if (modified)
{
free (rec_types);
rec_types = xstrdup ("MAR");
/*
* If the user has not specified a date oriented flag ("Since"), sort
* by Repository/file before date. Default is "just" date.
*/
if (last_entry
|| (!since_date && !*since_rev && !*since_tag && !*backto))
{
repos_sort++;
file_sort++;
/*
* If we are not looking for last_modified and the user specified
* one or more users to look at, sort by user before filename.
*/
if (!last_entry && user_list)
user_sort++;
}
}
else if (module_report)
{
free (rec_types);
rec_types = xstrdup (last_entry ? "OMAR" : ALL_HISTORY_REC_TYPES);
module_sort++;
repos_sort++;
file_sort++;
working = 0; /* User's workdir doesn't count here */
}
else
/* Must be "checkout" or default */
{
free (rec_types);
rec_types = xstrdup ("OF");
/* See comments in "modified" above */
if (!last_entry && user_list)
user_sort++;
if (last_entry
|| (!since_date && !*since_rev && !*since_tag && !*backto))
file_sort++;
}
/* If no users were specified, use self (-a saves a universal ("") user) */
if (!user_list)
save_user (getcaller ());
/* If we're looking back to a Tag value, must consider "Tag" records */
if (*since_tag && !strchr (rec_types, 'T'))
{
rec_types = xrealloc (rec_types, strlen (rec_types) + 5);
(void) strcat (rec_types, "T");
}
if (fname)
{
Node *p;
flist = getlist ();
p = getnode ();
p->type = FILES;
p->key = Xasprintf ("%s/%s/%s",
current_parsed_root->directory, CVSROOTADM, fname);
addnode (flist, p);
}
else
{
char *pat;
if (config->HistorySearchPath)
pat = config->HistorySearchPath;
else
pat = Xasprintf ("%s/%s/%s",
current_parsed_root->directory, CVSROOTADM,
CVSROOTADM_HISTORY);
flist = find_files (NULL, pat);
if (pat != config->HistorySearchPath) free (pat);
}
read_hrecs (flist);
if (hrec_count > 0)
qsort (hrec_head, hrec_count, sizeof (struct hrec), sort_order);
report_hrecs ();
if (since_date != NULL)
free (since_date);
free (since_rev);
free (since_tag);
free (backto);
free (rec_types);
return 0;
}
/* Compose a path to a file in the home directory. This is necessary because
* of different behavior on UNIX and VMS. See the notes in vms/filesubr.c.
*
* A more clean solution would be something more along the lines of a
* "join a directory to a filename" kind of thing which was not specific to
* the homedir. This should aid portability between UNIX, Mac, Windows, VMS,
* and possibly others. This is already handled by Perl - it might be
* interesting to see how much of the code was written in C since Perl is under
* the GPL and the Artistic license - we might be able to use it.
*/
char *
strcat_filename_onto_homedir (const char *dir, const char *file)
{
char *path = Xasprintf ("%s/%s", dir, file);
return path;
}
/*
* This is the recursive function that processes a module name.
* It calls back the passed routine for each directory of a module
* It runs the post checkout or post tag proc from the modules file
*/
int
my_module (DBM *db, char *mname, enum mtype m_type, char *msg,
CALLBACKPROC callback_proc, char *where, int shorten,
int local_specified, int run_module_prog, int build_dirs,
char *extra_arg, List *stack)
{
char *checkout_prog = NULL;
char *export_prog = NULL;
char *tag_prog = NULL;
struct saved_cwd cwd;
int cwd_saved = 0;
char *line;
int modargc;
int xmodargc;
char **modargv = NULL;
char **xmodargv = NULL;
/* Found entry from modules file, including options and such. */
char *value = NULL;
char *mwhere = NULL;
char *mfile = NULL;
char *spec_opt = NULL;
char *xvalue = NULL;
int alias = 0;
datum key, val;
char *cp;
int c, err = 0;
int nonalias_opt = 0;
#ifdef SERVER_SUPPORT
int restore_server_dir = 0;
char *server_dir_to_restore = NULL;
#endif
TRACE (TRACE_FUNCTION, "my_module (%s, %s, %s, %s)",
mname ? mname : "(null)", msg ? msg : "(null)",
where ? where : "NULL", extra_arg ? extra_arg : "NULL");
/* Don't process absolute directories. Anything else could be a security
* problem. Before this check was put in place:
*
* $ cvs -d:fork:/cvsroot co /foo
* cvs server: warning: cannot make directory CVS in /: Permission denied
* cvs [server aborted]: cannot make directory /foo: Permission denied
* $
*/
if (ISABSOLUTE (mname))
error (1, 0, "Absolute module reference invalid: `%s'", mname);
/* Similarly for directories that attempt to step above the root of the
* repository.
*/
if (pathname_levels (mname) > 0)
error (1, 0, "up-level in module reference (`..') invalid: `%s'.",
mname);
/* if this is a directory to ignore, add it to that list */
if (mname[0] == '!' && mname[1] != '\0')
{
ign_dir_add (mname+1);
goto do_module_return;
}
/* strip extra stuff from the module name */
strip_trailing_slashes (mname);
/*
* Look up the module using the following scheme:
* 1) look for mname as a module name
* 2) look for mname as a directory
* 3) look for mname as a file
* 4) take mname up to the first slash and look it up as a module name
* (this is for checking out only part of a module)
*/
/* look it up as a module name */
key.dptr = mname;
key.dsize = strlen (key.dptr);
if (db != NULL)
val = dbm_fetch (db, key);
else
val.dptr = NULL;
if (val.dptr != NULL)
{
/* copy and null terminate the value */
value = xmalloc (val.dsize + 1);
memcpy (value, val.dptr, val.dsize);
value[val.dsize] = '\0';
/* If the line ends in a comment, strip it off */
if ((cp = strchr (value, '#')) != NULL)
*cp = '\0';
else
cp = value + val.dsize;
/* Always strip trailing spaces */
while (cp > value && isspace ((unsigned char) *--cp))
*cp = '\0';
mwhere = xstrdup (mname);
goto found;
}
else
{
char *file;
char *attic_file;
char *acp;
int is_found = 0;
/* check to see if mname is a directory or file */
file = xmalloc (strlen (current_parsed_root->directory)
+ strlen (mname) + sizeof(RCSEXT) + 2);
(void) sprintf (file, "%s/%s", current_parsed_root->directory, mname);
attic_file = xmalloc (strlen (current_parsed_root->directory)
+ strlen (mname)
+ sizeof (CVSATTIC) + sizeof (RCSEXT) + 3);
if ((acp = strrchr (mname, '/')) != NULL)
{
*acp = '\0';
(void) sprintf (attic_file, "%s/%s/%s/%s%s", current_parsed_root->directory,
mname, CVSATTIC, acp + 1, RCSEXT);
*acp = '/';
}
else
(void) sprintf (attic_file, "%s/%s/%s%s",
current_parsed_root->directory,
CVSATTIC, mname, RCSEXT);
if (isdir (file))
{
modargv = xmalloc (sizeof (*modargv));
modargv[0] = xstrdup (mname);
modargc = 1;
is_found = 1;
}
else
{
(void) strcat (file, RCSEXT);
if (isfile (file) || isfile (attic_file))
{
/* if mname was a file, we have to split it into "dir file" */
if ((cp = strrchr (mname, '/')) != NULL && cp != mname)
{
modargv = xnmalloc (2, sizeof (*modargv));
modargv[0] = xmalloc (strlen (mname) + 2);
strncpy (modargv[0], mname, cp - mname);
modargv[0][cp - mname] = '\0';
modargv[1] = xstrdup (cp + 1);
modargc = 2;
}
else
{
/*
* the only '/' at the beginning or no '/' at all
* means the file we are interested in is in CVSROOT
* itself so the directory should be '.'
*/
if (cp == mname)
{
/* drop the leading / if specified */
modargv = xnmalloc (2, sizeof (*modargv));
modargv[0] = xstrdup (".");
modargv[1] = xstrdup (mname + 1);
modargc = 2;
}
else
{
/* otherwise just copy it */
modargv = xnmalloc (2, sizeof (*modargv));
modargv[0] = xstrdup (".");
modargv[1] = xstrdup (mname);
modargc = 2;
}
}
is_found = 1;
}
}
free (attic_file);
free (file);
if (is_found)
{
assert (value == NULL);
/* OK, we have now set up modargv with the actual
file/directory we want to work on. We duplicate a
small amount of code here because the vast majority of
the code after the "found" label does not pertain to
the case where we found a file/directory rather than
finding an entry in the modules file. */
if (save_cwd (&cwd))
error (1, errno, "Failed to save current directory.");
cwd_saved = 1;
err += callback_proc (modargc, modargv, where, mwhere, mfile,
shorten,
local_specified, mname, msg);
free_names (&modargc, modargv);
/* cd back to where we started. */
if (restore_cwd (&cwd))
error (1, errno, "Failed to restore current directory, `%s'.",
cwd.name);
free_cwd (&cwd);
cwd_saved = 0;
goto do_module_return;
}
}
/* look up everything to the first / as a module */
if (mname[0] != '/' && (cp = strchr (mname, '/')) != NULL)
{
/* Make the slash the new end of the string temporarily */
*cp = '\0';
key.dptr = mname;
key.dsize = strlen (key.dptr);
/* do the lookup */
if (db != NULL)
val = dbm_fetch (db, key);
else
val.dptr = NULL;
/* if we found it, clean up the value and life is good */
if (val.dptr != NULL)
{
char *cp2;
/* copy and null terminate the value */
value = xmalloc (val.dsize + 1);
memcpy (value, val.dptr, val.dsize);
value[val.dsize] = '\0';
/* If the line ends in a comment, strip it off */
if ((cp2 = strchr (value, '#')) != NULL)
*cp2 = '\0';
else
cp2 = value + val.dsize;
/* Always strip trailing spaces */
while (cp2 > value && isspace ((unsigned char) *--cp2))
*cp2 = '\0';
/* mwhere gets just the module name */
mwhere = xstrdup (mname);
mfile = cp + 1;
assert (strlen (mfile));
/* put the / back in mname */
*cp = '/';
goto found;
}
/* put the / back in mname */
*cp = '/';
}
/* if we got here, we couldn't find it using our search, so give up */
error (0, 0, "cannot find module `%s' - ignored", mname);
err++;
goto do_module_return;
/*
* At this point, we found what we were looking for in one
* of the many different forms.
*/
found:
/* remember where we start */
if (save_cwd (&cwd))
error (1, errno, "Failed to save current directory.");
cwd_saved = 1;
assert (value != NULL);
/* search the value for the special delimiter and save for later */
if ((cp = strchr (value, CVSMODULE_SPEC)) != NULL)
{
*cp = '\0'; /* null out the special char */
spec_opt = cp + 1; /* save the options for later */
/* strip whitespace if necessary */
while (cp > value && isspace ((unsigned char) *--cp))
*cp = '\0';
}
/* don't do special options only part of a module was specified */
if (mfile != NULL)
spec_opt = NULL;
/*
* value now contains one of the following:
* 1) dir
* 2) dir file
* 3) the value from modules without any special args
* [ args ] dir [file] [file] ...
* or -a module [ module ] ...
*/
/* Put the value on a line with XXX prepended for getopt to eat */
line = Xasprintf ("XXX %s", value);
/* turn the line into an argv[] array */
line2argv (&xmodargc, &xmodargv, line, " \t");
free (line);
modargc = xmodargc;
modargv = xmodargv;
/* parse the args */
getoptreset ();
while ((c = getopt (modargc, modargv, CVSMODULE_OPTS)) != -1)
{
switch (c)
{
case 'a':
alias = 1;
break;
case 'd':
if (mwhere)
free (mwhere);
mwhere = xstrdup (optarg);
nonalias_opt = 1;
break;
case 'l':
local_specified = 1;
nonalias_opt = 1;
break;
case 'o':
if (checkout_prog)
free (checkout_prog);
checkout_prog = xstrdup (optarg);
nonalias_opt = 1;
break;
case 'e':
if (export_prog)
free (export_prog);
export_prog = xstrdup (optarg);
nonalias_opt = 1;
break;
case 't':
if (tag_prog)
free (tag_prog);
tag_prog = xstrdup (optarg);
nonalias_opt = 1;
break;
case '?':
error (0, 0,
"modules file has invalid option for key %s value %s",
key.dptr, value);
err++;
goto do_module_return;
}
}
modargc -= optind;
modargv += optind;
if (modargc == 0 && spec_opt == NULL)
{
error (0, 0, "modules file missing directory for module %s", mname);
++err;
goto do_module_return;
}
if (alias && nonalias_opt)
{
/* The documentation has never said it is valid to specify
-a along with another option. And I believe that in the past
CVS has ignored the options other than -a, more or less, in this
situation. */
error (0, 0, "\
-a cannot be specified in the modules file along with other options");
++err;
goto do_module_return;
}
