static void grab_version (FILE * out, const database_t * db, cvs_connection_t * s, version_t * version) { if (version == NULL || version->mark != SIZE_MAX) return; const char * path = version->file->path; const char * slash = strrchr (path, '/'); // Make sure we have the directory. if (slash != NULL && (version->parent == NULL || version->parent->mark == SIZE_MAX || version->parent->mark <= cached_marks)) cvs_printf (s, "Directory %s/%.*s\n" "%s%.*s\n", s->module, (int) (slash - path), path, s->prefix, (int) (slash - path), path); // Go to the main directory. cvs_printf (s, "Directory %s\n%.*s\n", s->module, (int) strlen (s->prefix) - 1, s->prefix); cvs_printff (s, "Argument -kk\n" "Argument -r%s\n" "Argument --\n" "Argument %s\nupdate\n", version->version, version->file->path); read_versions (out, db, s); if (version->mark == SIZE_MAX) fatal ("cvs checkout - failed to get %s %s\n", version->file->path, version->version); }
static void import_printf(const char *fmt, ...) { char *str; va_list vap; va_start(vap, fmt); if (vasprintf(&str, fmt, vap) == -1) fatal("import_printf: could not allocate memory"); va_end(vap); cvs_printf("%s", str); buf_puts(logbuf, str); xfree(str); }
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 void grab_by_option (FILE * out, const database_t * db, cvs_connection_t * s, const char * r_arg, const char * D_arg, version_t ** fetch, version_t ** fetch_end) { // Build an array of the paths that we're getting. FIXME - if changeset // versions were sorted we wouldn't need this. const char ** paths = NULL; const char ** paths_end = NULL; for (version_t ** i = fetch; i != fetch_end; ++i) { version_t * v = version_live (*i); assert (v && v->used && v->mark == SIZE_MAX); ARRAY_APPEND (paths, v->file->path); } assert (paths != paths_end); ARRAY_SORT (paths, (int(*)(const void *, const void *)) strcmp); const char * d = NULL; ssize_t d_len = SSIZE_MAX; for (const char ** i = paths; i != paths_end; ++i) { const char * slash = strrchr (*i, '/'); if (slash == NULL) continue; if (slash - *i == d_len && memcmp (*i, d, d_len) == 0) continue; // Tell the server about this directory. d = *i; d_len = slash - d; cvs_printf (s, "Directory %s/%.*s\n" "%s%.*s\n", s->module, (int) d_len, d, s->prefix, (int) d_len, d); } // Go to the main directory. cvs_printf (s, "Directory %s\n%.*s\n", s->module, (int) (strlen (s->prefix) - 1), s->prefix); // Update args: if (r_arg) cvs_printf (s, "Argument -r%s\n", r_arg); if (D_arg) cvs_printf (s, "Argument -D%s\n", D_arg); cvs_printf (s, "Argument -kk\n" "Argument --\n"); for (const char ** i = paths; i != paths_end; ++i) cvs_printf (s, "Argument %s\n", *i); xfree (paths); cvs_printff (s, "update\n"); read_versions (out, db, s); }
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); }
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); }
static void add_directory(struct cvs_file *cf) { int added, nb; struct stat st; CVSENTRIES *entlist; char *date, entry[MAXPATHLEN], msg[1024], repo[MAXPATHLEN], *tag, *p; struct file_info_list files_info; struct file_info *fi; struct trigger_list *line_list; cvs_log(LP_TRACE, "add_directory(%s)", cf->file_path); (void)xsnprintf(entry, MAXPATHLEN, "%s%s", cf->file_rpath, RCS_FILE_EXT); added = 1; if (stat(entry, &st) != -1) { cvs_log(LP_NOTICE, "cannot add directory %s: " "a file with that name already exists", cf->file_path); added = 0; } else { /* Let's see if we have any per-directory tags first. */ cvs_parse_tagfile(cf->file_wd, &tag, &date, &nb); (void)xsnprintf(entry, MAXPATHLEN, "%s/%s", cf->file_path, CVS_PATH_CVSDIR); if (cvs_server_active) { if (mkdir(cf->file_rpath, 0755) == -1 && errno != EEXIST) fatal("add_directory: %s: %s", cf->file_rpath, strerror(errno)); } else if (stat(entry, &st) != -1) { if (!S_ISDIR(st.st_mode)) { cvs_log(LP_ERR, "%s exists but is not " "directory", entry); } else { cvs_log(LP_NOTICE, "%s already exists", entry); } added = 0; } else if (cvs_noexec != 1) { if (mkdir(cf->file_rpath, 0755) == -1 && errno != EEXIST) fatal("add_directory: %s: %s", cf->file_rpath, strerror(errno)); cvs_get_repository_name(cf->file_wd, repo, MAXPATHLEN); (void)xsnprintf(entry, MAXPATHLEN, "%s/%s", repo, cf->file_name); cvs_mkadmin(cf->file_path, current_cvsroot->cr_dir, entry, tag, date); p = xmalloc(CVS_ENT_MAXLINELEN); cvs_ent_line_str(cf->file_name, NULL, NULL, NULL, NULL, 1, 0, p, CVS_ENT_MAXLINELEN); entlist = cvs_ent_open(cf->file_wd); cvs_ent_add(entlist, p); xfree(p); } } if (added == 1 && current_cvsroot->cr_method == CVS_METHOD_LOCAL) { (void)xsnprintf(msg, sizeof(msg), "Directory %s added to the repository", cf->file_rpath); if (tag != NULL) { (void)strlcat(msg, "\n--> Using per-directory sticky tag ", sizeof(msg)); (void)strlcat(msg, tag, sizeof(msg)); } if (date != NULL) { (void)strlcat(msg, "\n--> Using per-directory sticky date ", sizeof(msg)); (void)strlcat(msg, date, sizeof(msg)); } cvs_printf("%s\n", msg); if (tag != NULL) xfree(tag); if (date != NULL) xfree(date); cvs_get_repository_name(cf->file_path, repo, MAXPATHLEN); line_list = cvs_trigger_getlines(CVS_PATH_LOGINFO, repo); if (line_list != NULL) { TAILQ_INIT(&files_info); fi = xcalloc(1, sizeof(*fi)); fi->file_path = xstrdup(cf->file_path); TAILQ_INSERT_TAIL(&files_info, fi, flist); cvs_add_loginfo(repo); cvs_trigger_handle(CVS_TRIGGER_LOGINFO, repo, loginfo, line_list, &files_info); cvs_trigger_freeinfo(&files_info); cvs_trigger_freelist(line_list); if (loginfo != NULL) xfree(loginfo); } } cf->file_status = FILE_SKIP; }
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; }