/* * 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 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 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 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); }