int
cvs_watchers(int argc, char **argv)
{
int ch;
int flags;
struct cvs_recursion cr;
flags = CR_RECURSE_DIRS;
while ((ch = getopt(argc, argv, cvs_cmd_watchers.cmd_opts)) != -1) {
switch (ch) {
case 'l':
flags &= ~CR_RECURSE_DIRS;
break;
case 'R':
flags |= CR_RECURSE_DIRS;
break;
default:
fatal("%s", cvs_cmd_watchers.cmd_synopsis);
}
}
argc -= optind;
argv += optind;
if (argc == 0)
fatal("%s", cvs_cmd_watchers.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 (!(flags & CR_RECURSE_DIRS))
cvs_client_send_request("Argument -l");
} else {
cr.fileproc = cvs_watchers_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("watchers");
cvs_client_get_responses();
}
return (0);
}
void
cvs_add_remote(struct cvs_file *cf)
{
char path[MAXPATHLEN];
cvs_log(LP_TRACE, "cvs_add_remote(%s)", cf->file_path);
cvs_file_classify(cf, cvs_directory_tag);
if (cf->file_type == CVS_DIR) {
cvs_get_repository_path(cf->file_wd, path, MAXPATHLEN);
if (strlcat(path, "/", sizeof(path)) >= sizeof(path))
fatal("cvs_add_remote: truncation");
if (strlcat(path, cf->file_path, sizeof(path)) >= sizeof(path))
fatal("cvs_add_remote: truncation");
cvs_client_send_request("Directory %s\n%s", cf->file_path,
path);
add_directory(cf);
} else {
cvs_client_sendfile(cf);
}
}
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
cvs_annotate(int argc, char **argv)
{
int ch, flags;
char *arg = ".";
struct cvs_recursion cr;
flags = CR_RECURSE_DIRS;
while ((ch = getopt(argc, argv, cvs_cmdop == CVS_OP_ANNOTATE ?
cvs_cmd_annotate.cmd_opts : cvs_cmd_rannotate.cmd_opts)) != -1) {
switch (ch) {
case 'D':
dateflag = optarg;
if ((cvs_specified_date = date_parse(dateflag)) == -1)
fatal("invalid date: %s", dateflag);
break;
case 'f':
force_head = 1;
break;
case 'l':
flags &= ~CR_RECURSE_DIRS;
break;
case 'R':
flags |= CR_RECURSE_DIRS;
break;
case 'r':
cvs_specified_tag = optarg;
break;
default:
fatal("%s", cvs_cmdop == CVS_OP_ANNOTATE ?
cvs_cmd_annotate.cmd_synopsis :
cvs_cmd_rannotate.cmd_synopsis);
}
}
argc -= optind;
argv += optind;
if (cvs_cmdop == CVS_OP_RANNOTATE) {
if (argc == 0)
fatal("%s", cvs_cmd_rannotate.cmd_synopsis);
flags |= CR_REPO;
}
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 (dateflag != NULL)
cvs_client_send_request("Argument -D%s", dateflag);
if (force_head == 1)
cvs_client_send_request("Argument -f");
if (!(flags & CR_RECURSE_DIRS))
cvs_client_send_request("Argument -l");
if (cvs_specified_tag != NULL)
cvs_client_send_request("Argument -r%s",
cvs_specified_tag);
} else {
if (cvs_cmdop == CVS_OP_RANNOTATE &&
chdir(current_cvsroot->cr_dir) == -1)
fatal("cvs_annotate: %s", strerror(errno));
cr.fileproc = cvs_annotate_local;
}
cr.flags = flags;
if (cvs_cmdop == CVS_OP_ANNOTATE ||
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_RANNOTATE) ?
"rannotate" : "annotate");
cvs_client_get_responses();
}
return (0);
}
int
cvs_watch(int argc, char **argv)
{
int ch, flags;
struct cvs_recursion cr;
int watch_req = 0;
int watch_aflags = 0;
if (argc < 2)
fatal("%s", cvs_cmd_watch.cmd_synopsis);
if (strcmp(argv[1], "on") == 0)
watch_req |= W_ON;
else if (strcmp(argv[1], "off") == 0)
watch_req |= W_OFF;
else if (strcmp(argv[1], "add") == 0)
watch_req |= W_ADD;
else if (strcmp(argv[1], "remove") == 0)
watch_req |= W_REMOVE;
else
fatal("%s", cvs_cmd_watch.cmd_synopsis);
--argc;
++argv;
flags = CR_RECURSE_DIRS;
while ((ch = getopt(argc, argv, cvs_cmd_watch.cmd_opts)) != -1) {
switch (ch) {
case 'a':
if (!(watch_req & (W_ADD|W_REMOVE)))
fatal("%s", cvs_cmd_watch.cmd_synopsis);
if (strcmp(optarg, "edit") == 0)
watch_aflags |= W_EDIT;
else if (strcmp(optarg, "unedit") == 0)
watch_aflags |= W_UNEDIT;
else if (strcmp(optarg, "commit") == 0)
watch_aflags |= W_COMMIT;
else if (strcmp(optarg, "all") == 0)
watch_aflags |= W_ALL;
else if (strcmp(optarg, "none") == 0)
watch_aflags &= ~W_ALL;
else
fatal("%s", cvs_cmd_watch.cmd_synopsis);
break;
case 'l':
flags &= ~CR_RECURSE_DIRS;
break;
case 'R':
flags |= CR_RECURSE_DIRS;
break;
default:
fatal("%s", cvs_cmd_watch.cmd_synopsis);
}
}
argc -= optind;
argv += optind;
if (watch_aflags == 0)
watch_aflags |= W_ALL;
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 (watch_req & (W_ADD|W_REMOVE)) {
if (watch_aflags & W_EDIT)
cvs_client_send_request("Argument -a edit");
if (watch_aflags & W_UNEDIT)
cvs_client_send_request("Argument -a unedit");
if (watch_aflags & W_COMMIT)
cvs_client_send_request("Argument -a commit");
if (!(watch_aflags & W_ALL))
cvs_client_send_request("Argument -a none");
}
if (!(flags & CR_RECURSE_DIRS))
cvs_client_send_request("Argument -l");
} else {
cr.fileproc = cvs_watch_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(".");
if (watch_req & (W_ADD|W_REMOVE))
cvs_client_send_request("watch-%s",
(watch_req & W_ADD) ? "add" : "remove");
else
cvs_client_send_request("watch-%s",
(watch_req & W_ON) ? "on" : "off");
cvs_client_get_responses();
}
return (0);
}
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);
}
