/*
* rcs_main()
*
* Handler for the `rcs' program.
* Returns 0 on success, or >0 on error.
*/
int
rcs_main(int argc, char **argv)
{
int fd;
int i, j, ch, flags, kflag, lkmode;
const char *nflag, *oldfilename, *orange;
char fpath[PATH_MAX];
char *logstr, *logmsg, *descfile;
char *alist, *comment, *elist, *lrev, *urev;
mode_t fmode;
RCSFILE *file;
RCSNUM *logrev;
struct rcs_access *acp;
time_t rcs_mtime = -1;
kflag = RCS_KWEXP_ERR;
lkmode = RCS_LOCK_INVAL;
fmode = S_IRUSR|S_IRGRP|S_IROTH;
flags = RCS_RDWR|RCS_PARSE_FULLY;
lrev = urev = descfile = NULL;
logstr = alist = comment = elist = NULL;
nflag = oldfilename = orange = NULL;
/* match GNU */
if (1 < argc && argv[1][0] != '-')
warnx("warning: No options were given; "
"this usage is obsolescent.");
while ((ch = rcs_getopt(argc, argv, RCSPROG_OPTSTRING)) != -1) {
switch (ch) {
case 'A':
oldfilename = rcs_optarg;
rcsflags |= CO_ACLAPPEND;
break;
case 'a':
alist = rcs_optarg;
break;
case 'c':
comment = rcs_optarg;
break;
case 'e':
elist = rcs_optarg;
rcsflags |= RCSPROG_EFLAG;
break;
case 'I':
rcsflags |= INTERACTIVE;
break;
case 'i':
flags |= RCS_CREATE;
break;
case 'k':
kflag = rcs_kflag_get(rcs_optarg);
if (RCS_KWEXP_INVAL(kflag)) {
warnx("invalid RCS keyword substitution mode");
(usage)();
}
break;
case 'L':
if (lkmode == RCS_LOCK_LOOSE)
warnx("-U overridden by -L");
lkmode = RCS_LOCK_STRICT;
break;
case 'l':
if (rcsflags & RCSPROG_UFLAG)
warnx("-u overridden by -l");
lrev = rcs_optarg;
rcsflags &= ~RCSPROG_UFLAG;
rcsflags |= RCSPROG_LFLAG;
break;
case 'm':
free(logstr);
logstr = xstrdup(rcs_optarg);
break;
case 'M':
/* ignore for the moment */
break;
case 'n':
nflag = rcs_optarg;
break;
case 'N':
nflag = rcs_optarg;
rcsflags |= RCSPROG_NFLAG;
break;
case 'o':
orange = rcs_optarg;
break;
case 'q':
rcsflags |= QUIET;
break;
case 't':
descfile = rcs_optarg;
rcsflags |= DESCRIPTION;
break;
case 'T':
rcsflags |= PRESERVETIME;
break;
case 'U':
if (lkmode == RCS_LOCK_STRICT)
warnx("-L overridden by -U");
lkmode = RCS_LOCK_LOOSE;
break;
case 'u':
if (rcsflags & RCSPROG_LFLAG)
warnx("-l overridden by -u");
urev = rcs_optarg;
rcsflags &= ~RCSPROG_LFLAG;
rcsflags |= RCSPROG_UFLAG;
break;
case 'V':
printf("%s\n", rcs_version);
exit(0);
case 'x':
/* Use blank extension if none given. */
rcs_suffixes = rcs_optarg ? rcs_optarg : "";
break;
case 'z':
/*
* kept for compatibility
*/
break;
default:
(usage)();
}
}
argc -= rcs_optind;
argv += rcs_optind;
if (argc == 0) {
warnx("no input file");
(usage)();
}
for (i = 0; i < argc; i++) {
fd = rcs_choosefile(argv[i], fpath, sizeof(fpath));
if (fd < 0 && !(flags & RCS_CREATE)) {
warn("%s", fpath);
continue;
}
if (!(rcsflags & QUIET))
(void)fprintf(stderr, "RCS file: %s\n", fpath);
if ((file = rcs_open(fpath, fd, flags, fmode)) == NULL) {
close(fd);
continue;
}
if (rcsflags & DESCRIPTION) {
if (rcs_set_description(file, descfile, rcsflags) == -1) {
warn("%s", descfile);
rcs_close(file);
continue;
}
}
else if (flags & RCS_CREATE) {
if (rcs_set_description(file, NULL, rcsflags) == -1) {
warn("stdin");
rcs_close(file);
continue;
}
}
if (rcsflags & PRESERVETIME)
rcs_mtime = rcs_get_mtime(file);
if (nflag != NULL)
rcs_attach_symbol(file, nflag);
if (logstr != NULL) {
if ((logmsg = strchr(logstr, ':')) == NULL) {
warnx("missing log message");
rcs_close(file);
continue;
}
*logmsg++ = '\0';
if ((logrev = rcsnum_parse(logstr)) == NULL) {
warnx("`%s' bad revision number", logstr);
rcs_close(file);
continue;
}
if (rcs_rev_setlog(file, logrev, logmsg) < 0) {
warnx("failed to set logmsg for `%s' to `%s'",
logstr, logmsg);
rcs_close(file);
rcsnum_free(logrev);
continue;
}
rcsnum_free(logrev);
}
/* entries to add from <oldfile> */
if (rcsflags & CO_ACLAPPEND) {
RCSFILE *oldfile;
int ofd;
char ofpath[PATH_MAX];
ofd = rcs_choosefile(oldfilename, ofpath, sizeof(ofpath));
if (ofd < 0) {
if (!(flags & RCS_CREATE))
warn("%s", ofpath);
exit(1);
}
if ((oldfile = rcs_open(ofpath, ofd, RCS_READ)) == NULL)
exit(1);
TAILQ_FOREACH(acp, &(oldfile->rf_access), ra_list)
rcs_access_add(file, acp->ra_name);
rcs_close(oldfile);
(void)close(ofd);
}
/* entries to add to the access list */
if (alist != NULL) {
struct rcs_argvector *aargv;
aargv = rcs_strsplit(alist, ",");
for (j = 0; aargv->argv[j] != NULL; j++)
rcs_access_add(file, aargv->argv[j]);
rcs_argv_destroy(aargv);
}
if (comment != NULL)
rcs_comment_set(file, comment);
if (elist != NULL) {
struct rcs_argvector *eargv;
eargv = rcs_strsplit(elist, ",");
for (j = 0; eargv->argv[j] != NULL; j++)
rcs_access_remove(file, eargv->argv[j]);
rcs_argv_destroy(eargv);
} else if (rcsflags & RCSPROG_EFLAG) {
struct rcs_access *rap;
/* XXX rcs_access_remove(file, NULL); ?? */
while (!TAILQ_EMPTY(&(file->rf_access))) {
rap = TAILQ_FIRST(&(file->rf_access));
TAILQ_REMOVE(&(file->rf_access), rap, ra_list);
free(rap->ra_name);
free(rap);
}
/* not synced anymore */
file->rf_flags &= ~RCS_SYNCED;
}
rcs_kwexp_set(file, kflag);
if (lkmode != RCS_LOCK_INVAL)
(void)rcs_lock_setmode(file, lkmode);
if (rcsflags & RCSPROG_LFLAG) {
RCSNUM *rev;
const char *username;
char rev_str[RCS_REV_BUFSZ];
if (file->rf_head == NULL) {
warnx("%s contains no revisions", fpath);
rcs_close(file);
continue;
}
if ((username = getlogin()) == NULL)
err(1, "getlogin");
if (lrev == NULL) {
rev = rcsnum_alloc();
rcsnum_cpy(file->rf_head, rev, 0);
} else if ((rev = rcsnum_parse(lrev)) == NULL) {
warnx("unable to unlock file");
rcs_close(file);
continue;
}
rcsnum_tostr(rev, rev_str, sizeof(rev_str));
/* Make sure revision exists. */
if (rcs_findrev(file, rev) == NULL)
errx(1, "%s: cannot lock nonexisting "
"revision %s", fpath, rev_str);
if (rcs_lock_add(file, username, rev) != -1 &&
!(rcsflags & QUIET))
(void)fprintf(stderr, "%s locked\n", rev_str);
rcsnum_free(rev);
}
if (rcsflags & RCSPROG_UFLAG) {
RCSNUM *rev;
const char *username;
char rev_str[RCS_REV_BUFSZ];
if (file->rf_head == NULL) {
warnx("%s contains no revisions", fpath);
rcs_close(file);
continue;
}
if ((username = getlogin()) == NULL)
err(1, "getlogin");
if (urev == NULL) {
rev = rcsnum_alloc();
rcsnum_cpy(file->rf_head, rev, 0);
} else if ((rev = rcsnum_parse(urev)) == NULL) {
warnx("unable to unlock file");
rcs_close(file);
continue;
}
rcsnum_tostr(rev, rev_str, sizeof(rev_str));
/* Make sure revision exists. */
if (rcs_findrev(file, rev) == NULL)
errx(1, "%s: cannot unlock nonexisting "
"revision %s", fpath, rev_str);
if (rcs_lock_remove(file, username, rev) == -1 &&
!(rcsflags & QUIET))
warnx("%s: warning: No locks are set.", fpath);
else {
if (!(rcsflags & QUIET))
(void)fprintf(stderr,
"%s unlocked\n", rev_str);
}
rcsnum_free(rev);
}
if (orange != NULL) {
struct rcs_delta *rdp, *nrdp;
char b[RCS_REV_BUFSZ];
rcs_rev_select(file, orange);
for (rdp = TAILQ_FIRST(&(file->rf_delta));
rdp != NULL; rdp = nrdp) {
nrdp = TAILQ_NEXT(rdp, rd_list);
/*
* Delete selected revisions.
*/
if (rdp->rd_flags & RCS_RD_SELECT) {
rcsnum_tostr(rdp->rd_num, b, sizeof(b));
if (!(rcsflags & QUIET)) {
(void)fprintf(stderr, "deleting"
" revision %s\n", b);
}
(void)rcs_rev_remove(file, rdp->rd_num);
}
}
}
rcs_write(file);
if (rcsflags & PRESERVETIME)
rcs_set_mtime(file, rcs_mtime);
rcs_close(file);
if (!(rcsflags & QUIET))
(void)fprintf(stderr, "done\n");
}
return (0);
}
int
rcsdiff_main(int argc, char **argv)
{
int fd, i, ch, dflags, status;
RCSNUM *rev1, *rev2;
RCSFILE *file;
char fpath[MAXPATHLEN], *rev_str1, *rev_str2;
const char *errstr;
rev1 = rev2 = NULL;
rev_str1 = rev_str2 = NULL;
status = D_SAME;
dflags = 0;
if (strlcpy(diffargs, "diff", sizeof(diffargs)) >= sizeof(diffargs))
errx(D_ERROR, "diffargs too long");
while ((ch = rcs_getopt(argc, argv, "abC:cdI:ik:npqr:TtU:uVwx::z::")) != -1) {
switch (ch) {
case 'a':
if (strlcat(diffargs, " -a", sizeof(diffargs)) >=
sizeof(diffargs))
errx(D_ERROR, "diffargs too long");
dflags |= D_FORCEASCII;
break;
case 'b':
if (strlcat(diffargs, " -b", sizeof(diffargs)) >=
sizeof(diffargs))
errx(D_ERROR, "diffargs too long");
dflags |= D_FOLDBLANKS;
break;
case 'C':
(void)strlcat(diffargs, " -C", sizeof(diffargs));
if (strlcat(diffargs, rcs_optarg, sizeof(diffargs)) >=
sizeof(diffargs))
errx(D_ERROR, "diffargs too long");
diff_context = strtonum(rcs_optarg, 0, INT_MAX, &errstr);
if (errstr)
errx(D_ERROR, "context is %s: %s",
errstr, rcs_optarg);
diff_format = D_CONTEXT;
break;
case 'c':
if (strlcat(diffargs, " -c", sizeof(diffargs)) >=
sizeof(diffargs))
errx(D_ERROR, "diffargs too long");
diff_format = D_CONTEXT;
break;
case 'd':
if (strlcat(diffargs, " -d", sizeof(diffargs)) >=
sizeof(diffargs))
errx(D_ERROR, "diffargs too long");
dflags |= D_MINIMAL;
break;
case 'i':
if (strlcat(diffargs, " -i", sizeof(diffargs)) >=
sizeof(diffargs))
errx(D_ERROR, "diffargs too long");
dflags |= D_IGNORECASE;
break;
case 'I':
(void)strlcat(diffargs, " -I", sizeof(diffargs));
if (strlcat(diffargs, rcs_optarg, sizeof(diffargs)) >=
sizeof(diffargs))
errx(D_ERROR, "diffargs too long");
push_ignore_pats(rcs_optarg);
break;
case 'k':
kflag = rcs_kflag_get(rcs_optarg);
if (RCS_KWEXP_INVAL(kflag)) {
warnx("invalid RCS keyword substitution mode");
(usage)();
exit(D_ERROR);
}
break;
case 'n':
if (strlcat(diffargs, " -n", sizeof(diffargs)) >=
sizeof(diffargs))
errx(D_ERROR, "diffargs too long");
diff_format = D_RCSDIFF;
break;
case 'p':
if (strlcat(diffargs, " -p", sizeof(diffargs)) >=
sizeof(diffargs))
errx(D_ERROR, "diffargs too long");
dflags |= D_PROTOTYPE;
break;
case 'q':
quiet = 1;
break;
case 'r':
rcs_setrevstr2(&rev_str1, &rev_str2, rcs_optarg);
break;
case 'T':
/*
* kept for compatibility
*/
break;
case 't':
if (strlcat(diffargs, " -t", sizeof(diffargs)) >=
sizeof(diffargs))
errx(D_ERROR, "diffargs too long");
dflags |= D_EXPANDTABS;
break;
case 'U':
(void)strlcat(diffargs, " -U", sizeof(diffargs));
if (strlcat(diffargs, rcs_optarg, sizeof(diffargs)) >=
sizeof(diffargs))
errx(D_ERROR, "diffargs too long");
diff_context = strtonum(rcs_optarg, 0, INT_MAX, &errstr);
if (errstr)
errx(D_ERROR, "context is %s: %s",
errstr, rcs_optarg);
diff_format = D_UNIFIED;
break;
case 'u':
if (strlcat(diffargs, " -u", sizeof(diffargs)) >=
sizeof(diffargs))
errx(D_ERROR, "diffargs too long");
diff_format = D_UNIFIED;
break;
case 'V':
printf("%s\n", rcs_version);
exit(0);
case 'w':
if (strlcat(diffargs, " -w", sizeof(diffargs)) >=
sizeof(diffargs))
errx(D_ERROR, "diffargs too long");
dflags |= D_IGNOREBLANKS;
break;
case 'x':
/* Use blank extension if none given. */
rcs_suffixes = rcs_optarg ? rcs_optarg : "";
break;
case 'z':
timezone_flag = rcs_optarg;
break;
default:
(usage)();
exit(D_ERROR);
}
}
argc -= rcs_optind;
argv += rcs_optind;
if (argc == 0) {
warnx("no input file");
(usage)();
exit(D_ERROR);
}
if (diff_ignore_pats != NULL) {
char buf[BUFSIZ];
int error;
diff_ignore_re = xmalloc(sizeof(*diff_ignore_re));
if ((error = regcomp(diff_ignore_re, diff_ignore_pats,
REG_NEWLINE | REG_EXTENDED)) != 0) {
regerror(error, diff_ignore_re, buf, sizeof(buf));
if (*diff_ignore_pats != '\0')
errx(D_ERROR, "%s: %s", diff_ignore_pats, buf);
else
errx(D_ERROR, "%s", buf);
}
}
for (i = 0; i < argc; i++) {
fd = rcs_choosefile(argv[i], fpath, sizeof(fpath));
if (fd < 0) {
warn("%s", fpath);
continue;
}
if ((file = rcs_open(fpath, fd,
RCS_READ|RCS_PARSE_FULLY)) == NULL)
continue;
rcs_kwexp_set(file, kflag);
if (rev_str1 != NULL) {
if ((rev1 = rcs_getrevnum(rev_str1, file)) == NULL)
errx(D_ERROR, "bad revision number");
}
if (rev_str2 != NULL) {
if ((rev2 = rcs_getrevnum(rev_str2, file)) == NULL)
errx(D_ERROR, "bad revision number");
}
if (!quiet) {
fprintf(stderr, "%s\n", RCS_DIFF_DIV);
fprintf(stderr, "RCS file: %s\n", fpath);
}
diff_file = argv[i];
/* No revisions given. */
if (rev_str1 == NULL)
status = rcsdiff_file(file, file->rf_head, argv[i],
dflags);
/* One revision given. */
else if (rev_str2 == NULL)
status = rcsdiff_file(file, rev1, argv[i], dflags);
/* Two revisions given. */
else
status = rcsdiff_rev(file, rev1, rev2, dflags);
rcs_close(file);
if (rev1 != NULL) {
rcsnum_free(rev1);
rev1 = NULL;
}
if (rev2 != NULL) {
rcsnum_free(rev2);
rev2 = NULL;
}
}
return (status);
}
int
cvs_admin(int argc, char **argv)
{
int ch;
int flags;
char *statestr;
struct cvs_recursion cr;
flags = CR_RECURSE_DIRS;
alist = comment = elist = logmsg = logstr = NULL;
oldfilename = orange = state = statestr = NULL;
while ((ch = getopt(argc, argv, cvs_cmd_admin.cmd_opts)) != -1) {
switch (ch) {
case 'A':
oldfilename = optarg;
break;
case 'a':
alist = optarg;
break;
case 'b':
break;
case 'c':
comment = optarg;
break;
case 'e':
elist = optarg;
runflags |= ADM_EFLAG;
break;
case 'I':
break;
case 'k':
koptstr = optarg;
kflag = rcs_kflag_get(koptstr);
if (RCS_KWEXP_INVAL(kflag)) {
cvs_log(LP_ERR,
"invalid RCS keyword expansion mode");
fatal("%s", cvs_cmd_admin.cmd_synopsis);
}
break;
case 'L':
if (lkmode == RCS_LOCK_LOOSE) {
cvs_log(LP_ERR, "-L and -U are incompatible");
fatal("%s", cvs_cmd_admin.cmd_synopsis);
}
lkmode = RCS_LOCK_STRICT;
break;
case 'l':
break;
case 'm':
logstr = optarg;
break;
case 'N':
break;
case 'n':
break;
case 'o':
orange = optarg;
break;
case 'q':
verbosity = 0;
break;
case 's':
statestr = optarg;
break;
case 't':
break;
case 'U':
if (lkmode == RCS_LOCK_STRICT) {
cvs_log(LP_ERR, "-U and -L are incompatible");
fatal("%s", cvs_cmd_admin.cmd_synopsis);
}
lkmode = RCS_LOCK_LOOSE;
break;
case 'u':
break;
default:
fatal("%s", cvs_cmd_admin.cmd_synopsis);
}
}
argc -= optind;
argv += optind;
if (argc == 0)
fatal("%s", cvs_cmd_admin.cmd_synopsis);
cr.enterdir = NULL;
cr.leavedir = NULL;
if (current_cvsroot->cr_method != CVS_METHOD_LOCAL) {
cvs_client_connect_to_server();
cr.fileproc = cvs_client_sendfile;
if (oldfilename != NULL)
cvs_client_send_request("Argument -A%s", oldfilename);
if (alist != NULL)
cvs_client_send_request("Argument -a%s", alist);
if (comment != NULL)
cvs_client_send_request("Argument -c%s", comment);
if (runflags & ADM_EFLAG)
cvs_client_send_request("Argument -e%s",
(elist != NULL) ? elist : "");
if (koptstr != NULL)
cvs_client_send_request("Argument -k%s", koptstr);
if (lkmode == RCS_LOCK_STRICT)
cvs_client_send_request("Argument -L");
else if (lkmode == RCS_LOCK_LOOSE)
cvs_client_send_request("Argument -U");
if (logstr != NULL)
cvs_client_send_logmsg(logstr);
if (orange != NULL)
cvs_client_send_request("Argument -o%s", orange);
if (statestr != NULL)
cvs_client_send_request("Argument -s%s", statestr);
if (verbosity == 0)
cvs_client_send_request("Argument -q");
} else {
if (statestr != NULL) {
if ((staterevstr = strchr(statestr, ':')) != NULL)
*staterevstr++ = '\0';
state = statestr;
if (rcs_state_check(state) < 0) {
cvs_log(LP_ERR, "invalid state `%s'", state);
state = NULL;
}
}
flags |= CR_REPO;
cr.fileproc = cvs_admin_local;
}
cr.flags = flags;
cvs_file_run(argc, argv, &cr);
if (current_cvsroot->cr_method != CVS_METHOD_LOCAL) {
cvs_client_send_files(argv, argc);
cvs_client_senddir(".");
cvs_client_send_request("admin");
cvs_client_get_responses();
}
return (0);
}
int
cvs_import(int argc, char **argv)
{
int i, ch;
char repo[MAXPATHLEN], *arg = ".";
struct cvs_recursion cr;
struct trigger_list *line_list;
while ((ch = getopt(argc, argv, cvs_cmd_import.cmd_opts)) != -1) {
switch (ch) {
case 'b':
import_branch = optarg;
break;
case 'd':
dflag = 1;
break;
case 'k':
koptstr = optarg;
kflag = rcs_kflag_get(koptstr);
if (RCS_KWEXP_INVAL(kflag)) {
cvs_log(LP_ERR,
"invalid RCS keyword expansion mode");
fatal("%s", cvs_cmd_import.cmd_synopsis);
}
break;
case 'm':
logmsg = optarg;
break;
default:
fatal("%s", cvs_cmd_import.cmd_synopsis);
break;
}
}
argc -= optind;
argv += optind;
if (argc < 3)
fatal("%s", cvs_cmd_import.cmd_synopsis);
import_repository = argv[0];
vendor_tag = argv[1];
argc -= 2;
argv += 2;
release_tags = argv;
tagcount = argc;
if (!rcs_sym_check(vendor_tag))
fatal("invalid symbol: %s", vendor_tag);
for (i = 0; i < tagcount; i++) {
if (!rcs_sym_check(release_tags[i]))
fatal("invalid symbol: %s", release_tags[i]);
}
if (logmsg == NULL) {
if (cvs_server_active)
fatal("no log message specified");
else
logmsg = cvs_logmsg_create(NULL, NULL, NULL, NULL);
}
if (current_cvsroot->cr_method != CVS_METHOD_LOCAL) {
cvs_client_connect_to_server();
cvs_client_send_request("Argument -b%s", IMPORT_DEFAULT_BRANCH);
if (kflag)
cvs_client_send_request("Argument -k%s", koptstr);
cvs_client_send_logmsg(logmsg);
cvs_client_send_request("Argument %s", import_repository);
cvs_client_send_request("Argument %s", vendor_tag);
for (i = 0; i < tagcount; i++)
cvs_client_send_request("Argument %s", release_tags[i]);
cr.enterdir = NULL;
cr.leavedir = NULL;
cr.fileproc = cvs_client_sendfile;
cr.flags = CR_RECURSE_DIRS;
cvs_file_run(1, &arg, &cr);
cvs_client_senddir(".");
cvs_client_send_request("import");
cvs_client_get_responses();
return (0);
}
if (cvs_logmsg_verify(logmsg))
return (0);
(void)xsnprintf(repo, sizeof(repo), "%s/%s",
current_cvsroot->cr_dir, import_repository);
import_loginfo(import_repository);
if (cvs_noexec != 1)
cvs_mkdir(repo, 0755);
cr.enterdir = NULL;
cr.leavedir = NULL;
cr.fileproc = cvs_import_local;
cr.flags = CR_RECURSE_DIRS;
cvs_file_run(1, &arg, &cr);
if (import_conflicts != 0) {
import_printf("\n%d conflicts created by this import.\n\n",
import_conflicts);
import_printf("Use the following command to help the merge:\n");
import_printf("\topencvs checkout ");
import_printf("-j%s:yesterday -j%s %s\n\n", vendor_tag,
vendor_tag, import_repository);
} else {
import_printf("\nNo conflicts created by this import.\n\n");
}
loginfo = buf_release(logbuf);
logbuf = NULL;
line_list = cvs_trigger_getlines(CVS_PATH_LOGINFO, import_repository);
if (line_list != NULL) {
cvs_trigger_handle(CVS_TRIGGER_LOGINFO, import_repository,
loginfo, line_list, NULL);
cvs_trigger_freelist(line_list);
}
xfree(loginfo);
return (0);
}
int
rcsclean_main(int argc, char **argv)
{
int i, ch;
char *rev_str;
DIR *dirp;
struct dirent *dp;
rev_str = NULL;
while ((ch = rcs_getopt(argc, argv, "k:n::q::r::Tu::Vx::")) != -1) {
switch (ch) {
case 'k':
kflag = rcs_kflag_get(rcs_optarg);
if (RCS_KWEXP_INVAL(kflag)) {
warnx("invalid RCS keyword substitution mode");
(usage)();
}
break;
case 'n':
rcs_setrevstr(&rev_str, rcs_optarg);
nflag = 1;
break;
case 'q':
rcs_setrevstr(&rev_str, rcs_optarg);
flags |= QUIET;
break;
case 'r':
rcs_setrevstr(&rev_str, rcs_optarg);
break;
case 'T':
flags |= PRESERVETIME;
break;
case 'u':
rcs_setrevstr(&rev_str, rcs_optarg);
uflag = 1;
break;
case 'V':
printf("%s\n", rcs_version);
exit(0);
case 'x':
/* Use blank extension if none given. */
rcs_suffixes = rcs_optarg ? rcs_optarg : "";
break;
default:
(usage)();
}
}
argc -= rcs_optind;
argv += rcs_optind;
if ((locker = getlogin()) == NULL)
err(1, "getlogin");
if (argc == 0) {
if ((dirp = opendir(".")) == NULL) {
warn("opendir");
(usage)();
}
while ((dp = readdir(dirp)) != NULL) {
if (dp->d_type == DT_DIR)
continue;
rcsclean_file(dp->d_name, rev_str);
}
(void)closedir(dirp);
} else
for (i = 0; i < argc; i++)
rcsclean_file(argv[i], rev_str);
return (0);
}
int
rcsmerge_main(int argc, char **argv)
{
int fd, ch, flags, kflag, status;
char fpath[PATH_MAX], r1[RCS_REV_BUFSZ], r2[RCS_REV_BUFSZ];
char *rev_str1, *rev_str2;
RCSFILE *file;
RCSNUM *rev1, *rev2;
BUF *bp;
flags = 0;
status = D_ERROR;
rev1 = rev2 = NULL;
rev_str1 = rev_str2 = NULL;
while ((ch = rcs_getopt(argc, argv, "AEek:p::q::r::TVx::z:")) != -1) {
switch (ch) {
case 'A':
/*
* kept for compatibility
*/
break;
case 'E':
flags |= MERGE_EFLAG;
flags |= MERGE_OFLAG;
break;
case 'e':
flags |= MERGE_EFLAG;
break;
case 'k':
kflag = rcs_kflag_get(rcs_optarg);
if (RCS_KWEXP_INVAL(kflag)) {
warnx("invalid RCS keyword substitution mode");
(usage)();
}
break;
case 'p':
rcs_setrevstr2(&rev_str1, &rev_str2, rcs_optarg);
flags |= PIPEOUT;
break;
case 'q':
rcs_setrevstr2(&rev_str1, &rev_str2, rcs_optarg);
flags |= QUIET;
break;
case 'r':
rcs_setrevstr2(&rev_str1, &rev_str2,
rcs_optarg ? rcs_optarg : "");
break;
case 'T':
/*
* kept for compatibility
*/
break;
case 'V':
printf("%s\n", rcs_version);
exit(0);
case 'x':
/* Use blank extension if none given. */
rcs_suffixes = rcs_optarg ? rcs_optarg : "";
break;
case 'z':
timezone_flag = rcs_optarg;
break;
default:
(usage)();
}
}
argc -= rcs_optind;
argv += rcs_optind;
if (rev_str1 == NULL) {
warnx("no base revision number given");
(usage)();
}
if (argc < 1) {
warnx("no input file");
(usage)();
}
if (argc > 2 || (argc == 2 && argv[1] != NULL))
warnx("warning: excess arguments ignored");
if ((fd = rcs_choosefile(argv[0], fpath, sizeof(fpath))) < 0)
err(status, "%s", fpath);
if (!(flags & QUIET))
(void)fprintf(stderr, "RCS file: %s\n", fpath);
if ((file = rcs_open(fpath, fd, RCS_READ)) == NULL)
return (status);
if (strcmp(rev_str1, "") == 0) {
rev1 = rcsnum_alloc();
rcsnum_cpy(file->rf_head, rev1, 0);
} else if ((rev1 = rcs_getrevnum(rev_str1, file)) == NULL)
errx(D_ERROR, "invalid revision: %s", rev_str1);
if (rev_str2 != NULL && strcmp(rev_str2, "") != 0) {
if ((rev2 = rcs_getrevnum(rev_str2, file)) == NULL)
errx(D_ERROR, "invalid revision: %s", rev_str2);
} else {
rev2 = rcsnum_alloc();
rcsnum_cpy(file->rf_head, rev2, 0);
}
if (rcsnum_cmp(rev1, rev2, 0) == 0)
goto out;
if ((bp = rcs_diff3(file, argv[0], rev1, rev2, flags)) == NULL)
errx(D_ERROR, "failed to merge");
if (!(flags & QUIET)) {
(void)rcsnum_tostr(rev1, r1, sizeof(r1));
(void)rcsnum_tostr(rev2, r2, sizeof(r2));
(void)fprintf(stderr, "Merging differences between %s and "
"%s into %s%s\n", r1, r2, argv[0],
(flags & PIPEOUT) ? "; result to stdout":"");
}
if (diff3_conflicts != 0)
status = D_OVERLAPS;
else
status = 0;
if (flags & PIPEOUT)
buf_write_fd(bp, STDOUT_FILENO);
else {
/* XXX mode */
if (buf_write(bp, argv[0], 0644) < 0)
warnx("buf_write failed");
}
buf_free(bp);
out:
rcs_close(file);
rcsnum_free(rev1);
rcsnum_free(rev2);
return (status);
}
int
cvs_add(int argc, char **argv)
{
int ch;
int flags;
struct cvs_recursion cr;
flags = CR_REPO;
while ((ch = getopt(argc, argv, cvs_cmd_add.cmd_opts)) != -1) {
switch (ch) {
case 'k':
kflag = rcs_kflag_get(optarg);
if (RCS_KWEXP_INVAL(kflag)) {
cvs_log(LP_ERR,
"invalid RCS keyword expansion mode");
fatal("%s", cvs_cmd_add.cmd_synopsis);
}
(void)xsnprintf(kbuf, sizeof(kbuf), "-k%s", optarg);
break;
case 'm':
logmsg = optarg;
break;
default:
fatal("%s", cvs_cmd_add.cmd_synopsis);
}
}
argc -= optind;
argv += optind;
if (argc == 0)
fatal("%s", cvs_cmd_add.cmd_synopsis);
cr.enterdir = NULL;
cr.leavedir = NULL;
if (current_cvsroot->cr_method != CVS_METHOD_LOCAL) {
cvs_client_connect_to_server();
cr.fileproc = cvs_add_remote;
flags = 0;
if (kflag)
cvs_client_send_request("Argument %s", kbuf);
if (logmsg != NULL)
cvs_client_send_logmsg(logmsg);
} else {
if (logmsg != NULL && cvs_logmsg_verify(logmsg))
return (0);
cr.fileproc = cvs_add_local;
}
cr.flags = flags;
cvs_file_run(argc, argv, &cr);
if (added_files != 0) {
cvs_log(LP_NOTICE, "use '%s commit' to add %s "
"permanently", __progname,
(added_files == 1) ? "this file" : "these files");
}
if (current_cvsroot->cr_method != CVS_METHOD_LOCAL) {
cvs_client_senddir(".");
cvs_client_send_files(argv, argc);
cvs_client_send_request("add");
cvs_client_get_responses();
if (server_response == SERVER_OK) {
cr.fileproc = cvs_add_entry;
cvs_file_run(argc, argv, &cr);
}
}
return (0);
}
int
cvs_diff(int argc, char **argv)
{
int ch, flags;
char *arg = ".";
const char *errstr;
struct cvs_recursion cr;
flags = CR_RECURSE_DIRS;
strlcpy(diffargs, cvs_cmdop == CVS_OP_DIFF ? "diff" : "rdiff",
sizeof(diffargs));
while ((ch = getopt(argc, argv, cvs_cmdop == CVS_OP_DIFF ?
cvs_cmd_diff.cmd_opts : cvs_cmd_rdiff.cmd_opts)) != -1) {
switch (ch) {
case 'a':
strlcat(diffargs, " -a", sizeof(diffargs));
dflags |= D_FORCEASCII;
break;
case 'b':
strlcat(diffargs, " -b", sizeof(diffargs));
dflags |= D_FOLDBLANKS;
break;
case 'c':
strlcat(diffargs, " -c", sizeof(diffargs));
diff_format = D_CONTEXT;
break;
case 'C':
diff_context = strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL)
fatal("context lines %s: %s", errstr, optarg);
strlcat(diffargs, " -C ", sizeof(diffargs));
strlcat(diffargs, optarg, sizeof(diffargs));
diff_format = D_CONTEXT;
break;
case 'd':
strlcat(diffargs, " -d", sizeof(diffargs));
dflags |= D_MINIMAL;
break;
case 'D':
if (date1 == -1 && rev1 == NULL) {
if ((date1 = date_parse(optarg)) == -1)
fatal("invalid date: %s", optarg);
dateflag1 = optarg;
} else if (date2 == -1 && rev2 == NULL) {
if ((date2 = date_parse(optarg)) == -1)
fatal("invalid date: %s", optarg);
dateflag2 = optarg;
} else {
fatal("no more than 2 revisions/dates can"
" be specified");
}
break;
case 'f':
force_head = 1;
break;
case 'i':
strlcat(diffargs, " -i", sizeof(diffargs));
dflags |= D_IGNORECASE;
break;
case 'k':
koptstr = optarg;
kflag = rcs_kflag_get(koptstr);
if (RCS_KWEXP_INVAL(kflag)) {
cvs_log(LP_ERR,
"invalid RCS keyword expansion mode");
fatal("%s", cvs_cmdop == CVS_OP_DIFF ?
cvs_cmd_diff.cmd_synopsis :
cvs_cmd_rdiff.cmd_synopsis);
}
break;
case 'l':
flags &= ~CR_RECURSE_DIRS;
break;
case 'n':
strlcat(diffargs, " -n", sizeof(diffargs));
diff_format = D_RCSDIFF;
break;
case 'N':
strlcat(diffargs, " -N", sizeof(diffargs));
Nflag = 1;
break;
case 'p':
strlcat(diffargs, " -p", sizeof(diffargs));
dflags |= D_PROTOTYPE;
break;
case 'R':
flags |= CR_RECURSE_DIRS;
break;
case 'r':
if (date1 == -1 && rev1 == NULL) {
rev1 = optarg;
} else if (date2 == -1 && rev2 == NULL) {
rev2 = optarg;
} else {
fatal("no more than 2 revisions/dates can"
" be specified");
}
break;
case 't':
strlcat(diffargs, " -t", sizeof(diffargs));
dflags |= D_EXPANDTABS;
break;
case 'u':
strlcat(diffargs, " -u", sizeof(diffargs));
diff_format = D_UNIFIED;
break;
case 'U':
diff_context = strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL)
fatal("context lines %s: %s", errstr, optarg);
strlcat(diffargs, " -U ", sizeof(diffargs));
strlcat(diffargs, optarg, sizeof(diffargs));
diff_format = D_UNIFIED;
break;
case 'V':
fatal("the -V option is obsolete "
"and should not be used");
case 'w':
strlcat(diffargs, " -w", sizeof(diffargs));
dflags |= D_IGNOREBLANKS;
break;
default:
fatal("%s", cvs_cmdop == CVS_OP_DIFF ?
cvs_cmd_diff.cmd_synopsis :
cvs_cmd_rdiff.cmd_synopsis);
}
}
argc -= optind;
argv += optind;
cr.enterdir = NULL;
cr.leavedir = NULL;
if (cvs_cmdop == CVS_OP_RDIFF) {
if (rev1 == NULL && rev2 == NULL && dateflag1 == NULL &&
dateflag2 == NULL)
fatal("must specify at least one revision/date!");
if (!argc)
fatal("%s", cvs_cmd_rdiff.cmd_synopsis);
if (!diff_format) {
strlcat(diffargs, " -c", sizeof(diffargs));
diff_format = D_CONTEXT;
}
flags |= CR_REPO;
}
if (current_cvsroot->cr_method != CVS_METHOD_LOCAL) {
cvs_client_connect_to_server();
cr.fileproc = cvs_client_sendfile;
if (!(flags & CR_RECURSE_DIRS))
cvs_client_send_request("Argument -l");
if (kflag)
cvs_client_send_request("Argument -k%s", koptstr);
switch (diff_format) {
case D_CONTEXT:
if (cvs_cmdop == CVS_OP_RDIFF)
cvs_client_send_request("Argument -c");
else {
cvs_client_send_request("Argument -C %d",
diff_context);
}
break;
case D_RCSDIFF:
cvs_client_send_request("Argument -n");
break;
case D_UNIFIED:
if (cvs_cmdop == CVS_OP_RDIFF || diff_context == 3)
cvs_client_send_request("Argument -u");
else {
cvs_client_send_request("Argument -U %d",
diff_context);
}
break;
default:
break;
}
if (Nflag == 1)
cvs_client_send_request("Argument -N");
if (dflags & D_PROTOTYPE)
cvs_client_send_request("Argument -p");
if (rev1 != NULL)
cvs_client_send_request("Argument -r%s", rev1);
if (rev2 != NULL)
cvs_client_send_request("Argument -r%s", rev2);
if (dateflag1 != NULL)
cvs_client_send_request("Argument -D%s", dateflag1);
if (dateflag2 != NULL)
cvs_client_send_request("Argument -D%s", dateflag2);
} else {
if (cvs_cmdop == CVS_OP_RDIFF &&
chdir(current_cvsroot->cr_dir) == -1)
fatal("cvs_diff: %s", strerror(errno));
cr.fileproc = cvs_diff_local;
}
cr.flags = flags;
diff_rev1 = diff_rev2 = NULL;
if (cvs_cmdop == CVS_OP_DIFF ||
current_cvsroot->cr_method == CVS_METHOD_LOCAL) {
if (argc > 0)
cvs_file_run(argc, argv, &cr);
else
cvs_file_run(1, &arg, &cr);
}
if (current_cvsroot->cr_method != CVS_METHOD_LOCAL) {
cvs_client_send_files(argv, argc);
cvs_client_senddir(".");
cvs_client_send_request((cvs_cmdop == CVS_OP_RDIFF) ?
"rdiff" : "diff");
cvs_client_get_responses();
}
return (0);
}