void cvs_server_unchanged(char *data) { char fpath[MAXPATHLEN]; CVSENTRIES *entlist; struct cvs_ent *ent; char sticky[CVS_ENT_MAXLINELEN]; char rev[CVS_REV_BUFSZ], entry[CVS_ENT_MAXLINELEN]; if (data == NULL) fatal("Missing argument for Unchanged"); /* sorry, we have to use TMP_DIR */ disable_fast_checkout = 1; (void)xsnprintf(fpath, MAXPATHLEN, "%s/%s", server_currentdir, data); entlist = cvs_ent_open(server_currentdir); ent = cvs_ent_get(entlist, data); if (ent == NULL) fatal("received Unchanged request for non-existing file"); sticky[0] = '\0'; if (ent->ce_tag != NULL) (void)xsnprintf(sticky, sizeof(sticky), "T%s", ent->ce_tag); rcsnum_tostr(ent->ce_rev, rev, sizeof(rev)); (void)xsnprintf(entry, sizeof(entry), "/%s/%s/%s/%s/%s", ent->ce_name, rev, CVS_SERVER_UNCHANGED, ent->ce_opts ? ent->ce_opts : "", sticky); cvs_ent_free(ent); cvs_ent_add(entlist, entry); }
static void rcs_attach_symbol(RCSFILE *file, const char *symname) { char *rnum; RCSNUM *rev; char rbuf[RCS_REV_BUFSZ]; int rm; rm = 0; rev = NULL; if ((rnum = strrchr(symname, ':')) != NULL) { if (rnum[1] == '\0') rev = file->rf_head; *(rnum++) = '\0'; } else { rm = 1; } if (rev == NULL && rm != 1) { if ((rev = rcsnum_parse(rnum)) == NULL) errx(1, "bad revision %s", rnum); } if (rcsflags & RCSPROG_NFLAG) rm = 1; if (rm == 1) { if (rcs_sym_remove(file, symname) < 0) { if (rcs_errno == RCS_ERR_NOENT && !(rcsflags & RCSPROG_NFLAG)) warnx("cannot delete nonexisting symbol %s", symname); } else { if (rcsflags & RCSPROG_NFLAG) rm = 0; } } if (rm == 0) { if (rcs_sym_add(file, symname, rev) < 0 && rcs_errno == RCS_ERR_DUPENT) { rcsnum_tostr(rcs_sym_getrev(file, symname), rbuf, sizeof(rbuf)); errx(1, "symbolic name %s already bound to %s", symname, rbuf); } } }
/* * 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); }
void cvs_admin_local(struct cvs_file *cf) { int i; RCSNUM *rev; cvs_log(LP_TRACE, "cvs_admin_local(%s)", cf->file_path); cvs_file_classify(cf, cvs_directory_tag); if (cf->file_type == CVS_DIR) { if (verbosity > 1) cvs_log(LP_NOTICE, "Administrating %s", cf->file_name); return; } if (cf->file_ent == NULL) return; else if (cf->file_status == FILE_ADDED) { cvs_log(LP_ERR, "cannot admin newly added file `%s'", cf->file_name); return; } if (cf->file_rcs == NULL) { cvs_log(LP_ERR, "lost RCS file for `%s'", cf->file_path); return; } if (verbosity > 0) cvs_printf("RCS file: %s\n", cf->file_rcs->rf_path); if (oldfilename != NULL) { struct cvs_file *ocf; struct rcs_access *acp; int ofd; char *d, *f, fpath[MAXPATHLEN], repo[MAXPATHLEN]; if ((f = basename(oldfilename)) == NULL) fatal("cvs_admin_local: basename failed"); if ((d = dirname(oldfilename)) == NULL) fatal("cvs_admin_local: dirname failed"); cvs_get_repository_path(d, repo, MAXPATHLEN); (void)xsnprintf(fpath, MAXPATHLEN, "%s/%s", repo, f); if (strlcat(fpath, RCS_FILE_EXT, MAXPATHLEN) >= MAXPATHLEN) fatal("cvs_admin_local: truncation"); if ((ofd = open(fpath, O_RDONLY)) == -1) fatal("cvs_admin_local: open: `%s': %s", fpath, strerror(errno)); /* XXX: S_ISREG() check instead of blindly using CVS_FILE? */ ocf = cvs_file_get_cf(d, f, oldfilename, ofd, CVS_FILE, 0); ocf->file_rcs = rcs_open(fpath, ofd, RCS_READ, 0444); if (ocf->file_rcs == NULL) fatal("cvs_admin_local: rcs_open failed"); TAILQ_FOREACH(acp, &(ocf->file_rcs->rf_access), ra_list) rcs_access_add(cf->file_rcs, acp->ra_name); cvs_file_free(ocf); } if (alist != NULL) { struct cvs_argvector *aargv; aargv = cvs_strsplit(alist, ","); for (i = 0; aargv->argv[i] != NULL; i++) rcs_access_add(cf->file_rcs, aargv->argv[i]); cvs_argv_destroy(aargv); } if (comment != NULL) rcs_comment_set(cf->file_rcs, comment); if (elist != NULL) { struct cvs_argvector *eargv; eargv = cvs_strsplit(elist, ","); for (i = 0; eargv->argv[i] != NULL; i++) rcs_access_remove(cf->file_rcs, eargv->argv[i]); cvs_argv_destroy(eargv); } else if (runflags & ADM_EFLAG) { struct rcs_access *rap; while (!TAILQ_EMPTY(&(cf->file_rcs->rf_access))) { rap = TAILQ_FIRST(&(cf->file_rcs->rf_access)); TAILQ_REMOVE(&(cf->file_rcs->rf_access), rap, ra_list); xfree(rap->ra_name); xfree(rap); } /* no synced anymore */ cf->file_rcs->rf_flags &= ~RCS_SYNCED; } /* Default `-kv' is accepted here. */ if (kflag) { if (cf->file_rcs->rf_expand == NULL || strcmp(cf->file_rcs->rf_expand, koptstr) != 0) rcs_kwexp_set(cf->file_rcs, kflag); } if (logstr != NULL) { if ((logmsg = strchr(logstr, ':')) == NULL) { cvs_log(LP_ERR, "missing log message"); return; } *logmsg++ = '\0'; if ((rev = rcsnum_parse(logstr)) == NULL) { cvs_log(LP_ERR, "`%s' bad revision number", logstr); return; } if (rcs_rev_setlog(cf->file_rcs, rev, logmsg) < 0) { cvs_log(LP_ERR, "failed to set logmsg for `%s' to `%s'", logstr, logmsg); rcsnum_free(rev); return; } rcsnum_free(rev); } if (orange != NULL) { struct rcs_delta *rdp, *nrdp; char b[CVS_REV_BUFSZ]; cvs_revision_select(cf->file_rcs, orange); for (rdp = TAILQ_FIRST(&(cf->file_rcs->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 (verbosity > 0) cvs_printf("deleting revision %s\n", b); (void)rcs_rev_remove(cf->file_rcs, rdp->rd_num); } } } if (state != NULL) { if (staterevstr != NULL) { if ((rev = rcsnum_parse(staterevstr)) == NULL) { cvs_log(LP_ERR, "`%s' bad revision number", staterevstr); return; } } else if (cf->file_rcs->rf_head != NULL) { rev = rcsnum_alloc(); rcsnum_cpy(cf->file_rcs->rf_head, rev, 0); } else { cvs_log(LP_ERR, "head revision missing"); return; } (void)rcs_state_set(cf->file_rcs, rev, state); rcsnum_free(rev); } if (lkmode != RCS_LOCK_INVAL) (void)rcs_lock_setmode(cf->file_rcs, lkmode); rcs_write(cf->file_rcs); if (verbosity > 0) cvs_printf("done\n"); }
static int rcsdiff_rev(RCSFILE *file, RCSNUM *rev1, RCSNUM *rev2, int dflags) { struct timeval tv[2], tv2[2]; BUF *b1, *b2; int ret; char *path1, *path2, rbuf1[RCS_REV_BUFSZ], rbuf2[RCS_REV_BUFSZ]; ret = D_ERROR; b1 = b2 = NULL; memset(&tv, 0, sizeof(tv)); memset(&tv2, 0, sizeof(tv2)); diff_rev1 = rev1; diff_rev2 = rev2; path1 = path2 = NULL; rcsnum_tostr(rev1, rbuf1, sizeof(rbuf1)); if (!quiet) fprintf(stderr, "retrieving revision %s\n", rbuf1); if ((b1 = rcs_getrev(file, rev1)) == NULL) { warnx("failed to retrieve revision %s", rbuf1); goto out; } b1 = rcs_kwexp_buf(b1, file, rev1); tv[0].tv_sec = (long)rcs_rev_getdate(file, rev1); tv[1].tv_sec = tv[0].tv_sec; rcsnum_tostr(rev2, rbuf2, sizeof(rbuf2)); if (!quiet) fprintf(stderr, "retrieving revision %s\n", rbuf2); if ((b2 = rcs_getrev(file, rev2)) == NULL) { warnx("failed to retrieve revision %s", rbuf2); goto out; } b2 = rcs_kwexp_buf(b2, file, rev2); tv2[0].tv_sec = (long)rcs_rev_getdate(file, rev2); tv2[1].tv_sec = tv2[0].tv_sec; if (!quiet) fprintf(stderr, "%s -r%s -r%s\n", diffargs, rbuf1, rbuf2); (void)xasprintf(&path1, "%s/diff1.XXXXXXXXXX", rcs_tmpdir); buf_write_stmp(b1, path1); buf_free(b1); b1 = NULL; if (utimes(path1, (const struct timeval *)&tv) < 0) warn("utimes"); (void)xasprintf(&path2, "%s/diff2.XXXXXXXXXX", rcs_tmpdir); buf_write_stmp(b2, path2); buf_free(b2); b2 = NULL; if (utimes(path2, (const struct timeval *)&tv2) < 0) warn("utimes"); ret = diffreg(path1, path2, NULL, dflags); out: if (b1 != NULL) buf_free(b1); if (b2 != NULL) buf_free(b2); if (path1 != NULL) xfree(path1); if (path2 != NULL) xfree(path2); return (ret); }
static int rcsdiff_file(RCSFILE *file, RCSNUM *rev, const char *filename, int dflags) { int ret, fd; time_t t; struct stat st; char *path1, *path2; BUF *b1, *b2; char rbuf[RCS_REV_BUFSZ]; struct tm *tb; struct timeval tv[2], tv2[2]; memset(&tv, 0, sizeof(tv)); memset(&tv2, 0, sizeof(tv2)); ret = D_ERROR; b1 = b2 = NULL; diff_rev1 = rev; diff_rev2 = NULL; path1 = path2 = NULL; if ((fd = open(filename, O_RDONLY)) == -1) { warn("%s", filename); goto out; } rcsnum_tostr(rev, rbuf, sizeof(rbuf)); if (!quiet) { fprintf(stderr, "retrieving revision %s\n", rbuf); fprintf(stderr, "%s -r%s %s\n", diffargs, rbuf, filename); } if ((b1 = rcs_getrev(file, rev)) == NULL) { warnx("failed to retrieve revision %s", rbuf); goto out; } b1 = rcs_kwexp_buf(b1, file, rev); tv[0].tv_sec = (long)rcs_rev_getdate(file, rev); tv[1].tv_sec = tv[0].tv_sec; if ((b2 = buf_load(filename)) == NULL) { warnx("failed to load file: `%s'", filename); goto out; } /* XXX - GNU uses GMT */ if (fstat(fd, &st) == -1) err(D_ERROR, "%s", filename); tb = gmtime(&st.st_mtime); t = mktime(tb); tv2[0].tv_sec = t; tv2[1].tv_sec = t; (void)xasprintf(&path1, "%s/diff1.XXXXXXXXXX", rcs_tmpdir); buf_write_stmp(b1, path1); buf_free(b1); b1 = NULL; if (utimes(path1, (const struct timeval *)&tv) < 0) warn("utimes"); (void)xasprintf(&path2, "%s/diff2.XXXXXXXXXX", rcs_tmpdir); buf_write_stmp(b2, path2); buf_free(b2); b2 = NULL; if (utimes(path2, (const struct timeval *)&tv2) < 0) warn("utimes"); ret = diffreg(path1, path2, NULL, dflags); out: if (fd != -1) (void)close(fd); if (b1 != NULL) buf_free(b1); if (b2 != NULL) buf_free(b2); if (path1 != NULL) xfree(path1); if (path2 != NULL) xfree(path2); return (ret); }
static void import_update(struct cvs_file *cf) { int ret; BUF *b1, *b2, *d; char branch[CVS_REV_BUFSZ]; RCSNUM *newrev, *rev, *brev; cvs_log(LP_TRACE, "import_update(%s)", cf->file_path); if (cf->file_rcs->rf_head == NULL) fatal("no head revision in RCS file for `%s'", cf->file_path); if ((rev = rcs_translate_tag(import_branch, cf->file_rcs)) == NULL) fatal("import_update: could not translate tag `%s'", import_branch); if ((brev = rcsnum_parse(import_branch)) == NULL) fatal("import_update: rcsnum_parse failed"); b1 = rcs_rev_getbuf(cf->file_rcs, rev, RCS_KWEXP_NONE); b2 = buf_load_fd(cf->fd); ret = buf_differ(b1, b2); buf_free(b1); buf_free(b2); if (ret == 0) { import_tag(cf, brev, rev); rcsnum_free(brev); if (cvs_noexec != 1) rcs_write(cf->file_rcs); import_printf("U %s/%s\n", import_repository, cf->file_path); return; } if (cf->file_rcs->rf_branch != NULL) rcsnum_tostr(cf->file_rcs->rf_branch, branch, sizeof(branch)); if (cf->file_rcs->rf_branch == NULL || cf->in_attic == 1 || strcmp(branch, import_branch)) { import_conflicts++; import_printf("C %s/%s\n", import_repository, cf->file_path); } else { import_printf("U %s/%s\n", import_repository, cf->file_path); } if (cvs_noexec == 1) return; d = import_get_rcsdiff(cf, rev); newrev = rcsnum_inc(rev); if (rcs_rev_add(cf->file_rcs, newrev, logmsg, -1, NULL) == -1) fatal("import_update: failed to add new revision"); if (rcs_deltatext_set(cf->file_rcs, newrev, d) == -1) fatal("import_update: failed to set deltatext"); import_tag(cf, brev, newrev); if (kflag) rcs_kwexp_set(cf->file_rcs, kflag); rcsnum_free(brev); rcs_write(cf->file_rcs); }
static void rcsclean_file(char *fname, const char *rev_str) { int fd, match; RCSFILE *file; char fpath[PATH_MAX], numb[RCS_REV_BUFSZ]; RCSNUM *rev; BUF *b1, *b2; time_t rcs_mtime = -1; b1 = b2 = NULL; file = NULL; rev = NULL; if ((fd = rcs_choosefile(fname, fpath, sizeof(fpath))) < 0) goto out; if ((file = rcs_open(fpath, fd, RCS_RDWR)) == NULL) goto out; if (flags & PRESERVETIME) rcs_mtime = rcs_get_mtime(file); rcs_kwexp_set(file, kflag); if (rev_str == NULL) rev = file->rf_head; else if ((rev = rcs_getrevnum(rev_str, file)) == NULL) { warnx("%s: Symbolic name `%s' is undefined.", fpath, rev_str); goto out; } if ((b1 = rcs_getrev(file, rev)) == NULL) { warnx("failed to get needed revision"); goto out; } if ((b2 = buf_load(fname)) == NULL) { warnx("failed to load `%s'", fname); goto out; } /* If buffer lengths are the same, compare contents as well. */ if (buf_len(b1) != buf_len(b2)) match = 0; else { size_t len, n; len = buf_len(b1); match = 1; for (n = 0; n < len; ++n) if (buf_getc(b1, n) != buf_getc(b2, n)) { match = 0; break; } } if (match == 1) { if (uflag == 1 && !TAILQ_EMPTY(&(file->rf_locks))) { if (!(flags & QUIET) && nflag == 0) { printf("rcs -u%s %s\n", rcsnum_tostr(rev, numb, sizeof(numb)), fpath); } (void)rcs_lock_remove(file, locker, rev); } if (TAILQ_EMPTY(&(file->rf_locks))) { if (!(flags & QUIET)) printf("rm -f %s\n", fname); if (nflag == 0) (void)unlink(fname); } } rcs_write(file); if (flags & PRESERVETIME) rcs_set_mtime(file, rcs_mtime); out: if (b1 != NULL) buf_free(b1); if (b2 != NULL) buf_free(b2); if (file != NULL) rcs_close(file); }
void cvs_annotate_local(struct cvs_file *cf) { int i; char date[10], rnum[13], *p; RCSNUM *bnum, *rev; struct rcs_line *line; struct rcs_line **alines; cvs_log(LP_TRACE, "cvs_annotate_local(%s)", cf->file_path); cvs_file_classify(cf, cvs_directory_tag); if (cf->file_rcs == NULL || cf->file_rcs->rf_head == NULL) return; if (cvs_specified_tag != NULL) { if ((rev = rcs_translate_tag(cvs_specified_tag, cf->file_rcs)) == NULL) { if (!force_head) /* Stick at weird GNU cvs, ignore error. */ return; /* -f is not allowed for unknown symbols */ rev = rcsnum_parse(cvs_specified_tag); if (rev == NULL) fatal("no such tag %s", cvs_specified_tag); rcsnum_free(rev); rev = rcsnum_alloc(); rcsnum_cpy(cf->file_rcs->rf_head, rev, 0); } /* * If this is a revision in a branch, we have to go first * from HEAD to branch, then down to 1.1. After that, take * annotated branch and go up to branch revision. This must * be done this way due to different handling of "a" and * "d" in rcs file for annotation. */ if (!RCSNUM_ISBRANCHREV(rev)) { bnum = rev; } else { bnum = rcsnum_alloc(); rcsnum_cpy(rev, bnum, 2); } rcs_rev_getlines(cf->file_rcs, bnum, &alines); /* * Go into branch and receive annotations for branch revision, * with inverted "a" and "d" meaning. */ if (bnum != rev) { rcs_annotate_getlines(cf->file_rcs, rev, &alines); rcsnum_free(bnum); } rcsnum_free(rev); } else { rcs_rev_getlines(cf->file_rcs, (cvs_specified_date != -1 || cvs_directory_date != -1) ? cf->file_rcsrev : cf->file_rcs->rf_head, &alines); } /* Stick at weird GNU cvs, ignore error. */ if (alines == NULL) return; cvs_log(LP_RCS, "Annotations for %s", cf->file_path); cvs_log(LP_RCS, "***************"); for (i = 0; alines[i] != NULL; i++) { line = alines[i]; rcsnum_tostr(line->l_delta->rd_num, rnum, sizeof(rnum)); strftime(date, sizeof(date), "%d-%b-%y", &(line->l_delta->rd_date)); if (line->l_len && line->l_line[line->l_len - 1] == '\n') line->l_line[line->l_len - 1] = '\0'; else { p = xmalloc(line->l_len + 1); memcpy(p, line->l_line, line->l_len); p[line->l_len] = '\0'; if (line->l_needsfree) xfree(line->l_line); line->l_line = p; line->l_len++; line->l_needsfree = 1; } cvs_printf("%-12.12s (%-8.8s %s): %s\n", rnum, line->l_delta->rd_author, date, line->l_line); if (line->l_needsfree) xfree(line->l_line); xfree(line); } xfree(alines); }
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); }
static void add_entry(struct cvs_file *cf) { FILE *fp; char *entry, path[MAXPATHLEN]; char revbuf[CVS_REV_BUFSZ], tbuf[CVS_TIME_BUFSZ]; char sticky[CVS_ENT_MAXLINELEN]; CVSENTRIES *entlist; if (cvs_noexec == 1) return; sticky[0] = '\0'; entry = xmalloc(CVS_ENT_MAXLINELEN); if (cf->file_status == FILE_REMOVED) { rcsnum_tostr(cf->file_ent->ce_rev, revbuf, sizeof(revbuf)); ctime_r(&cf->file_ent->ce_mtime, tbuf); tbuf[strcspn(tbuf, "\n")] = '\0'; if (cf->file_ent->ce_tag != NULL) (void)xsnprintf(sticky, sizeof(sticky), "T%s", cf->file_ent->ce_tag); /* Remove the '-' prefixing the version number. */ cvs_ent_line_str(cf->file_name, revbuf, tbuf, cf->file_ent->ce_opts ? cf->file_ent->ce_opts : "", sticky, 0, 0, entry, CVS_ENT_MAXLINELEN); } else { if (logmsg != NULL) { (void)xsnprintf(path, MAXPATHLEN, "%s/%s/%s%s", cf->file_wd, CVS_PATH_CVSDIR, cf->file_name, CVS_DESCR_FILE_EXT); if ((fp = fopen(path, "w+")) == NULL) fatal("add_entry: fopen `%s': %s", path, strerror(errno)); if (fputs(logmsg, fp) == EOF) { (void)unlink(path); fatal("add_entry: fputs `%s': %s", path, strerror(errno)); } (void)fclose(fp); } if (cvs_directory_tag != NULL) (void)xsnprintf(sticky, sizeof(sticky), "T%s", cvs_directory_tag); tbuf[0] = '\0'; if (!cvs_server_active) (void)xsnprintf(tbuf, sizeof(tbuf), "Initial %s", cf->file_name); cvs_ent_line_str(cf->file_name, "0", tbuf, kflag ? kbuf : "", sticky, 0, 0, entry, CVS_ENT_MAXLINELEN); } if (cvs_server_active) { cvs_server_send_response("Checked-in %s/", cf->file_wd); cvs_server_send_response("%s", cf->file_path); cvs_server_send_response("%s", entry); } else { entlist = cvs_ent_open(cf->file_wd); cvs_ent_add(entlist, entry); } xfree(entry); }
static void add_file(struct cvs_file *cf) { int nb, stop; char revbuf[CVS_REV_BUFSZ]; RCSNUM *head = NULL; char *tag; cvs_parse_tagfile(cf->file_wd, &tag, NULL, &nb); if (nb) { cvs_log(LP_ERR, "cannot add file on non-branch tag %s", tag); return; } if (cf->file_rcs != NULL) { head = rcs_head_get(cf->file_rcs); if (head == NULL) { cvs_log(LP_NOTICE, "no head revision in RCS file for " "%s", cf->file_path); } rcsnum_tostr(head, revbuf, sizeof(revbuf)); } stop = 0; switch (cf->file_status) { case FILE_ADDED: case FILE_CHECKOUT: if (verbosity > 1) cvs_log(LP_NOTICE, "%s has already been entered", cf->file_path); stop = 1; break; case FILE_REMOVED: if (cf->file_rcs == NULL) { cvs_log(LP_NOTICE, "cannot resurrect %s; " "RCS file removed by second party", cf->file_name); } else if (!(cf->file_flags & FILE_ON_DISK)) { add_entry(cf); /* Restore the file. */ cvs_checkout_file(cf, head, NULL, 0); cvs_printf("U %s\n", cf->file_path); cvs_log(LP_NOTICE, "%s, version %s, resurrected", cf->file_name, revbuf); cf->file_status = FILE_UPTODATE; } stop = 1; break; case FILE_CONFLICT: case FILE_LOST: case FILE_MODIFIED: case FILE_UPTODATE: if (cf->file_rcs != NULL && cf->file_rcs->rf_dead == 0) { cvs_log(LP_NOTICE, "%s already exists, with version " "number %s", cf->file_path, revbuf); stop = 1; } break; case FILE_UNKNOWN: if (cf->file_rcs != NULL && cf->file_rcs->rf_dead == 1) { cvs_log(LP_NOTICE, "re-adding file %s " "(instead of dead revision %s)", cf->file_path, revbuf); added_files++; } else if (cf->file_flags & FILE_ON_DISK) { cvs_log(LP_NOTICE, "scheduling file '%s' for addition", cf->file_path); added_files++; } else { stop = 1; } break; default: break; } if (head != NULL) rcsnum_free(head); if (stop == 1) return; add_entry(cf); }
void cvs_history_add(int type, struct cvs_file *cf, const char *argument) { BUF *buf; FILE *fp; RCSNUM *hrev; size_t len; int fd; char *cwd, *p, *rev; char revbuf[CVS_REV_BUFSZ], repo[MAXPATHLEN], fpath[MAXPATHLEN]; char timebuf[CVS_TIME_BUFSZ]; struct tm datetm; if (cvs_nolog == 1) return; if (cvs_cmdop == CVS_OP_CHECKOUT || cvs_cmdop == CVS_OP_EXPORT) { if (type != CVS_HISTORY_CHECKOUT && type != CVS_HISTORY_EXPORT) return; } cvs_log(LP_TRACE, "cvs_history_add(`%c', `%s', `%s')", historytab[type], (cf != NULL) ? cf->file_name : "", argument); /* construct repository field */ if (cvs_cmdop != CVS_OP_CHECKOUT && cvs_cmdop != CVS_OP_EXPORT) { cvs_get_repository_name((cf != NULL) ? cf->file_wd : ".", repo, sizeof(repo)); } else { cvs_get_repository_name(argument, repo, sizeof(repo)); } if (cvs_server_active == 1) { cwd = "<remote>"; } else { if (getcwd(fpath, sizeof(fpath)) == NULL) fatal("cvs_history_add: getcwd: %s", strerror(errno)); p = fpath; if (cvs_cmdop == CVS_OP_CHECKOUT || cvs_cmdop == CVS_OP_EXPORT) { if (strlcat(fpath, "/", sizeof(fpath)) >= sizeof(fpath) || strlcat(fpath, argument, sizeof(fpath)) >= sizeof(fpath)) fatal("cvs_history_add: string truncation"); } if (cvs_homedir != NULL && cvs_homedir[0] != '\0') { len = strlen(cvs_homedir); if (strncmp(cvs_homedir, fpath, len) == 0 && fpath[len] == '/') { p += len - 1; *p = '~'; } } history_compress(p, repo); cwd = xstrdup(p); } /* construct revision field */ revbuf[0] = '\0'; rev = revbuf; switch (type) { case CVS_HISTORY_TAG: strlcpy(revbuf, argument, sizeof(revbuf)); break; case CVS_HISTORY_CHECKOUT: case CVS_HISTORY_EXPORT: /* * cvs_buf_alloc uses xcalloc(), so we are safe even * if neither cvs_specified_tag nor cvs_specified_date * have been supplied. */ buf = cvs_buf_alloc(128); if (cvs_specified_tag != NULL) { cvs_buf_puts(buf, cvs_specified_tag); if (cvs_specified_date != -1) cvs_buf_putc(buf, ':'); } if (cvs_specified_date != -1) { gmtime_r(&cvs_specified_date, &datetm); strftime(timebuf, sizeof(timebuf), "%Y.%m.%d.%H.%M.%S", &datetm); cvs_buf_puts(buf, timebuf); } rev = cvs_buf_release(buf); break; case CVS_HISTORY_UPDATE_MERGED: case CVS_HISTORY_UPDATE_MERGED_ERR: case CVS_HISTORY_COMMIT_MODIFIED: case CVS_HISTORY_COMMIT_ADDED: case CVS_HISTORY_COMMIT_REMOVED: case CVS_HISTORY_UPDATE_CO: if ((hrev = rcs_head_get(cf->file_rcs)) == NULL) fatal("cvs_history_add: rcs_head_get failed"); rcsnum_tostr(hrev, revbuf, sizeof(revbuf)); rcsnum_free(hrev); break; } (void)xsnprintf(fpath, sizeof(fpath), "%s/%s", current_cvsroot->cr_dir, CVS_PATH_HISTORY); if ((fd = open(fpath, O_WRONLY|O_APPEND)) == -1) { if (errno != ENOENT) cvs_log(LP_ERR, "failed to open history file"); } else { if ((fp = fdopen(fd, "a")) != NULL) { fprintf(fp, "%c%x|%s|%s|%s|%s|%s\n", historytab[type], time(NULL), getlogin(), cwd, repo, rev, (cf != NULL) ? cf->file_name : argument); (void)fclose(fp); } else { cvs_log(LP_ERR, "failed to add entry to history file"); (void)close(fd); } } if (rev != revbuf) xfree(rev); if (cvs_server_active != 1) xfree(cwd); }
void cvs_diff_local(struct cvs_file *cf) { BUF *b1; int fd1, fd2; struct stat st; struct timespec tv[2], tv2[2]; struct tm datetm; char rbuf[CVS_REV_BUFSZ], tbuf[CVS_TIME_BUFSZ], *p1, *p2; b1 = NULL; fd1 = fd2 = -1; p1 = p2 = NULL; cvs_log(LP_TRACE, "cvs_diff_local(%s)", cf->file_path); if (cf->file_type == CVS_DIR) { if (verbosity > 1) cvs_log(LP_ERR, "Diffing inside %s", cf->file_path); return; } cvs_file_classify(cf, cvs_directory_tag); if (cvs_cmdop == CVS_OP_DIFF) { if (cf->file_ent == NULL) { cvs_log(LP_ERR, "I know nothing about %s", cf->file_path); return; } switch (cf->file_ent->ce_status) { case CVS_ENT_ADDED: if (Nflag == 0) { cvs_log(LP_ERR, "%s is a new entry, no " "comparison available", cf->file_path); return; } if (!(cf->file_flags & FILE_ON_DISK)) { cvs_log(LP_ERR, "cannot find %s", cf->file_path); return; } break; case CVS_ENT_REMOVED: if (Nflag == 0) { cvs_log(LP_ERR, "%s was removed, no " "comparison available", cf->file_path); return; } if (cf->file_rcs == NULL) { cvs_log(LP_ERR, "cannot find RCS file for %s", cf->file_path); return; } break; default: if (!(cf->file_flags & FILE_ON_DISK)) { cvs_printf("? %s\n", cf->file_path); return; } if (cf->file_rcs == NULL) { cvs_log(LP_ERR, "cannot find RCS file for %s", cf->file_path); return; } break; } } if (cf->file_status == FILE_UPTODATE && rev1 == NULL && rev2 == NULL && date1 == -1 && date2 == -1) return; if (cf->file_rcs != NULL && cf->file_rcs->rf_head == NULL) { cvs_log(LP_ERR, "no head revision in RCS file for %s\n", cf->file_path); return; } if (kflag && cf->file_rcs != NULL) rcs_kwexp_set(cf->file_rcs, kflag); if (cf->file_rcs == NULL) diff_rev1 = NULL; else if (rev1 != NULL || date1 != -1) { cvs_specified_date = date1; diff_rev1 = rcs_translate_tag(rev1, cf->file_rcs); if (diff_rev1 == NULL && cvs_cmdop == CVS_OP_DIFF) { if (rev1 != NULL) { cvs_log(LP_ERR, "tag %s not in file %s", rev1, cf->file_path); goto cleanup; } else if (Nflag) { diff_rev1 = NULL; } else { gmtime_r(&cvs_specified_date, &datetm); strftime(tbuf, sizeof(tbuf), "%Y.%m.%d.%H.%M.%S", &datetm); cvs_log(LP_ERR, "no revision for date %s in " "file %s", tbuf, cf->file_path); goto cleanup; } } else if (diff_rev1 == NULL && cvs_cmdop == CVS_OP_RDIFF && force_head) { /* -f is not allowed for unknown symbols */ if ((diff_rev1 = rcsnum_parse(rev1)) == NULL) fatal("no such tag %s", rev1); rcsnum_free(diff_rev1); diff_rev1 = cf->file_rcs->rf_head; } cvs_specified_date = -1; } else if (cvs_cmdop == CVS_OP_DIFF) { if (cf->file_ent->ce_status == CVS_ENT_ADDED) diff_rev1 = NULL; else diff_rev1 = cf->file_ent->ce_rev; } if (cf->file_rcs == NULL) diff_rev2 = NULL; else if (rev2 != NULL || date2 != -1) { cvs_specified_date = date2; diff_rev2 = rcs_translate_tag(rev2, cf->file_rcs); if (diff_rev2 == NULL && cvs_cmdop == CVS_OP_DIFF) { if (rev2 != NULL) { cvs_log(LP_ERR, "tag %s not in file %s", rev2, cf->file_path); goto cleanup; } else if (Nflag) { diff_rev2 = NULL; } else { gmtime_r(&cvs_specified_date, &datetm); strftime(tbuf, sizeof(tbuf), "%Y.%m.%d.%H.%M.%S", &datetm); cvs_log(LP_ERR, "no revision for date %s in " "file %s", tbuf, cf->file_path); goto cleanup; } } else if (diff_rev2 == NULL && cvs_cmdop == CVS_OP_RDIFF && force_head) { /* -f is not allowed for unknown symbols */ if ((diff_rev2 = rcsnum_parse(rev2)) == NULL) fatal("no such tag %s", rev2); rcsnum_free(diff_rev2); diff_rev2 = cf->file_rcs->rf_head; } cvs_specified_date = -1; } else if (cvs_cmdop == CVS_OP_RDIFF) diff_rev2 = cf->file_rcs->rf_head; else if (cf->file_ent->ce_status == CVS_ENT_REMOVED) diff_rev2 = NULL; if (diff_rev1 != NULL && diff_rev2 != NULL && rcsnum_cmp(diff_rev1, diff_rev2, 0) == 0) goto cleanup; switch (cvs_cmdop) { case CVS_OP_DIFF: if (cf->file_status == FILE_UPTODATE) { if (diff_rev2 == NULL && !rcsnum_cmp(diff_rev1, cf->file_rcsrev, 0)) goto cleanup; } break; case CVS_OP_RDIFF: if (diff_rev1 == NULL && diff_rev2 == NULL) goto cleanup; break; } cvs_printf("Index: %s\n", cf->file_path); if (cvs_cmdop == CVS_OP_DIFF) cvs_printf("%s\nRCS file: %s\n", RCS_DIFF_DIV, cf->file_rcs != NULL ? cf->file_rpath : cf->file_path); if (diff_rev1 != NULL) { if (cvs_cmdop == CVS_OP_DIFF && diff_rev1 != NULL) { (void)rcsnum_tostr(diff_rev1, rbuf, sizeof(rbuf)); cvs_printf("retrieving revision %s\n", rbuf); } tv[0].tv_sec = rcs_rev_getdate(cf->file_rcs, diff_rev1); tv[0].tv_nsec = 0; tv[1] = tv[0]; (void)xasprintf(&p1, "%s/diff1.XXXXXXXXXX", cvs_tmpdir); fd1 = rcs_rev_write_stmp(cf->file_rcs, diff_rev1, p1, 0); if (futimens(fd1, tv) == -1) fatal("cvs_diff_local: futimens failed"); } if (diff_rev2 != NULL) { if (cvs_cmdop == CVS_OP_DIFF && rev2 != NULL) { (void)rcsnum_tostr(diff_rev2, rbuf, sizeof(rbuf)); cvs_printf("retrieving revision %s\n", rbuf); } tv2[0].tv_sec = rcs_rev_getdate(cf->file_rcs, diff_rev2); tv2[0].tv_nsec = 0; tv2[1] = tv2[0]; (void)xasprintf(&p2, "%s/diff2.XXXXXXXXXX", cvs_tmpdir); fd2 = rcs_rev_write_stmp(cf->file_rcs, diff_rev2, p2, 0); if (futimens(fd2, tv2) == -1) fatal("cvs_diff_local: futimens failed"); } else if (cvs_cmdop == CVS_OP_DIFF && (cf->file_flags & FILE_ON_DISK) && cf->file_ent->ce_status != CVS_ENT_REMOVED) { (void)xasprintf(&p2, "%s/diff2.XXXXXXXXXX", cvs_tmpdir); if (cvs_server_active == 1 && cf->fd == -1) { tv2[0].tv_sec = rcs_rev_getdate(cf->file_rcs, cf->file_ent->ce_rev); tv2[0].tv_nsec = 0; tv2[1] = tv2[0]; fd2 = rcs_rev_write_stmp(cf->file_rcs, cf->file_ent->ce_rev, p2, 0); if (futimens(fd2, tv2) == -1) fatal("cvs_diff_local: futimens failed"); } else { if (fstat(cf->fd, &st) == -1) fatal("fstat failed %s", strerror(errno)); b1 = buf_load_fd(cf->fd); tv2[0].tv_sec = st.st_mtime; tv2[0].tv_nsec = 0; tv2[1] = tv2[0]; fd2 = buf_write_stmp(b1, p2, tv2); buf_free(b1); } } switch (cvs_cmdop) { case CVS_OP_DIFF: cvs_printf("%s", diffargs); if (rev1 != NULL && diff_rev1 != NULL) { (void)rcsnum_tostr(diff_rev1, rbuf, sizeof(rbuf)); cvs_printf(" -r%s", rbuf); if (rev2 != NULL && diff_rev2 != NULL) { (void)rcsnum_tostr(diff_rev2, rbuf, sizeof(rbuf)); cvs_printf(" -r%s", rbuf); } } if (diff_rev2 == NULL) cvs_printf(" %s", cf->file_path); cvs_printf("\n"); break; case CVS_OP_RDIFF: cvs_printf("diff "); switch (diff_format) { case D_CONTEXT: cvs_printf("-c "); break; case D_RCSDIFF: cvs_printf("-n "); break; case D_UNIFIED: cvs_printf("-u "); break; default: break; } if (diff_rev1 == NULL) { cvs_printf("%s ", CVS_PATH_DEVNULL); } else { (void)rcsnum_tostr(diff_rev1, rbuf, sizeof(rbuf)); cvs_printf("%s:%s ", cf->file_path, rbuf); } if (diff_rev2 == NULL) { cvs_printf("%s:removed\n", cf->file_path); } else { (void)rcsnum_tostr(diff_rev2 != NULL ? diff_rev2 : cf->file_rcs->rf_head, rbuf, sizeof(rbuf)); cvs_printf("%s:%s\n", cf->file_path, rbuf); } break; } if (fd1 == -1) { if ((fd1 = open(CVS_PATH_DEVNULL, O_RDONLY, 0)) == -1) fatal("cannot open %s", CVS_PATH_DEVNULL); } if (fd2 == -1) { if ((fd2 = open(CVS_PATH_DEVNULL, O_RDONLY, 0)) == -1) fatal("cannot open %s", CVS_PATH_DEVNULL); } if (diffreg(p1 != NULL ? cf->file_path : CVS_PATH_DEVNULL, p2 != NULL ? cf->file_path : CVS_PATH_DEVNULL, fd1, fd2, NULL, dflags) == D_ERROR) fatal("cvs_diff_local: failed to get RCS patch"); close(fd1); close(fd2); worklist_run(&temp_files, worklist_unlink); if (p1 != NULL) xfree(p1); if (p2 != NULL) xfree(p2); cleanup: if (diff_rev1 != NULL && (cf->file_rcs == NULL || diff_rev1 != cf->file_rcs->rf_head) && (cf->file_ent == NULL || diff_rev1 != cf->file_ent->ce_rev)) xfree(diff_rev1); diff_rev1 = NULL; if (diff_rev2 != NULL && (cf->file_rcs == NULL || diff_rev2 != cf->file_rcs->rf_head)) xfree(diff_rev2); diff_rev2 = NULL; }