File: | src/usr.bin/rcs/rcs.c |
Warning: | line 891, column 16 Use of memory after it is freed |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: rcs.c,v 1.89 2021/11/28 19:28:42 deraadt Exp $ */ | |||
2 | /* | |||
3 | * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org> | |||
4 | * All rights reserved. | |||
5 | * | |||
6 | * Redistribution and use in source and binary forms, with or without | |||
7 | * modification, are permitted provided that the following conditions | |||
8 | * are met: | |||
9 | * | |||
10 | * 1. Redistributions of source code must retain the above copyright | |||
11 | * notice, this list of conditions and the following disclaimer. | |||
12 | * 2. The name of the author may not be used to endorse or promote products | |||
13 | * derived from this software without specific prior written permission. | |||
14 | * | |||
15 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, | |||
16 | * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY | |||
17 | * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL | |||
18 | * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | |||
19 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |||
20 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; | |||
21 | * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | |||
22 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | |||
23 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF | |||
24 | * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |||
25 | */ | |||
26 | ||||
27 | #include <sys/types.h> | |||
28 | #include <sys/stat.h> | |||
29 | ||||
30 | #include <ctype.h> | |||
31 | #include <err.h> | |||
32 | #include <errno(*__errno()).h> | |||
33 | #include <pwd.h> | |||
34 | #include <stdarg.h> | |||
35 | #include <stdio.h> | |||
36 | #include <stdlib.h> | |||
37 | #include <string.h> | |||
38 | #include <unistd.h> | |||
39 | ||||
40 | #include "diff.h" | |||
41 | #include "rcs.h" | |||
42 | #include "rcsparse.h" | |||
43 | #include "rcsprog.h" | |||
44 | #include "rcsutil.h" | |||
45 | #include "xmalloc.h" | |||
46 | ||||
47 | #define _MAXBSIZE(64 * 1024) (64 * 1024) | |||
48 | ||||
49 | #define MINIMUM(a, b)(((a) < (b)) ? (a) : (b)) (((a) < (b)) ? (a) : (b)) | |||
50 | ||||
51 | /* invalid characters in RCS states */ | |||
52 | static const char rcs_state_invch[] = RCS_STATE_INVALCHAR"$,:;@"; | |||
53 | ||||
54 | /* invalid characters in RCS symbol names */ | |||
55 | static const char rcs_sym_invch[] = RCS_SYM_INVALCHAR"$,.:;@"; | |||
56 | ||||
57 | struct rcs_kw rcs_expkw[] = { | |||
58 | { "Author", RCS_KW_AUTHOR0x1000 }, | |||
59 | { "Date", RCS_KW_DATE0x2000 }, | |||
60 | { "Locker", RCS_KW_LOCKER0x10000 }, | |||
61 | { "Header", RCS_KW_HEADER((0x0100 | 0x0200 | 0x2000 | 0x1000 | 0x0800 | 0x10000) | 0x0010 ) }, | |||
62 | { "Id", RCS_KW_ID(0x0100 | 0x0200 | 0x2000 | 0x1000 | 0x0800 | 0x10000) }, | |||
63 | { "OpenBSD", RCS_KW_ID(0x0100 | 0x0200 | 0x2000 | 0x1000 | 0x0800 | 0x10000) }, | |||
64 | { "Log", RCS_KW_LOG0x4000 }, | |||
65 | { "Name", RCS_KW_NAME0x8000 }, | |||
66 | { "RCSfile", RCS_KW_RCSFILE0x0100 }, | |||
67 | { "Revision", RCS_KW_REVISION0x0200 }, | |||
68 | { "Source", RCS_KW_SOURCE0x0400 }, | |||
69 | { "State", RCS_KW_STATE0x0800 }, | |||
70 | { "Mdocdate", RCS_KW_MDOCDATE0x0020 }, | |||
71 | }; | |||
72 | ||||
73 | int rcs_errno = RCS_ERR_NOERR0; | |||
74 | char *timezone_flag = NULL((void *)0); | |||
75 | ||||
76 | int rcs_patch_lines(struct rcs_lines *, struct rcs_lines *); | |||
77 | static int rcs_movefile(char *, char *, mode_t, u_int); | |||
78 | ||||
79 | static void rcs_freedelta(struct rcs_delta *); | |||
80 | static void rcs_strprint(const u_char *, size_t, FILE *); | |||
81 | ||||
82 | static BUF *rcs_expand_keywords(char *, struct rcs_delta *, BUF *, int); | |||
83 | ||||
84 | RCSFILE * | |||
85 | rcs_open(const char *path, int fd, int flags, ...) | |||
86 | { | |||
87 | int mode; | |||
88 | mode_t fmode; | |||
89 | RCSFILE *rfp; | |||
90 | va_list vap; | |||
91 | struct rcs_delta *rdp; | |||
92 | struct rcs_lock *lkr; | |||
93 | ||||
94 | fmode = S_IRUSR0000400|S_IRGRP0000040|S_IROTH0000004; | |||
95 | flags &= 0xffff; /* ditch any internal flags */ | |||
96 | ||||
97 | if (flags & RCS_CREATE(1<<2)) { | |||
98 | va_start(vap, flags)__builtin_va_start(vap, flags); | |||
99 | mode = va_arg(vap, int)__builtin_va_arg(vap, int); | |||
100 | va_end(vap)__builtin_va_end(vap); | |||
101 | fmode = (mode_t)mode; | |||
102 | } | |||
103 | ||||
104 | rfp = xcalloc(1, sizeof(*rfp)); | |||
105 | ||||
106 | rfp->rf_path = xstrdup(path); | |||
107 | rfp->rf_flags = flags | RCS_SLOCK(1<<6) | RCS_SYNCED(1<<5); | |||
108 | rfp->rf_mode = fmode; | |||
109 | if (fd == -1) | |||
110 | rfp->rf_file = NULL((void *)0); | |||
111 | else if ((rfp->rf_file = fdopen(fd, "r")) == NULL((void *)0)) | |||
112 | err(1, "rcs_open: fdopen: `%s'", path); | |||
113 | ||||
114 | TAILQ_INIT(&(rfp->rf_delta))do { (&(rfp->rf_delta))->tqh_first = ((void *)0); ( &(rfp->rf_delta))->tqh_last = &(&(rfp->rf_delta ))->tqh_first; } while (0); | |||
115 | TAILQ_INIT(&(rfp->rf_access))do { (&(rfp->rf_access))->tqh_first = ((void *)0); ( &(rfp->rf_access))->tqh_last = &(&(rfp-> rf_access))->tqh_first; } while (0); | |||
116 | TAILQ_INIT(&(rfp->rf_symbols))do { (&(rfp->rf_symbols))->tqh_first = ((void *)0); (&(rfp->rf_symbols))->tqh_last = &(&(rfp-> rf_symbols))->tqh_first; } while (0); | |||
117 | TAILQ_INIT(&(rfp->rf_locks))do { (&(rfp->rf_locks))->tqh_first = ((void *)0); ( &(rfp->rf_locks))->tqh_last = &(&(rfp->rf_locks ))->tqh_first; } while (0); | |||
118 | ||||
119 | if (!(rfp->rf_flags & RCS_CREATE(1<<2))) { | |||
120 | if (rcsparse_init(rfp)) | |||
121 | errx(1, "could not parse admin data"); | |||
122 | ||||
123 | /* fill in rd_locker */ | |||
124 | TAILQ_FOREACH(lkr, &(rfp->rf_locks), rl_list)for((lkr) = ((&(rfp->rf_locks))->tqh_first); (lkr) != ((void *)0); (lkr) = ((lkr)->rl_list.tqe_next)) { | |||
125 | if ((rdp = rcs_findrev(rfp, lkr->rl_num)) == NULL((void *)0)) { | |||
126 | rcs_close(rfp); | |||
127 | return (NULL((void *)0)); | |||
128 | } | |||
129 | ||||
130 | rdp->rd_locker = xstrdup(lkr->rl_name); | |||
131 | } | |||
132 | } | |||
133 | ||||
134 | return (rfp); | |||
135 | } | |||
136 | ||||
137 | /* | |||
138 | * rcs_close() | |||
139 | * | |||
140 | * Close an RCS file handle. | |||
141 | */ | |||
142 | void | |||
143 | rcs_close(RCSFILE *rfp) | |||
144 | { | |||
145 | struct rcs_delta *rdp; | |||
146 | struct rcs_access *rap; | |||
147 | struct rcs_lock *rlp; | |||
148 | struct rcs_sym *rsp; | |||
149 | ||||
150 | if ((rfp->rf_flags & RCS_WRITE(1<<1)) && !(rfp->rf_flags & RCS_SYNCED(1<<5))) | |||
151 | rcs_write(rfp); | |||
152 | ||||
153 | while (!TAILQ_EMPTY(&(rfp->rf_delta))(((&(rfp->rf_delta))->tqh_first) == ((void *)0))) { | |||
154 | rdp = TAILQ_FIRST(&(rfp->rf_delta))((&(rfp->rf_delta))->tqh_first); | |||
155 | TAILQ_REMOVE(&(rfp->rf_delta), rdp, rd_list)do { if (((rdp)->rd_list.tqe_next) != ((void *)0)) (rdp)-> rd_list.tqe_next->rd_list.tqe_prev = (rdp)->rd_list.tqe_prev ; else (&(rfp->rf_delta))->tqh_last = (rdp)->rd_list .tqe_prev; *(rdp)->rd_list.tqe_prev = (rdp)->rd_list.tqe_next ; ; ; } while (0); | |||
156 | rcs_freedelta(rdp); | |||
157 | } | |||
158 | ||||
159 | while (!TAILQ_EMPTY(&(rfp->rf_access))(((&(rfp->rf_access))->tqh_first) == ((void *)0))) { | |||
160 | rap = TAILQ_FIRST(&(rfp->rf_access))((&(rfp->rf_access))->tqh_first); | |||
161 | TAILQ_REMOVE(&(rfp->rf_access), rap, ra_list)do { if (((rap)->ra_list.tqe_next) != ((void *)0)) (rap)-> ra_list.tqe_next->ra_list.tqe_prev = (rap)->ra_list.tqe_prev ; else (&(rfp->rf_access))->tqh_last = (rap)->ra_list .tqe_prev; *(rap)->ra_list.tqe_prev = (rap)->ra_list.tqe_next ; ; ; } while (0); | |||
162 | free(rap->ra_name); | |||
163 | free(rap); | |||
164 | } | |||
165 | ||||
166 | while (!TAILQ_EMPTY(&(rfp->rf_symbols))(((&(rfp->rf_symbols))->tqh_first) == ((void *)0))) { | |||
167 | rsp = TAILQ_FIRST(&(rfp->rf_symbols))((&(rfp->rf_symbols))->tqh_first); | |||
168 | TAILQ_REMOVE(&(rfp->rf_symbols), rsp, rs_list)do { if (((rsp)->rs_list.tqe_next) != ((void *)0)) (rsp)-> rs_list.tqe_next->rs_list.tqe_prev = (rsp)->rs_list.tqe_prev ; else (&(rfp->rf_symbols))->tqh_last = (rsp)->rs_list .tqe_prev; *(rsp)->rs_list.tqe_prev = (rsp)->rs_list.tqe_next ; ; ; } while (0); | |||
169 | rcsnum_free(rsp->rs_num); | |||
170 | free(rsp->rs_name); | |||
171 | free(rsp); | |||
172 | } | |||
173 | ||||
174 | while (!TAILQ_EMPTY(&(rfp->rf_locks))(((&(rfp->rf_locks))->tqh_first) == ((void *)0))) { | |||
175 | rlp = TAILQ_FIRST(&(rfp->rf_locks))((&(rfp->rf_locks))->tqh_first); | |||
176 | TAILQ_REMOVE(&(rfp->rf_locks), rlp, rl_list)do { if (((rlp)->rl_list.tqe_next) != ((void *)0)) (rlp)-> rl_list.tqe_next->rl_list.tqe_prev = (rlp)->rl_list.tqe_prev ; else (&(rfp->rf_locks))->tqh_last = (rlp)->rl_list .tqe_prev; *(rlp)->rl_list.tqe_prev = (rlp)->rl_list.tqe_next ; ; ; } while (0); | |||
177 | rcsnum_free(rlp->rl_num); | |||
178 | free(rlp->rl_name); | |||
179 | free(rlp); | |||
180 | } | |||
181 | ||||
182 | rcsnum_free(rfp->rf_head); | |||
183 | rcsnum_free(rfp->rf_branch); | |||
184 | ||||
185 | if (rfp->rf_file != NULL((void *)0)) | |||
186 | fclose(rfp->rf_file); | |||
187 | ||||
188 | free(rfp->rf_path); | |||
189 | free(rfp->rf_comment); | |||
190 | free(rfp->rf_expand); | |||
191 | free(rfp->rf_desc); | |||
192 | if (rfp->rf_pdata != NULL((void *)0)) | |||
193 | rcsparse_free(rfp); | |||
194 | ||||
195 | free(rfp); | |||
196 | } | |||
197 | ||||
198 | /* | |||
199 | * rcs_write() | |||
200 | * | |||
201 | * Write the contents of the RCS file handle <rfp> to disk in the file whose | |||
202 | * path is in <rf_path>. | |||
203 | */ | |||
204 | void | |||
205 | rcs_write(RCSFILE *rfp) | |||
206 | { | |||
207 | FILE *fp; | |||
208 | char numbuf[RCS_REV_BUFSZ64], *fn; | |||
209 | struct rcs_access *ap; | |||
210 | struct rcs_sym *symp; | |||
211 | struct rcs_branch *brp; | |||
212 | struct rcs_delta *rdp; | |||
213 | struct rcs_lock *lkp; | |||
214 | size_t len; | |||
215 | int fd; | |||
216 | ||||
217 | fn = NULL((void *)0); | |||
218 | ||||
219 | if (rfp->rf_flags & RCS_SYNCED(1<<5)) | |||
220 | return; | |||
221 | ||||
222 | /* Write operations need the whole file parsed */ | |||
223 | if (rcsparse_deltatexts(rfp, NULL((void *)0))) | |||
224 | errx(1, "problem parsing deltatexts"); | |||
225 | ||||
226 | (void)xasprintf(&fn, "%s/rcs.XXXXXXXXXX", rcs_tmpdir); | |||
227 | ||||
228 | if ((fd = mkstemp(fn)) == -1) | |||
229 | err(1, "%s", fn); | |||
230 | ||||
231 | if ((fp = fdopen(fd, "w+")) == NULL((void *)0)) { | |||
232 | int saved_errno; | |||
233 | ||||
234 | saved_errno = errno(*__errno()); | |||
235 | (void)unlink(fn); | |||
236 | errno(*__errno()) = saved_errno; | |||
237 | err(1, "%s", fn); | |||
238 | } | |||
239 | ||||
240 | worklist_add(fn, &temp_files); | |||
241 | ||||
242 | if (rfp->rf_head != NULL((void *)0)) | |||
243 | rcsnum_tostr(rfp->rf_head, numbuf, sizeof(numbuf)); | |||
244 | else | |||
245 | numbuf[0] = '\0'; | |||
246 | ||||
247 | fprintf(fp, "head\t%s;\n", numbuf); | |||
248 | ||||
249 | if (rfp->rf_branch != NULL((void *)0)) { | |||
250 | rcsnum_tostr(rfp->rf_branch, numbuf, sizeof(numbuf)); | |||
251 | fprintf(fp, "branch\t%s;\n", numbuf); | |||
252 | } | |||
253 | ||||
254 | fputs("access", fp); | |||
255 | TAILQ_FOREACH(ap, &(rfp->rf_access), ra_list)for((ap) = ((&(rfp->rf_access))->tqh_first); (ap) != ((void *)0); (ap) = ((ap)->ra_list.tqe_next)) { | |||
256 | fprintf(fp, "\n\t%s", ap->ra_name); | |||
257 | } | |||
258 | fputs(";\n", fp); | |||
259 | ||||
260 | fprintf(fp, "symbols"); | |||
261 | TAILQ_FOREACH(symp, &(rfp->rf_symbols), rs_list)for((symp) = ((&(rfp->rf_symbols))->tqh_first); (symp ) != ((void *)0); (symp) = ((symp)->rs_list.tqe_next)) { | |||
262 | if (RCSNUM_ISBRANCH(symp->rs_num)((symp->rs_num)->rn_len % 2)) | |||
263 | rcsnum_addmagic(symp->rs_num); | |||
264 | rcsnum_tostr(symp->rs_num, numbuf, sizeof(numbuf)); | |||
265 | fprintf(fp, "\n\t%s:%s", symp->rs_name, numbuf); | |||
266 | } | |||
267 | fprintf(fp, ";\n"); | |||
268 | ||||
269 | fprintf(fp, "locks"); | |||
270 | TAILQ_FOREACH(lkp, &(rfp->rf_locks), rl_list)for((lkp) = ((&(rfp->rf_locks))->tqh_first); (lkp) != ((void *)0); (lkp) = ((lkp)->rl_list.tqe_next)) { | |||
271 | rcsnum_tostr(lkp->rl_num, numbuf, sizeof(numbuf)); | |||
272 | fprintf(fp, "\n\t%s:%s", lkp->rl_name, numbuf); | |||
273 | } | |||
274 | ||||
275 | fprintf(fp, ";"); | |||
276 | ||||
277 | if (rfp->rf_flags & RCS_SLOCK(1<<6)) | |||
278 | fprintf(fp, " strict;"); | |||
279 | fputc('\n', fp); | |||
280 | ||||
281 | fputs("comment\t@", fp); | |||
282 | if (rfp->rf_comment != NULL((void *)0)) { | |||
283 | rcs_strprint((const u_char *)rfp->rf_comment, | |||
284 | strlen(rfp->rf_comment), fp); | |||
285 | fputs("@;\n", fp); | |||
286 | } else | |||
287 | fputs("# @;\n", fp); | |||
288 | ||||
289 | if (rfp->rf_expand != NULL((void *)0)) { | |||
290 | fputs("expand @", fp); | |||
291 | rcs_strprint((const u_char *)rfp->rf_expand, | |||
292 | strlen(rfp->rf_expand), fp); | |||
293 | fputs("@;\n", fp); | |||
294 | } | |||
295 | ||||
296 | fputs("\n\n", fp); | |||
297 | ||||
298 | TAILQ_FOREACH(rdp, &(rfp->rf_delta), rd_list)for((rdp) = ((&(rfp->rf_delta))->tqh_first); (rdp) != ((void *)0); (rdp) = ((rdp)->rd_list.tqe_next)) { | |||
299 | fprintf(fp, "%s\n", rcsnum_tostr(rdp->rd_num, numbuf, | |||
300 | sizeof(numbuf))); | |||
301 | fprintf(fp, "date\t%d.%02d.%02d.%02d.%02d.%02d;", | |||
302 | rdp->rd_date.tm_year + 1900, rdp->rd_date.tm_mon + 1, | |||
303 | rdp->rd_date.tm_mday, rdp->rd_date.tm_hour, | |||
304 | rdp->rd_date.tm_min, rdp->rd_date.tm_sec); | |||
305 | fprintf(fp, "\tauthor %s;\tstate %s;\n", | |||
306 | rdp->rd_author, rdp->rd_state); | |||
307 | fputs("branches", fp); | |||
308 | TAILQ_FOREACH(brp, &(rdp->rd_branches), rb_list)for((brp) = ((&(rdp->rd_branches))->tqh_first); (brp ) != ((void *)0); (brp) = ((brp)->rb_list.tqe_next)) { | |||
309 | fprintf(fp, "\n\t%s", rcsnum_tostr(brp->rb_num, numbuf, | |||
310 | sizeof(numbuf))); | |||
311 | } | |||
312 | fputs(";\n", fp); | |||
313 | fprintf(fp, "next\t%s;\n\n", rcsnum_tostr(rdp->rd_next, | |||
314 | numbuf, sizeof(numbuf))); | |||
315 | } | |||
316 | ||||
317 | fputs("\ndesc\n@", fp); | |||
318 | if (rfp->rf_desc != NULL((void *)0) && (len = strlen(rfp->rf_desc)) > 0) { | |||
319 | rcs_strprint((const u_char *)rfp->rf_desc, len, fp); | |||
320 | if (rfp->rf_desc[len-1] != '\n') | |||
321 | fputc('\n', fp); | |||
322 | } | |||
323 | fputs("@\n", fp); | |||
324 | ||||
325 | /* deltatexts */ | |||
326 | TAILQ_FOREACH(rdp, &(rfp->rf_delta), rd_list)for((rdp) = ((&(rfp->rf_delta))->tqh_first); (rdp) != ((void *)0); (rdp) = ((rdp)->rd_list.tqe_next)) { | |||
327 | fprintf(fp, "\n\n%s\n", rcsnum_tostr(rdp->rd_num, numbuf, | |||
328 | sizeof(numbuf))); | |||
329 | fputs("log\n@", fp); | |||
330 | if (rdp->rd_log != NULL((void *)0)) { | |||
331 | len = strlen(rdp->rd_log); | |||
332 | rcs_strprint((const u_char *)rdp->rd_log, len, fp); | |||
333 | if (len == 0 || rdp->rd_log[len-1] != '\n') | |||
334 | fputc('\n', fp); | |||
335 | } | |||
336 | fputs("@\ntext\n@", fp); | |||
337 | if (rdp->rd_text != NULL((void *)0)) | |||
338 | rcs_strprint(rdp->rd_text, rdp->rd_tlen, fp); | |||
339 | fputs("@\n", fp); | |||
340 | } | |||
341 | (void)fclose(fp); | |||
342 | ||||
343 | if (rcs_movefile(fn, rfp->rf_path, rfp->rf_mode, rfp->rf_flags) == -1) { | |||
344 | (void)unlink(fn); | |||
345 | errx(1, "rcs_movefile failed"); | |||
346 | } | |||
347 | ||||
348 | rfp->rf_flags |= RCS_SYNCED(1<<5); | |||
349 | ||||
350 | free(fn); | |||
351 | } | |||
352 | ||||
353 | /* | |||
354 | * rcs_movefile() | |||
355 | * | |||
356 | * Move a file using rename(2) if possible and copying if not. | |||
357 | * Returns 0 on success, -1 on failure. | |||
358 | */ | |||
359 | static int | |||
360 | rcs_movefile(char *from, char *to, mode_t perm, u_int to_flags) | |||
361 | { | |||
362 | FILE *src, *dst; | |||
363 | size_t nread, nwritten; | |||
364 | char *buf; | |||
365 | ||||
366 | if (rename(from, to) == 0) { | |||
367 | if (chmod(to, perm) == -1) { | |||
368 | warn("%s", to); | |||
369 | return (-1); | |||
370 | } | |||
371 | return (0); | |||
372 | } else if (errno(*__errno()) != EXDEV18) { | |||
373 | warn("failed to access temp RCS output file"); | |||
374 | return (-1); | |||
375 | } | |||
376 | ||||
377 | if ((chmod(to, S_IWUSR0000200) == -1) && !(to_flags & RCS_CREATE(1<<2))) { | |||
378 | warnx("chmod(%s, 0%o) failed", to, S_IWUSR0000200); | |||
379 | return (-1); | |||
380 | } | |||
381 | ||||
382 | /* different filesystem, have to copy the file */ | |||
383 | if ((src = fopen(from, "r")) == NULL((void *)0)) { | |||
384 | warn("%s", from); | |||
385 | return (-1); | |||
386 | } | |||
387 | if ((dst = fopen(to, "w")) == NULL((void *)0)) { | |||
388 | warn("%s", to); | |||
389 | (void)fclose(src); | |||
390 | return (-1); | |||
391 | } | |||
392 | if (fchmod(fileno(dst)(!__isthreaded ? ((dst)->_file) : (fileno)(dst)), perm)) { | |||
393 | warn("%s", to); | |||
394 | (void)unlink(to); | |||
395 | (void)fclose(src); | |||
396 | (void)fclose(dst); | |||
397 | return (-1); | |||
398 | } | |||
399 | ||||
400 | buf = xmalloc(_MAXBSIZE(64 * 1024)); | |||
401 | while ((nread = fread(buf, sizeof(char), _MAXBSIZE(64 * 1024), src)) != 0) { | |||
402 | if (ferror(src)(!__isthreaded ? (((src)->_flags & 0x0040) != 0) : (ferror )(src))) { | |||
403 | warnx("failed to read `%s'", from); | |||
404 | (void)unlink(to); | |||
405 | goto out; | |||
406 | } | |||
407 | nwritten = fwrite(buf, sizeof(char), nread, dst); | |||
408 | if (nwritten != nread) { | |||
409 | warnx("failed to write `%s'", to); | |||
410 | (void)unlink(to); | |||
411 | goto out; | |||
412 | } | |||
413 | } | |||
414 | ||||
415 | (void)unlink(from); | |||
416 | ||||
417 | out: | |||
418 | (void)fclose(src); | |||
419 | (void)fclose(dst); | |||
420 | free(buf); | |||
421 | ||||
422 | return (0); | |||
423 | } | |||
424 | ||||
425 | /* | |||
426 | * rcs_head_set() | |||
427 | * | |||
428 | * Set the revision number of the head revision for the RCS file <file> to | |||
429 | * <rev>, which must reference a valid revision within the file. | |||
430 | */ | |||
431 | int | |||
432 | rcs_head_set(RCSFILE *file, RCSNUM *rev) | |||
433 | { | |||
434 | if (rcs_findrev(file, rev) == NULL((void *)0)) | |||
435 | return (-1); | |||
436 | ||||
437 | if (file->rf_head == NULL((void *)0)) | |||
438 | file->rf_head = rcsnum_alloc(); | |||
439 | ||||
440 | rcsnum_cpy(rev, file->rf_head, 0); | |||
441 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
442 | return (0); | |||
443 | } | |||
444 | ||||
445 | ||||
446 | /* | |||
447 | * rcs_branch_get() | |||
448 | * | |||
449 | * Retrieve the default branch number for the RCS file <file>. | |||
450 | * Returns the number on success. If NULL is returned, then there is no | |||
451 | * default branch for this file. | |||
452 | */ | |||
453 | const RCSNUM * | |||
454 | rcs_branch_get(RCSFILE *file) | |||
455 | { | |||
456 | return (file->rf_branch); | |||
457 | } | |||
458 | ||||
459 | /* | |||
460 | * rcs_access_add() | |||
461 | * | |||
462 | * Add the login name <login> to the access list for the RCS file <file>. | |||
463 | * Returns 0 on success, or -1 on failure. | |||
464 | */ | |||
465 | int | |||
466 | rcs_access_add(RCSFILE *file, const char *login) | |||
467 | { | |||
468 | struct rcs_access *ap; | |||
469 | ||||
470 | /* first look for duplication */ | |||
471 | TAILQ_FOREACH(ap, &(file->rf_access), ra_list)for((ap) = ((&(file->rf_access))->tqh_first); (ap) != ((void *)0); (ap) = ((ap)->ra_list.tqe_next)) { | |||
472 | if (strcmp(ap->ra_name, login) == 0) { | |||
473 | rcs_errno = RCS_ERR_DUPENT2; | |||
474 | return (-1); | |||
475 | } | |||
476 | } | |||
477 | ||||
478 | ap = xmalloc(sizeof(*ap)); | |||
479 | ap->ra_name = xstrdup(login); | |||
480 | TAILQ_INSERT_TAIL(&(file->rf_access), ap, ra_list)do { (ap)->ra_list.tqe_next = ((void *)0); (ap)->ra_list .tqe_prev = (&(file->rf_access))->tqh_last; *(& (file->rf_access))->tqh_last = (ap); (&(file->rf_access ))->tqh_last = &(ap)->ra_list.tqe_next; } while (0); | |||
481 | ||||
482 | /* not synced anymore */ | |||
483 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
484 | return (0); | |||
485 | } | |||
486 | ||||
487 | /* | |||
488 | * rcs_access_remove() | |||
489 | * | |||
490 | * Remove an entry with login name <login> from the access list of the RCS | |||
491 | * file <file>. | |||
492 | * Returns 0 on success, or -1 on failure. | |||
493 | */ | |||
494 | int | |||
495 | rcs_access_remove(RCSFILE *file, const char *login) | |||
496 | { | |||
497 | struct rcs_access *ap; | |||
498 | ||||
499 | TAILQ_FOREACH(ap, &(file->rf_access), ra_list)for((ap) = ((&(file->rf_access))->tqh_first); (ap) != ((void *)0); (ap) = ((ap)->ra_list.tqe_next)) | |||
500 | if (strcmp(ap->ra_name, login) == 0) | |||
501 | break; | |||
502 | ||||
503 | if (ap == NULL((void *)0)) { | |||
504 | rcs_errno = RCS_ERR_NOENT1; | |||
505 | return (-1); | |||
506 | } | |||
507 | ||||
508 | TAILQ_REMOVE(&(file->rf_access), ap, ra_list)do { if (((ap)->ra_list.tqe_next) != ((void *)0)) (ap)-> ra_list.tqe_next->ra_list.tqe_prev = (ap)->ra_list.tqe_prev ; else (&(file->rf_access))->tqh_last = (ap)->ra_list .tqe_prev; *(ap)->ra_list.tqe_prev = (ap)->ra_list.tqe_next ; ; ; } while (0); | |||
509 | free(ap->ra_name); | |||
510 | free(ap); | |||
511 | ||||
512 | /* not synced anymore */ | |||
513 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
514 | return (0); | |||
515 | } | |||
516 | ||||
517 | /* | |||
518 | * rcs_sym_add() | |||
519 | * | |||
520 | * Add a symbol to the list of symbols for the RCS file <rfp>. The new symbol | |||
521 | * is named <sym> and is bound to the RCS revision <snum>. | |||
522 | * Returns 0 on success, or -1 on failure. | |||
523 | */ | |||
524 | int | |||
525 | rcs_sym_add(RCSFILE *rfp, const char *sym, RCSNUM *snum) | |||
526 | { | |||
527 | struct rcs_sym *symp; | |||
528 | ||||
529 | if (!rcs_sym_check(sym)) { | |||
530 | rcs_errno = RCS_ERR_BADSYM4; | |||
531 | return (-1); | |||
532 | } | |||
533 | ||||
534 | /* first look for duplication */ | |||
535 | TAILQ_FOREACH(symp, &(rfp->rf_symbols), rs_list)for((symp) = ((&(rfp->rf_symbols))->tqh_first); (symp ) != ((void *)0); (symp) = ((symp)->rs_list.tqe_next)) { | |||
536 | if (strcmp(symp->rs_name, sym) == 0) { | |||
537 | rcs_errno = RCS_ERR_DUPENT2; | |||
538 | return (-1); | |||
539 | } | |||
540 | } | |||
541 | ||||
542 | symp = xmalloc(sizeof(*symp)); | |||
543 | symp->rs_name = xstrdup(sym); | |||
544 | symp->rs_num = rcsnum_alloc(); | |||
545 | rcsnum_cpy(snum, symp->rs_num, 0); | |||
546 | ||||
547 | TAILQ_INSERT_HEAD(&(rfp->rf_symbols), symp, rs_list)do { if (((symp)->rs_list.tqe_next = (&(rfp->rf_symbols ))->tqh_first) != ((void *)0)) (&(rfp->rf_symbols)) ->tqh_first->rs_list.tqe_prev = &(symp)->rs_list .tqe_next; else (&(rfp->rf_symbols))->tqh_last = & (symp)->rs_list.tqe_next; (&(rfp->rf_symbols))-> tqh_first = (symp); (symp)->rs_list.tqe_prev = &(& (rfp->rf_symbols))->tqh_first; } while (0); | |||
548 | ||||
549 | /* not synced anymore */ | |||
550 | rfp->rf_flags &= ~RCS_SYNCED(1<<5); | |||
551 | return (0); | |||
552 | } | |||
553 | ||||
554 | /* | |||
555 | * rcs_sym_remove() | |||
556 | * | |||
557 | * Remove the symbol with name <sym> from the symbol list for the RCS file | |||
558 | * <file>. If no such symbol is found, the call fails and returns with an | |||
559 | * error. | |||
560 | * Returns 0 on success, or -1 on failure. | |||
561 | */ | |||
562 | int | |||
563 | rcs_sym_remove(RCSFILE *file, const char *sym) | |||
564 | { | |||
565 | struct rcs_sym *symp; | |||
566 | ||||
567 | if (!rcs_sym_check(sym)) { | |||
568 | rcs_errno = RCS_ERR_BADSYM4; | |||
569 | return (-1); | |||
570 | } | |||
571 | ||||
572 | TAILQ_FOREACH(symp, &(file->rf_symbols), rs_list)for((symp) = ((&(file->rf_symbols))->tqh_first); (symp ) != ((void *)0); (symp) = ((symp)->rs_list.tqe_next)) | |||
573 | if (strcmp(symp->rs_name, sym) == 0) | |||
574 | break; | |||
575 | ||||
576 | if (symp == NULL((void *)0)) { | |||
577 | rcs_errno = RCS_ERR_NOENT1; | |||
578 | return (-1); | |||
579 | } | |||
580 | ||||
581 | TAILQ_REMOVE(&(file->rf_symbols), symp, rs_list)do { if (((symp)->rs_list.tqe_next) != ((void *)0)) (symp) ->rs_list.tqe_next->rs_list.tqe_prev = (symp)->rs_list .tqe_prev; else (&(file->rf_symbols))->tqh_last = ( symp)->rs_list.tqe_prev; *(symp)->rs_list.tqe_prev = (symp )->rs_list.tqe_next; ; ; } while (0); | |||
582 | free(symp->rs_name); | |||
583 | rcsnum_free(symp->rs_num); | |||
584 | free(symp); | |||
585 | ||||
586 | /* not synced anymore */ | |||
587 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
588 | return (0); | |||
589 | } | |||
590 | ||||
591 | /* | |||
592 | * rcs_sym_getrev() | |||
593 | * | |||
594 | * Retrieve the RCS revision number associated with the symbol <sym> for the | |||
595 | * RCS file <file>. The returned value is a dynamically-allocated copy and | |||
596 | * should be freed by the caller once they are done with it. | |||
597 | * Returns the RCSNUM on success, or NULL on failure. | |||
598 | */ | |||
599 | RCSNUM * | |||
600 | rcs_sym_getrev(RCSFILE *file, const char *sym) | |||
601 | { | |||
602 | RCSNUM *num; | |||
603 | struct rcs_sym *symp; | |||
604 | ||||
605 | if (!rcs_sym_check(sym)) { | |||
606 | rcs_errno = RCS_ERR_BADSYM4; | |||
607 | return (NULL((void *)0)); | |||
608 | } | |||
609 | ||||
610 | num = NULL((void *)0); | |||
611 | TAILQ_FOREACH(symp, &(file->rf_symbols), rs_list)for((symp) = ((&(file->rf_symbols))->tqh_first); (symp ) != ((void *)0); (symp) = ((symp)->rs_list.tqe_next)) | |||
612 | if (strcmp(symp->rs_name, sym) == 0) | |||
613 | break; | |||
614 | ||||
615 | if (symp == NULL((void *)0)) { | |||
616 | rcs_errno = RCS_ERR_NOENT1; | |||
617 | } else { | |||
618 | num = rcsnum_alloc(); | |||
619 | rcsnum_cpy(symp->rs_num, num, 0); | |||
620 | } | |||
621 | ||||
622 | return (num); | |||
623 | } | |||
624 | ||||
625 | /* | |||
626 | * rcs_sym_check() | |||
627 | * | |||
628 | * Check the RCS symbol name <sym> for any unsupported characters. | |||
629 | * Returns 1 if the tag is correct, 0 if it isn't valid. | |||
630 | */ | |||
631 | int | |||
632 | rcs_sym_check(const char *sym) | |||
633 | { | |||
634 | int ret; | |||
635 | const unsigned char *cp; | |||
636 | ||||
637 | ret = 1; | |||
638 | cp = sym; | |||
639 | if (!isalpha(*cp++)) | |||
640 | return (0); | |||
641 | ||||
642 | for (; *cp != '\0'; cp++) | |||
643 | if (!isgraph(*cp) || (strchr(rcs_sym_invch, *cp) != NULL((void *)0))) { | |||
644 | ret = 0; | |||
645 | break; | |||
646 | } | |||
647 | ||||
648 | return (ret); | |||
649 | } | |||
650 | ||||
651 | /* | |||
652 | * rcs_lock_getmode() | |||
653 | * | |||
654 | * Retrieve the locking mode of the RCS file <file>. | |||
655 | */ | |||
656 | int | |||
657 | rcs_lock_getmode(RCSFILE *file) | |||
658 | { | |||
659 | return (file->rf_flags & RCS_SLOCK(1<<6)) ? RCS_LOCK_STRICT1 : RCS_LOCK_LOOSE0; | |||
660 | } | |||
661 | ||||
662 | /* | |||
663 | * rcs_lock_setmode() | |||
664 | * | |||
665 | * Set the locking mode of the RCS file <file> to <mode>, which must either | |||
666 | * be RCS_LOCK_LOOSE or RCS_LOCK_STRICT. | |||
667 | * Returns the previous mode on success, or -1 on failure. | |||
668 | */ | |||
669 | int | |||
670 | rcs_lock_setmode(RCSFILE *file, int mode) | |||
671 | { | |||
672 | int pmode; | |||
673 | pmode = rcs_lock_getmode(file); | |||
674 | ||||
675 | if (mode == RCS_LOCK_STRICT1) | |||
676 | file->rf_flags |= RCS_SLOCK(1<<6); | |||
677 | else if (mode == RCS_LOCK_LOOSE0) | |||
678 | file->rf_flags &= ~RCS_SLOCK(1<<6); | |||
679 | else | |||
680 | errx(1, "rcs_lock_setmode: invalid mode `%d'", mode); | |||
681 | ||||
682 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
683 | return (pmode); | |||
684 | } | |||
685 | ||||
686 | /* | |||
687 | * rcs_lock_add() | |||
688 | * | |||
689 | * Add an RCS lock for the user <user> on revision <rev>. | |||
690 | * Returns 0 on success, or -1 on failure. | |||
691 | */ | |||
692 | int | |||
693 | rcs_lock_add(RCSFILE *file, const char *user, RCSNUM *rev) | |||
694 | { | |||
695 | struct rcs_lock *lkp; | |||
696 | struct rcs_delta *rdp; | |||
697 | ||||
698 | if ((rdp = rcs_findrev(file, rev)) == NULL((void *)0)) { | |||
699 | rcs_errno = RCS_ERR_NOENT1; | |||
700 | return (-1); | |||
701 | } | |||
702 | ||||
703 | /* first look for duplication */ | |||
704 | TAILQ_FOREACH(lkp, &(file->rf_locks), rl_list)for((lkp) = ((&(file->rf_locks))->tqh_first); (lkp) != ((void *)0); (lkp) = ((lkp)->rl_list.tqe_next)) { | |||
705 | if (strcmp(lkp->rl_name, user) == 0 && | |||
706 | rcsnum_cmp(rev, lkp->rl_num, 0) == 0) { | |||
707 | rcs_errno = RCS_ERR_DUPENT2; | |||
708 | return (-1); | |||
709 | } | |||
710 | } | |||
711 | ||||
712 | lkp = xmalloc(sizeof(*lkp)); | |||
713 | lkp->rl_name = xstrdup(user); | |||
714 | lkp->rl_num = rcsnum_alloc(); | |||
715 | rcsnum_cpy(rev, lkp->rl_num, 0); | |||
716 | ||||
717 | free(rdp->rd_locker); | |||
718 | rdp->rd_locker = xstrdup(user); | |||
719 | ||||
720 | TAILQ_INSERT_TAIL(&(file->rf_locks), lkp, rl_list)do { (lkp)->rl_list.tqe_next = ((void *)0); (lkp)->rl_list .tqe_prev = (&(file->rf_locks))->tqh_last; *(&( file->rf_locks))->tqh_last = (lkp); (&(file->rf_locks ))->tqh_last = &(lkp)->rl_list.tqe_next; } while (0 ); | |||
721 | ||||
722 | /* not synced anymore */ | |||
723 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
724 | return (0); | |||
725 | } | |||
726 | ||||
727 | ||||
728 | /* | |||
729 | * rcs_lock_remove() | |||
730 | * | |||
731 | * Remove the RCS lock on revision <rev>. | |||
732 | * Returns 0 on success, or -1 on failure. | |||
733 | */ | |||
734 | int | |||
735 | rcs_lock_remove(RCSFILE *file, const char *user, RCSNUM *rev) | |||
736 | { | |||
737 | struct rcs_lock *lkp; | |||
738 | struct rcs_delta *rdp; | |||
739 | ||||
740 | if ((rdp = rcs_findrev(file, rev)) == NULL((void *)0)) { | |||
741 | rcs_errno = RCS_ERR_NOENT1; | |||
742 | return (-1); | |||
743 | } | |||
744 | ||||
745 | TAILQ_FOREACH(lkp, &(file->rf_locks), rl_list)for((lkp) = ((&(file->rf_locks))->tqh_first); (lkp) != ((void *)0); (lkp) = ((lkp)->rl_list.tqe_next)) { | |||
746 | if (strcmp(lkp->rl_name, user) == 0 && | |||
747 | rcsnum_cmp(lkp->rl_num, rev, 0) == 0) | |||
748 | break; | |||
749 | } | |||
750 | ||||
751 | if (lkp == NULL((void *)0)) { | |||
752 | rcs_errno = RCS_ERR_NOENT1; | |||
753 | return (-1); | |||
754 | } | |||
755 | ||||
756 | TAILQ_REMOVE(&(file->rf_locks), lkp, rl_list)do { if (((lkp)->rl_list.tqe_next) != ((void *)0)) (lkp)-> rl_list.tqe_next->rl_list.tqe_prev = (lkp)->rl_list.tqe_prev ; else (&(file->rf_locks))->tqh_last = (lkp)->rl_list .tqe_prev; *(lkp)->rl_list.tqe_prev = (lkp)->rl_list.tqe_next ; ; ; } while (0); | |||
757 | rcsnum_free(lkp->rl_num); | |||
758 | free(lkp->rl_name); | |||
759 | free(lkp); | |||
760 | ||||
761 | free(rdp->rd_locker); | |||
762 | rdp->rd_locker = NULL((void *)0); | |||
763 | ||||
764 | /* not synced anymore */ | |||
765 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
766 | return (0); | |||
767 | } | |||
768 | ||||
769 | /* | |||
770 | * rcs_desc_set() | |||
771 | * | |||
772 | * Set the description for the RCS file <file>. | |||
773 | */ | |||
774 | void | |||
775 | rcs_desc_set(RCSFILE *file, const char *desc) | |||
776 | { | |||
777 | char *tmp; | |||
778 | ||||
779 | tmp = xstrdup(desc); | |||
780 | free(file->rf_desc); | |||
781 | file->rf_desc = tmp; | |||
782 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
783 | } | |||
784 | ||||
785 | /* | |||
786 | * rcs_comment_set() | |||
787 | * | |||
788 | * Set the comment leader for the RCS file <file>. | |||
789 | */ | |||
790 | void | |||
791 | rcs_comment_set(RCSFILE *file, const char *comment) | |||
792 | { | |||
793 | char *tmp; | |||
794 | ||||
795 | tmp = xstrdup(comment); | |||
796 | free(file->rf_comment); | |||
797 | file->rf_comment = tmp; | |||
798 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
799 | } | |||
800 | ||||
801 | int | |||
802 | rcs_patch_lines(struct rcs_lines *dlines, struct rcs_lines *plines) | |||
803 | { | |||
804 | char op, *ep; | |||
805 | struct rcs_line *lp, *dlp, *ndlp; | |||
806 | int i, lineno, nbln; | |||
807 | u_char tmp; | |||
808 | ||||
809 | dlp = TAILQ_FIRST(&(dlines->l_lines))((&(dlines->l_lines))->tqh_first); | |||
810 | lp = TAILQ_FIRST(&(plines->l_lines))((&(plines->l_lines))->tqh_first); | |||
811 | ||||
812 | /* skip first bogus line */ | |||
813 | for (lp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next); lp != NULL((void *)0); | |||
| ||||
814 | lp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next)) { | |||
815 | if (lp->l_len < 2) | |||
816 | errx(1, "line too short, RCS patch seems broken"); | |||
817 | op = *(lp->l_line); | |||
818 | /* NUL-terminate line buffer for strtol() safety. */ | |||
819 | tmp = lp->l_line[lp->l_len - 1]; | |||
820 | lp->l_line[lp->l_len - 1] = '\0'; | |||
821 | lineno = (int)strtol((lp->l_line + 1), &ep, 10); | |||
822 | if (lineno > dlines->l_nblines || lineno < 0 || | |||
823 | *ep != ' ') | |||
824 | errx(1, "invalid line specification in RCS patch"); | |||
825 | ep++; | |||
826 | nbln = (int)strtol(ep, &ep, 10); | |||
827 | /* Restore the last byte of the buffer */ | |||
828 | lp->l_line[lp->l_len - 1] = tmp; | |||
829 | if (nbln < 0) | |||
830 | errx(1, | |||
831 | "invalid line number specification in RCS patch"); | |||
832 | ||||
833 | /* find the appropriate line */ | |||
834 | for (;;) { | |||
835 | if (dlp == NULL((void *)0)) | |||
836 | break; | |||
837 | if (dlp->l_lineno == lineno) | |||
838 | break; | |||
839 | if (dlp->l_lineno > lineno) { | |||
840 | dlp = TAILQ_PREV(dlp, tqh, l_list)(*(((struct tqh *)((dlp)->l_list.tqe_prev))->tqh_last)); | |||
841 | } else if (dlp->l_lineno < lineno) { | |||
842 | if (((ndlp = TAILQ_NEXT(dlp, l_list)((dlp)->l_list.tqe_next)) == NULL((void *)0)) || | |||
843 | ndlp->l_lineno > lineno) | |||
844 | break; | |||
845 | dlp = ndlp; | |||
846 | } | |||
847 | } | |||
848 | if (dlp
| |||
849 | errx(1, "can't find referenced line in RCS patch"); | |||
850 | ||||
851 | if (op == 'd') { | |||
852 | for (i = 0; (i < nbln) && (dlp
| |||
853 | ndlp = TAILQ_NEXT(dlp, l_list)((dlp)->l_list.tqe_next); | |||
854 | TAILQ_REMOVE(&(dlines->l_lines), dlp, l_list)do { if (((dlp)->l_list.tqe_next) != ((void *)0)) (dlp)-> l_list.tqe_next->l_list.tqe_prev = (dlp)->l_list.tqe_prev ; else (&(dlines->l_lines))->tqh_last = (dlp)->l_list .tqe_prev; *(dlp)->l_list.tqe_prev = (dlp)->l_list.tqe_next ; ; ; } while (0); | |||
855 | free(dlp); | |||
856 | dlp = ndlp; | |||
857 | /* last line is gone - reset dlp */ | |||
858 | if (dlp
| |||
859 | ndlp = TAILQ_LAST(&(dlines->l_lines),(*(((struct tqh *)((&(dlines->l_lines))->tqh_last)) ->tqh_last)) | |||
860 | tqh)(*(((struct tqh *)((&(dlines->l_lines))->tqh_last)) ->tqh_last)); | |||
861 | dlp = ndlp; | |||
862 | } | |||
863 | } | |||
864 | } else if (op == 'a') { | |||
865 | for (i = 0; i < nbln; i++) { | |||
866 | ndlp = lp; | |||
867 | lp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next); | |||
868 | if (lp == NULL((void *)0)) | |||
869 | errx(1, "truncated RCS patch"); | |||
870 | TAILQ_REMOVE(&(plines->l_lines), lp, l_list)do { if (((lp)->l_list.tqe_next) != ((void *)0)) (lp)-> l_list.tqe_next->l_list.tqe_prev = (lp)->l_list.tqe_prev ; else (&(plines->l_lines))->tqh_last = (lp)->l_list .tqe_prev; *(lp)->l_list.tqe_prev = (lp)->l_list.tqe_next ; ; ; } while (0); | |||
871 | TAILQ_INSERT_AFTER(&(dlines->l_lines), dlp,do { if (((lp)->l_list.tqe_next = (dlp)->l_list.tqe_next ) != ((void *)0)) (lp)->l_list.tqe_next->l_list.tqe_prev = &(lp)->l_list.tqe_next; else (&(dlines->l_lines ))->tqh_last = &(lp)->l_list.tqe_next; (dlp)->l_list .tqe_next = (lp); (lp)->l_list.tqe_prev = &(dlp)->l_list .tqe_next; } while (0) | |||
872 | lp, l_list)do { if (((lp)->l_list.tqe_next = (dlp)->l_list.tqe_next ) != ((void *)0)) (lp)->l_list.tqe_next->l_list.tqe_prev = &(lp)->l_list.tqe_next; else (&(dlines->l_lines ))->tqh_last = &(lp)->l_list.tqe_next; (dlp)->l_list .tqe_next = (lp); (lp)->l_list.tqe_prev = &(dlp)->l_list .tqe_next; } while (0); | |||
873 | dlp = lp; | |||
874 | ||||
875 | /* we don't want lookup to block on those */ | |||
876 | lp->l_lineno = lineno; | |||
877 | ||||
878 | lp = ndlp; | |||
879 | } | |||
880 | } else | |||
881 | errx(1, "unknown RCS patch operation `%c'", op); | |||
882 | ||||
883 | /* last line of the patch, done */ | |||
884 | if (lp->l_lineno == plines->l_nblines) | |||
885 | break; | |||
886 | } | |||
887 | ||||
888 | /* once we're done patching, rebuild the line numbers */ | |||
889 | lineno = 0; | |||
890 | TAILQ_FOREACH(lp, &(dlines->l_lines), l_list)for((lp) = ((&(dlines->l_lines))->tqh_first); (lp) != ((void *)0); (lp) = ((lp)->l_list.tqe_next)) | |||
891 | lp->l_lineno = lineno++; | |||
| ||||
892 | dlines->l_nblines = lineno - 1; | |||
893 | ||||
894 | return (0); | |||
895 | } | |||
896 | ||||
897 | /* | |||
898 | * rcs_getrev() | |||
899 | * | |||
900 | * Get the whole contents of revision <rev> from the RCSFILE <rfp>. The | |||
901 | * returned buffer is dynamically allocated and should be released using | |||
902 | * buf_free() once the caller is done using it. | |||
903 | */ | |||
904 | BUF * | |||
905 | rcs_getrev(RCSFILE *rfp, RCSNUM *frev) | |||
906 | { | |||
907 | u_int i, numlen; | |||
908 | int isbranch, lookonbranch, found; | |||
909 | size_t dlen, plen, len; | |||
910 | RCSNUM *crev, *rev, *brev; | |||
911 | BUF *rbuf; | |||
912 | struct rcs_delta *rdp = NULL((void *)0); | |||
913 | struct rcs_branch *rb; | |||
914 | u_char *data, *patch; | |||
915 | ||||
916 | if (rfp->rf_head == NULL((void *)0)) | |||
917 | return (NULL((void *)0)); | |||
918 | ||||
919 | if (frev == RCS_HEAD_REV((RCSNUM *)(-1))) | |||
920 | rev = rfp->rf_head; | |||
921 | else | |||
922 | rev = frev; | |||
923 | ||||
924 | /* XXX rcsnum_cmp() */ | |||
925 | for (i = 0; i < rfp->rf_head->rn_len; i++) { | |||
926 | if (rfp->rf_head->rn_id[i] < rev->rn_id[i]) { | |||
927 | rcs_errno = RCS_ERR_NOENT1; | |||
928 | return (NULL((void *)0)); | |||
929 | } | |||
930 | } | |||
931 | ||||
932 | /* No matter what, we'll need everything parsed up until the description | |||
933 | so go for it. */ | |||
934 | if (rcsparse_deltas(rfp, NULL((void *)0))) | |||
935 | return (NULL((void *)0)); | |||
936 | ||||
937 | rdp = rcs_findrev(rfp, rfp->rf_head); | |||
938 | if (rdp == NULL((void *)0)) { | |||
939 | warnx("failed to get RCS HEAD revision"); | |||
940 | return (NULL((void *)0)); | |||
941 | } | |||
942 | ||||
943 | if (rdp->rd_tlen == 0) | |||
944 | if (rcsparse_deltatexts(rfp, rfp->rf_head)) | |||
945 | return (NULL((void *)0)); | |||
946 | ||||
947 | len = rdp->rd_tlen; | |||
948 | if (len == 0) { | |||
949 | rbuf = buf_alloc(1); | |||
950 | buf_empty(rbuf); | |||
951 | return (rbuf); | |||
952 | } | |||
953 | ||||
954 | rbuf = buf_alloc(len); | |||
955 | buf_append(rbuf, rdp->rd_text, len); | |||
956 | ||||
957 | isbranch = 0; | |||
958 | brev = NULL((void *)0); | |||
959 | ||||
960 | /* | |||
961 | * If a branch was passed, get the latest revision on it. | |||
962 | */ | |||
963 | if (RCSNUM_ISBRANCH(rev)((rev)->rn_len % 2)) { | |||
964 | brev = rev; | |||
965 | rdp = rcs_findrev(rfp, rev); | |||
966 | if (rdp == NULL((void *)0)) { | |||
967 | buf_free(rbuf); | |||
968 | return (NULL((void *)0)); | |||
969 | } | |||
970 | ||||
971 | rev = rdp->rd_num; | |||
972 | } else { | |||
973 | if (RCSNUM_ISBRANCHREV(rev)(!((rev)->rn_len % 2) && ((rev)->rn_len >= 4 ))) { | |||
974 | brev = rcsnum_revtobr(rev); | |||
975 | isbranch = 1; | |||
976 | } | |||
977 | } | |||
978 | ||||
979 | lookonbranch = 0; | |||
980 | crev = NULL((void *)0); | |||
981 | ||||
982 | /* Apply patches backwards to get the right version. | |||
983 | */ | |||
984 | do { | |||
985 | found = 0; | |||
986 | ||||
987 | if (rcsnum_cmp(rfp->rf_head, rev, 0) == 0) | |||
988 | break; | |||
989 | ||||
990 | if (isbranch == 1 && rdp->rd_num->rn_len < rev->rn_len && | |||
991 | !TAILQ_EMPTY(&(rdp->rd_branches))(((&(rdp->rd_branches))->tqh_first) == ((void *)0))) | |||
992 | lookonbranch = 1; | |||
993 | ||||
994 | if (isbranch && lookonbranch == 1) { | |||
995 | lookonbranch = 0; | |||
996 | TAILQ_FOREACH(rb, &(rdp->rd_branches), rb_list)for((rb) = ((&(rdp->rd_branches))->tqh_first); (rb) != ((void *)0); (rb) = ((rb)->rb_list.tqe_next)) { | |||
997 | /* XXX rcsnum_cmp() is totally broken for | |||
998 | * this purpose. | |||
999 | */ | |||
1000 | numlen = MINIMUM(brev->rn_len,(((brev->rn_len) < (rb->rb_num->rn_len - 1)) ? (brev ->rn_len) : (rb->rb_num->rn_len - 1)) | |||
1001 | rb->rb_num->rn_len - 1)(((brev->rn_len) < (rb->rb_num->rn_len - 1)) ? (brev ->rn_len) : (rb->rb_num->rn_len - 1)); | |||
1002 | for (i = 0; i < numlen; i++) { | |||
1003 | if (rb->rb_num->rn_id[i] != | |||
1004 | brev->rn_id[i]) | |||
1005 | break; | |||
1006 | } | |||
1007 | ||||
1008 | if (i == numlen) { | |||
1009 | crev = rb->rb_num; | |||
1010 | found = 1; | |||
1011 | break; | |||
1012 | } | |||
1013 | } | |||
1014 | if (found == 0) | |||
1015 | crev = rdp->rd_next; | |||
1016 | } else { | |||
1017 | crev = rdp->rd_next; | |||
1018 | } | |||
1019 | ||||
1020 | rdp = rcs_findrev(rfp, crev); | |||
1021 | if (rdp == NULL((void *)0)) { | |||
1022 | buf_free(rbuf); | |||
1023 | return (NULL((void *)0)); | |||
1024 | } | |||
1025 | ||||
1026 | plen = rdp->rd_tlen; | |||
1027 | dlen = buf_len(rbuf); | |||
1028 | patch = rdp->rd_text; | |||
1029 | data = buf_release(rbuf); | |||
1030 | /* check if we have parsed this rev's deltatext */ | |||
1031 | if (rdp->rd_tlen == 0) | |||
1032 | if (rcsparse_deltatexts(rfp, rdp->rd_num)) | |||
1033 | return (NULL((void *)0)); | |||
1034 | ||||
1035 | rbuf = rcs_patchfile(data, dlen, patch, plen, rcs_patch_lines); | |||
1036 | free(data); | |||
1037 | ||||
1038 | if (rbuf == NULL((void *)0)) | |||
1039 | break; | |||
1040 | } while (rcsnum_cmp(crev, rev, 0) != 0); | |||
1041 | ||||
1042 | return (rbuf); | |||
1043 | } | |||
1044 | ||||
1045 | void | |||
1046 | rcs_delta_stats(struct rcs_delta *rdp, int *ladded, int *lremoved) | |||
1047 | { | |||
1048 | struct rcs_lines *plines; | |||
1049 | struct rcs_line *lp; | |||
1050 | int added, i, nbln, removed; | |||
1051 | char op, *ep; | |||
1052 | u_char tmp; | |||
1053 | ||||
1054 | added = removed = 0; | |||
1055 | ||||
1056 | plines = rcs_splitlines(rdp->rd_text, rdp->rd_tlen); | |||
1057 | lp = TAILQ_FIRST(&(plines->l_lines))((&(plines->l_lines))->tqh_first); | |||
1058 | ||||
1059 | /* skip first bogus line */ | |||
1060 | for (lp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next); lp != NULL((void *)0); | |||
1061 | lp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next)) { | |||
1062 | if (lp->l_len < 2) | |||
1063 | errx(1, | |||
1064 | "line too short, RCS patch seems broken"); | |||
1065 | op = *(lp->l_line); | |||
1066 | /* NUL-terminate line buffer for strtol() safety. */ | |||
1067 | tmp = lp->l_line[lp->l_len - 1]; | |||
1068 | lp->l_line[lp->l_len - 1] = '\0'; | |||
1069 | (void)strtol((lp->l_line + 1), &ep, 10); | |||
1070 | ep++; | |||
1071 | nbln = (int)strtol(ep, &ep, 10); | |||
1072 | /* Restore the last byte of the buffer */ | |||
1073 | lp->l_line[lp->l_len - 1] = tmp; | |||
1074 | if (nbln < 0) | |||
1075 | errx(1, "invalid line number specification " | |||
1076 | "in RCS patch"); | |||
1077 | ||||
1078 | if (op == 'a') { | |||
1079 | added += nbln; | |||
1080 | for (i = 0; i < nbln; i++) { | |||
1081 | lp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next); | |||
1082 | if (lp == NULL((void *)0)) | |||
1083 | errx(1, "truncated RCS patch"); | |||
1084 | } | |||
1085 | } else if (op == 'd') | |||
1086 | removed += nbln; | |||
1087 | else | |||
1088 | errx(1, "unknown RCS patch operation '%c'", op); | |||
1089 | } | |||
1090 | ||||
1091 | rcs_freelines(plines); | |||
1092 | ||||
1093 | *ladded = added; | |||
1094 | *lremoved = removed; | |||
1095 | } | |||
1096 | ||||
1097 | /* | |||
1098 | * rcs_rev_add() | |||
1099 | * | |||
1100 | * Add a revision to the RCS file <rf>. The new revision's number can be | |||
1101 | * specified in <rev> (which can also be RCS_HEAD_REV, in which case the | |||
1102 | * new revision will have a number equal to the previous head revision plus | |||
1103 | * one). The <msg> argument specifies the log message for that revision, and | |||
1104 | * <date> specifies the revision's date (a value of -1 is | |||
1105 | * equivalent to using the current time). | |||
1106 | * If <author> is NULL, set the author for this revision to the current user. | |||
1107 | * Returns 0 on success, or -1 on failure. | |||
1108 | */ | |||
1109 | int | |||
1110 | rcs_rev_add(RCSFILE *rf, RCSNUM *rev, const char *msg, time_t date, | |||
1111 | const char *author) | |||
1112 | { | |||
1113 | time_t now; | |||
1114 | struct passwd *pw; | |||
1115 | struct rcs_delta *ordp, *rdp; | |||
1116 | ||||
1117 | if (rev == RCS_HEAD_REV((RCSNUM *)(-1))) { | |||
1118 | if (rf->rf_flags & RCS_CREATE(1<<2)) { | |||
1119 | if ((rev = rcsnum_parse(RCS_HEAD_INIT"1.1")) == NULL((void *)0)) | |||
1120 | return (-1); | |||
1121 | rf->rf_head = rev; | |||
1122 | } else { | |||
1123 | rev = rcsnum_inc(rf->rf_head); | |||
1124 | } | |||
1125 | } else { | |||
1126 | if ((rdp = rcs_findrev(rf, rev)) != NULL((void *)0)) { | |||
1127 | rcs_errno = RCS_ERR_DUPENT2; | |||
1128 | return (-1); | |||
1129 | } | |||
1130 | } | |||
1131 | ||||
1132 | rdp = xcalloc(1, sizeof(*rdp)); | |||
1133 | ||||
1134 | TAILQ_INIT(&(rdp->rd_branches))do { (&(rdp->rd_branches))->tqh_first = ((void *)0) ; (&(rdp->rd_branches))->tqh_last = &(&(rdp ->rd_branches))->tqh_first; } while (0); | |||
1135 | ||||
1136 | rdp->rd_num = rcsnum_alloc(); | |||
1137 | rcsnum_cpy(rev, rdp->rd_num, 0); | |||
1138 | ||||
1139 | rdp->rd_next = rcsnum_alloc(); | |||
1140 | ||||
1141 | if (!(rf->rf_flags & RCS_CREATE(1<<2))) { | |||
1142 | /* next should point to the previous HEAD */ | |||
1143 | ordp = TAILQ_FIRST(&(rf->rf_delta))((&(rf->rf_delta))->tqh_first); | |||
1144 | rcsnum_cpy(ordp->rd_num, rdp->rd_next, 0); | |||
1145 | } | |||
1146 | ||||
1147 | if (!author && !(author = getlogin())) { | |||
1148 | if (!(pw = getpwuid(getuid()))) | |||
1149 | errx(1, "getpwuid failed"); | |||
1150 | author = pw->pw_name; | |||
1151 | } | |||
1152 | rdp->rd_author = xstrdup(author); | |||
1153 | rdp->rd_state = xstrdup(RCS_STATE_EXP"Exp"); | |||
1154 | rdp->rd_log = xstrdup(msg); | |||
1155 | ||||
1156 | if (date != (time_t)(-1)) | |||
1157 | now = date; | |||
1158 | else | |||
1159 | time(&now); | |||
1160 | gmtime_r(&now, &(rdp->rd_date)); | |||
1161 | ||||
1162 | TAILQ_INSERT_HEAD(&(rf->rf_delta), rdp, rd_list)do { if (((rdp)->rd_list.tqe_next = (&(rf->rf_delta ))->tqh_first) != ((void *)0)) (&(rf->rf_delta))-> tqh_first->rd_list.tqe_prev = &(rdp)->rd_list.tqe_next ; else (&(rf->rf_delta))->tqh_last = &(rdp)-> rd_list.tqe_next; (&(rf->rf_delta))->tqh_first = (rdp ); (rdp)->rd_list.tqe_prev = &(&(rf->rf_delta)) ->tqh_first; } while (0); | |||
1163 | rf->rf_ndelta++; | |||
1164 | ||||
1165 | /* not synced anymore */ | |||
1166 | rf->rf_flags &= ~RCS_SYNCED(1<<5); | |||
1167 | ||||
1168 | return (0); | |||
1169 | } | |||
1170 | ||||
1171 | /* | |||
1172 | * rcs_rev_remove() | |||
1173 | * | |||
1174 | * Remove the revision whose number is <rev> from the RCS file <rf>. | |||
1175 | */ | |||
1176 | int | |||
1177 | rcs_rev_remove(RCSFILE *rf, RCSNUM *rev) | |||
1178 | { | |||
1179 | char *path_tmp1, *path_tmp2; | |||
1180 | struct rcs_delta *rdp, *prevrdp, *nextrdp; | |||
1181 | BUF *newdeltatext, *nextbuf, *prevbuf, *newdiff; | |||
1182 | ||||
1183 | nextrdp = prevrdp = NULL((void *)0); | |||
1184 | path_tmp1 = path_tmp2 = NULL((void *)0); | |||
1185 | ||||
1186 | if (rev == RCS_HEAD_REV((RCSNUM *)(-1))) | |||
1187 | rev = rf->rf_head; | |||
1188 | ||||
1189 | /* do we actually have that revision? */ | |||
1190 | if ((rdp = rcs_findrev(rf, rev)) == NULL((void *)0)) { | |||
1191 | rcs_errno = RCS_ERR_NOENT1; | |||
1192 | return (-1); | |||
1193 | } | |||
1194 | ||||
1195 | /* | |||
1196 | * This is confusing, the previous delta is next in the TAILQ list. | |||
1197 | * the next delta is the previous one in the TAILQ list. | |||
1198 | * | |||
1199 | * When the HEAD revision got specified, nextrdp will be NULL. | |||
1200 | * When the first revision got specified, prevrdp will be NULL. | |||
1201 | */ | |||
1202 | prevrdp = (struct rcs_delta *)TAILQ_NEXT(rdp, rd_list)((rdp)->rd_list.tqe_next); | |||
1203 | nextrdp = (struct rcs_delta *)TAILQ_PREV(rdp, tqh, rd_list)(*(((struct tqh *)((rdp)->rd_list.tqe_prev))->tqh_last) ); | |||
1204 | ||||
1205 | newdeltatext = prevbuf = nextbuf = NULL((void *)0); | |||
1206 | ||||
1207 | if (prevrdp != NULL((void *)0)) { | |||
1208 | if ((prevbuf = rcs_getrev(rf, prevrdp->rd_num)) == NULL((void *)0)) | |||
1209 | errx(1, "error getting revision"); | |||
1210 | } | |||
1211 | ||||
1212 | if (prevrdp != NULL((void *)0) && nextrdp != NULL((void *)0)) { | |||
1213 | if ((nextbuf = rcs_getrev(rf, nextrdp->rd_num)) == NULL((void *)0)) | |||
1214 | errx(1, "error getting revision"); | |||
1215 | ||||
1216 | newdiff = buf_alloc(64); | |||
1217 | ||||
1218 | /* calculate new diff */ | |||
1219 | (void)xasprintf(&path_tmp1, "%s/diff1.XXXXXXXXXX", rcs_tmpdir); | |||
1220 | buf_write_stmp(nextbuf, path_tmp1); | |||
1221 | buf_free(nextbuf); | |||
1222 | ||||
1223 | (void)xasprintf(&path_tmp2, "%s/diff2.XXXXXXXXXX", rcs_tmpdir); | |||
1224 | buf_write_stmp(prevbuf, path_tmp2); | |||
1225 | buf_free(prevbuf); | |||
1226 | ||||
1227 | diff_format = D_RCSDIFF5; | |||
1228 | if (diffreg(path_tmp1, path_tmp2, newdiff, D_FORCEASCII0x01) == D_ERROR2) | |||
1229 | errx(1, "diffreg failed"); | |||
1230 | ||||
1231 | newdeltatext = newdiff; | |||
1232 | } else if (nextrdp == NULL((void *)0) && prevrdp != NULL((void *)0)) { | |||
1233 | newdeltatext = prevbuf; | |||
1234 | } | |||
1235 | ||||
1236 | if (newdeltatext != NULL((void *)0)) { | |||
1237 | if (rcs_deltatext_set(rf, prevrdp->rd_num, newdeltatext) < 0) | |||
1238 | errx(1, "error setting new deltatext"); | |||
1239 | } | |||
1240 | ||||
1241 | TAILQ_REMOVE(&(rf->rf_delta), rdp, rd_list)do { if (((rdp)->rd_list.tqe_next) != ((void *)0)) (rdp)-> rd_list.tqe_next->rd_list.tqe_prev = (rdp)->rd_list.tqe_prev ; else (&(rf->rf_delta))->tqh_last = (rdp)->rd_list .tqe_prev; *(rdp)->rd_list.tqe_prev = (rdp)->rd_list.tqe_next ; ; ; } while (0); | |||
1242 | ||||
1243 | /* update pointers */ | |||
1244 | if (prevrdp != NULL((void *)0) && nextrdp != NULL((void *)0)) { | |||
1245 | rcsnum_cpy(prevrdp->rd_num, nextrdp->rd_next, 0); | |||
1246 | } else if (prevrdp != NULL((void *)0)) { | |||
1247 | if (rcs_head_set(rf, prevrdp->rd_num) < 0) | |||
1248 | errx(1, "rcs_head_set failed"); | |||
1249 | } else if (nextrdp != NULL((void *)0)) { | |||
1250 | rcsnum_free(nextrdp->rd_next); | |||
1251 | nextrdp->rd_next = rcsnum_alloc(); | |||
1252 | } else { | |||
1253 | rcsnum_free(rf->rf_head); | |||
1254 | rf->rf_head = NULL((void *)0); | |||
1255 | } | |||
1256 | ||||
1257 | rf->rf_ndelta--; | |||
1258 | rf->rf_flags &= ~RCS_SYNCED(1<<5); | |||
1259 | ||||
1260 | rcs_freedelta(rdp); | |||
1261 | ||||
1262 | free(path_tmp1); | |||
1263 | free(path_tmp2); | |||
1264 | ||||
1265 | return (0); | |||
1266 | } | |||
1267 | ||||
1268 | /* | |||
1269 | * rcs_findrev() | |||
1270 | * | |||
1271 | * Find a specific revision's delta entry in the tree of the RCS file <rfp>. | |||
1272 | * The revision number is given in <rev>. | |||
1273 | * | |||
1274 | * If the given revision is a branch number, we translate it into the latest | |||
1275 | * revision on the branch. | |||
1276 | * | |||
1277 | * Returns a pointer to the delta on success, or NULL on failure. | |||
1278 | */ | |||
1279 | struct rcs_delta * | |||
1280 | rcs_findrev(RCSFILE *rfp, RCSNUM *rev) | |||
1281 | { | |||
1282 | u_int cmplen; | |||
1283 | struct rcs_delta *rdp; | |||
1284 | RCSNUM *brev, *frev; | |||
1285 | ||||
1286 | /* | |||
1287 | * We need to do more parsing if the last revision in the linked list | |||
1288 | * is greater than the requested revision. | |||
1289 | */ | |||
1290 | rdp = TAILQ_LAST(&(rfp->rf_delta), rcs_dlist)(*(((struct rcs_dlist *)((&(rfp->rf_delta))->tqh_last ))->tqh_last)); | |||
1291 | if (rdp == NULL((void *)0) || | |||
1292 | rcsnum_cmp(rdp->rd_num, rev, 0) == -1) { | |||
1293 | if (rcsparse_deltas(rfp, rev)) | |||
1294 | return (NULL((void *)0)); | |||
1295 | } | |||
1296 | ||||
1297 | /* | |||
1298 | * Translate a branch into the latest revision on the branch itself. | |||
1299 | */ | |||
1300 | if (RCSNUM_ISBRANCH(rev)((rev)->rn_len % 2)) { | |||
1301 | brev = rcsnum_brtorev(rev); | |||
1302 | frev = brev; | |||
1303 | for (;;) { | |||
1304 | rdp = rcs_findrev(rfp, frev); | |||
1305 | if (rdp == NULL((void *)0)) | |||
1306 | return (NULL((void *)0)); | |||
1307 | ||||
1308 | if (rdp->rd_next->rn_len == 0) | |||
1309 | break; | |||
1310 | ||||
1311 | frev = rdp->rd_next; | |||
1312 | } | |||
1313 | ||||
1314 | rcsnum_free(brev); | |||
1315 | return (rdp); | |||
1316 | } | |||
1317 | ||||
1318 | cmplen = rev->rn_len; | |||
1319 | ||||
1320 | TAILQ_FOREACH(rdp, &(rfp->rf_delta), rd_list)for((rdp) = ((&(rfp->rf_delta))->tqh_first); (rdp) != ((void *)0); (rdp) = ((rdp)->rd_list.tqe_next)) { | |||
1321 | if (rcsnum_cmp(rdp->rd_num, rev, cmplen) == 0) | |||
1322 | return (rdp); | |||
1323 | } | |||
1324 | ||||
1325 | return (NULL((void *)0)); | |||
1326 | } | |||
1327 | ||||
1328 | /* | |||
1329 | * rcs_kwexp_set() | |||
1330 | * | |||
1331 | * Set the keyword expansion mode to use on the RCS file <file> to <mode>. | |||
1332 | */ | |||
1333 | void | |||
1334 | rcs_kwexp_set(RCSFILE *file, int mode) | |||
1335 | { | |||
1336 | int i; | |||
1337 | char *tmp, buf[8] = ""; | |||
1338 | ||||
1339 | if (RCS_KWEXP_INVAL(mode)((mode & 0x10) || ((mode & 0x08) && (mode & ~0x08)))) | |||
1340 | return; | |||
1341 | ||||
1342 | i = 0; | |||
1343 | if (mode == RCS_KWEXP_NONE0x00) | |||
1344 | buf[0] = 'b'; | |||
1345 | else if (mode == RCS_KWEXP_OLD0x08) | |||
1346 | buf[0] = 'o'; | |||
1347 | else { | |||
1348 | if (mode & RCS_KWEXP_NAME0x01) | |||
1349 | buf[i++] = 'k'; | |||
1350 | if (mode & RCS_KWEXP_VAL0x02) | |||
1351 | buf[i++] = 'v'; | |||
1352 | if (mode & RCS_KWEXP_LKR0x04) | |||
1353 | buf[i++] = 'l'; | |||
1354 | } | |||
1355 | ||||
1356 | tmp = xstrdup(buf); | |||
1357 | free(file->rf_expand); | |||
1358 | file->rf_expand = tmp; | |||
1359 | /* not synced anymore */ | |||
1360 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
1361 | } | |||
1362 | ||||
1363 | /* | |||
1364 | * rcs_kwexp_get() | |||
1365 | * | |||
1366 | * Retrieve the keyword expansion mode to be used for the RCS file <file>. | |||
1367 | */ | |||
1368 | int | |||
1369 | rcs_kwexp_get(RCSFILE *file) | |||
1370 | { | |||
1371 | if (file->rf_expand == NULL((void *)0)) | |||
1372 | return (RCS_KWEXP_DEFAULT(0x01 | 0x02)); | |||
1373 | ||||
1374 | return (rcs_kflag_get(file->rf_expand)); | |||
1375 | } | |||
1376 | ||||
1377 | /* | |||
1378 | * rcs_kflag_get() | |||
1379 | * | |||
1380 | * Get the keyword expansion mode from a set of character flags given in | |||
1381 | * <flags> and return the appropriate flag mask. In case of an error, the | |||
1382 | * returned mask will have the RCS_KWEXP_ERR bit set to 1. | |||
1383 | */ | |||
1384 | int | |||
1385 | rcs_kflag_get(const char *flags) | |||
1386 | { | |||
1387 | int fl; | |||
1388 | size_t len; | |||
1389 | const char *fp; | |||
1390 | ||||
1391 | if (flags == NULL((void *)0) || !(len = strlen(flags))) | |||
1392 | return (RCS_KWEXP_ERR0x10); | |||
1393 | ||||
1394 | fl = 0; | |||
1395 | for (fp = flags; *fp != '\0'; fp++) { | |||
1396 | if (*fp == 'k') | |||
1397 | fl |= RCS_KWEXP_NAME0x01; | |||
1398 | else if (*fp == 'v') | |||
1399 | fl |= RCS_KWEXP_VAL0x02; | |||
1400 | else if (*fp == 'l') | |||
1401 | fl |= RCS_KWEXP_LKR0x04; | |||
1402 | else if (*fp == 'o') { | |||
1403 | if (len != 1) | |||
1404 | fl |= RCS_KWEXP_ERR0x10; | |||
1405 | fl |= RCS_KWEXP_OLD0x08; | |||
1406 | } else if (*fp == 'b') { | |||
1407 | if (len != 1) | |||
1408 | fl |= RCS_KWEXP_ERR0x10; | |||
1409 | fl |= RCS_KWEXP_NONE0x00; | |||
1410 | } else /* unknown letter */ | |||
1411 | fl |= RCS_KWEXP_ERR0x10; | |||
1412 | } | |||
1413 | ||||
1414 | return (fl); | |||
1415 | } | |||
1416 | ||||
1417 | /* | |||
1418 | * rcs_freedelta() | |||
1419 | * | |||
1420 | * Free the contents of a delta structure. | |||
1421 | */ | |||
1422 | static void | |||
1423 | rcs_freedelta(struct rcs_delta *rdp) | |||
1424 | { | |||
1425 | struct rcs_branch *rb; | |||
1426 | ||||
1427 | rcsnum_free(rdp->rd_num); | |||
1428 | rcsnum_free(rdp->rd_next); | |||
1429 | ||||
1430 | free(rdp->rd_author); | |||
1431 | free(rdp->rd_locker); | |||
1432 | free(rdp->rd_state); | |||
1433 | free(rdp->rd_log); | |||
1434 | free(rdp->rd_text); | |||
1435 | ||||
1436 | while ((rb = TAILQ_FIRST(&(rdp->rd_branches))((&(rdp->rd_branches))->tqh_first)) != NULL((void *)0)) { | |||
1437 | TAILQ_REMOVE(&(rdp->rd_branches), rb, rb_list)do { if (((rb)->rb_list.tqe_next) != ((void *)0)) (rb)-> rb_list.tqe_next->rb_list.tqe_prev = (rb)->rb_list.tqe_prev ; else (&(rdp->rd_branches))->tqh_last = (rb)->rb_list .tqe_prev; *(rb)->rb_list.tqe_prev = (rb)->rb_list.tqe_next ; ; ; } while (0); | |||
1438 | rcsnum_free(rb->rb_num); | |||
1439 | free(rb); | |||
1440 | } | |||
1441 | ||||
1442 | free(rdp); | |||
1443 | } | |||
1444 | ||||
1445 | /* | |||
1446 | * rcs_strprint() | |||
1447 | * | |||
1448 | * Output an RCS string <str> of size <slen> to the stream <stream>. Any | |||
1449 | * '@' characters are escaped. Otherwise, the string can contain arbitrary | |||
1450 | * binary data. | |||
1451 | */ | |||
1452 | static void | |||
1453 | rcs_strprint(const u_char *str, size_t slen, FILE *stream) | |||
1454 | { | |||
1455 | const u_char *ap, *ep, *sp; | |||
1456 | ||||
1457 | if (slen == 0) | |||
1458 | return; | |||
1459 | ||||
1460 | ep = str + slen - 1; | |||
1461 | ||||
1462 | for (sp = str; sp <= ep;) { | |||
1463 | ap = memchr(sp, '@', ep - sp); | |||
1464 | if (ap == NULL((void *)0)) | |||
1465 | ap = ep; | |||
1466 | (void)fwrite(sp, sizeof(u_char), ap - sp + 1, stream); | |||
1467 | ||||
1468 | if (*ap == '@') | |||
1469 | putc('@', stream)(!__isthreaded ? __sputc('@', stream) : (putc)('@', stream)); | |||
1470 | sp = ap + 1; | |||
1471 | } | |||
1472 | } | |||
1473 | ||||
1474 | /* | |||
1475 | * rcs_expand_keywords() | |||
1476 | * | |||
1477 | * Return expansion any RCS keywords in <data> | |||
1478 | * | |||
1479 | * On error, return NULL. | |||
1480 | */ | |||
1481 | static BUF * | |||
1482 | rcs_expand_keywords(char *rcsfile_in, struct rcs_delta *rdp, BUF *bp, int mode) | |||
1483 | { | |||
1484 | BUF *newbuf; | |||
1485 | u_char *c, *kw, *fin; | |||
1486 | char buf[256], *tmpf, resolved[PATH_MAX1024], *rcsfile; | |||
1487 | u_char *line, *line2; | |||
1488 | u_int i, j; | |||
1489 | int kwtype; | |||
1490 | int found; | |||
1491 | struct tm tb; | |||
1492 | ||||
1493 | tb = rdp->rd_date; | |||
1494 | if (timezone_flag != NULL((void *)0)) | |||
1495 | rcs_set_tz(timezone_flag, rdp, &tb); | |||
1496 | ||||
1497 | if (realpath(rcsfile_in, resolved) == NULL((void *)0)) | |||
1498 | rcsfile = rcsfile_in; | |||
1499 | else | |||
1500 | rcsfile = resolved; | |||
1501 | ||||
1502 | newbuf = buf_alloc(buf_len(bp)); | |||
1503 | ||||
1504 | /* | |||
1505 | * Keyword formats: | |||
1506 | * $Keyword$ | |||
1507 | * $Keyword: value$ | |||
1508 | */ | |||
1509 | c = buf_get(bp); | |||
1510 | fin = c + buf_len(bp); | |||
1511 | /* Copying to newbuf is deferred until the first keyword. */ | |||
1512 | found = 0; | |||
1513 | ||||
1514 | while (c < fin) { | |||
1515 | kw = memchr(c, '$', fin - c); | |||
1516 | if (kw == NULL((void *)0)) | |||
1517 | break; | |||
1518 | ++kw; | |||
1519 | if (found) { | |||
1520 | /* Copy everything up to and including the $. */ | |||
1521 | buf_append(newbuf, c, kw - c); | |||
1522 | } | |||
1523 | c = kw; | |||
1524 | /* c points after the $ now. */ | |||
1525 | if (c == fin) | |||
1526 | break; | |||
1527 | if (!isalpha(*c)) /* all valid keywords start with a letter */ | |||
1528 | continue; | |||
1529 | ||||
1530 | for (i = 0; i < RCS_NKWORDS(sizeof(rcs_expkw)/sizeof(rcs_expkw[0])); ++i) { | |||
1531 | size_t kwlen; | |||
1532 | ||||
1533 | kwlen = strlen(rcs_expkw[i].kw_str); | |||
1534 | /* | |||
1535 | * kwlen must be less than clen since clen includes | |||
1536 | * either a terminating `$' or a `:'. | |||
1537 | */ | |||
1538 | if (c + kwlen < fin && | |||
1539 | memcmp(c , rcs_expkw[i].kw_str, kwlen) == 0 && | |||
1540 | (c[kwlen] == '$' || c[kwlen] == ':')) { | |||
1541 | c += kwlen; | |||
1542 | break; | |||
1543 | } | |||
1544 | } | |||
1545 | if (i == RCS_NKWORDS(sizeof(rcs_expkw)/sizeof(rcs_expkw[0]))) | |||
1546 | continue; | |||
1547 | kwtype = rcs_expkw[i].kw_type; | |||
1548 | ||||
1549 | /* | |||
1550 | * If the next character is ':' we need to look for an '$' | |||
1551 | * before the end of the line to be sure it is in fact a | |||
1552 | * keyword. | |||
1553 | */ | |||
1554 | if (*c == ':') { | |||
1555 | for (; c < fin; ++c) { | |||
1556 | if (*c == '$' || *c == '\n') | |||
1557 | break; | |||
1558 | } | |||
1559 | ||||
1560 | if (*c != '$') { | |||
1561 | if (found) | |||
1562 | buf_append(newbuf, kw, c - kw); | |||
1563 | continue; | |||
1564 | } | |||
1565 | } | |||
1566 | ++c; | |||
1567 | ||||
1568 | if (!found) { | |||
1569 | found = 1; | |||
1570 | /* Copy everything up to and including the $. */ | |||
1571 | buf_append(newbuf, buf_get(bp), kw - buf_get(bp)); | |||
1572 | } | |||
1573 | ||||
1574 | if (mode & RCS_KWEXP_NAME0x01) { | |||
1575 | buf_puts(newbuf, rcs_expkw[i].kw_str); | |||
1576 | if (mode & RCS_KWEXP_VAL0x02) | |||
1577 | buf_puts(newbuf, ": "); | |||
1578 | } | |||
1579 | ||||
1580 | /* Order matters because of RCS_KW_ID and RCS_KW_HEADER. */ | |||
1581 | if (mode & RCS_KWEXP_VAL0x02) { | |||
1582 | if (kwtype & (RCS_KW_RCSFILE0x0100|RCS_KW_LOG0x4000)) { | |||
1583 | if ((kwtype & RCS_KW_FULLPATH0x0010) || | |||
1584 | (tmpf = strrchr(rcsfile, '/')) == NULL((void *)0)) | |||
1585 | buf_puts(newbuf, rcsfile); | |||
1586 | else | |||
1587 | buf_puts(newbuf, tmpf + 1); | |||
1588 | buf_putc(newbuf, ' '); | |||
1589 | } | |||
1590 | ||||
1591 | if (kwtype & RCS_KW_REVISION0x0200) { | |||
1592 | rcsnum_tostr(rdp->rd_num, buf, sizeof(buf)); | |||
1593 | buf_puts(newbuf, buf); | |||
1594 | buf_putc(newbuf, ' '); | |||
1595 | } | |||
1596 | ||||
1597 | if (kwtype & RCS_KW_DATE0x2000) { | |||
1598 | strftime(buf, sizeof(buf), | |||
1599 | "%Y/%m/%d %H:%M:%S ", &tb); | |||
1600 | buf_puts(newbuf, buf); | |||
1601 | } | |||
1602 | ||||
1603 | if (kwtype & RCS_KW_AUTHOR0x1000) { | |||
1604 | buf_puts(newbuf, rdp->rd_author); | |||
1605 | buf_putc(newbuf, ' '); | |||
1606 | } | |||
1607 | ||||
1608 | if (kwtype & RCS_KW_STATE0x0800) { | |||
1609 | buf_puts(newbuf, rdp->rd_state); | |||
1610 | buf_putc(newbuf, ' '); | |||
1611 | } | |||
1612 | ||||
1613 | /* Order does not matter anymore below. */ | |||
1614 | if (kwtype & RCS_KW_SOURCE0x0400) { | |||
1615 | buf_puts(newbuf, rcsfile); | |||
1616 | buf_putc(newbuf, ' '); | |||
1617 | } | |||
1618 | ||||
1619 | if (kwtype & RCS_KW_MDOCDATE0x0020) { | |||
1620 | strftime(buf, sizeof(buf), "%B", &tb); | |||
1621 | buf_puts(newbuf, buf); | |||
1622 | /* Only one blank before single-digit day. */ | |||
1623 | snprintf(buf, sizeof(buf), " %d", tb.tm_mday); | |||
1624 | buf_puts(newbuf, buf); | |||
1625 | strftime(buf, sizeof(buf), " %Y ", &tb); | |||
1626 | buf_puts(newbuf, buf); | |||
1627 | } | |||
1628 | ||||
1629 | if (kwtype & RCS_KW_NAME0x8000) | |||
1630 | buf_putc(newbuf, ' '); | |||
1631 | ||||
1632 | if ((kwtype & RCS_KW_LOCKER0x10000)) { | |||
1633 | if (rdp->rd_locker) { | |||
1634 | buf_puts(newbuf, rdp->rd_locker); | |||
1635 | buf_putc(newbuf, ' '); | |||
1636 | } | |||
1637 | } | |||
1638 | } | |||
1639 | ||||
1640 | /* End the expansion. */ | |||
1641 | if (mode & RCS_KWEXP_NAME0x01) | |||
1642 | buf_putc(newbuf, '$'); | |||
1643 | ||||
1644 | if (kwtype & RCS_KW_LOG0x4000) { | |||
1645 | line = memrchr(buf_get(bp), '\n', kw - buf_get(bp) - 1); | |||
1646 | if (line == NULL((void *)0)) | |||
1647 | line = buf_get(bp); | |||
1648 | else | |||
1649 | ++line; | |||
1650 | line2 = kw - 1; | |||
1651 | while (line2 > line && line2[-1] == ' ') | |||
1652 | --line2; | |||
1653 | ||||
1654 | buf_putc(newbuf, '\n'); | |||
1655 | buf_append(newbuf, line, kw - 1 - line); | |||
1656 | buf_puts(newbuf, "Revision "); | |||
1657 | rcsnum_tostr(rdp->rd_num, buf, sizeof(buf)); | |||
1658 | buf_puts(newbuf, buf); | |||
1659 | buf_puts(newbuf, " "); | |||
1660 | strftime(buf, sizeof(buf), "%Y/%m/%d %H:%M:%S", &tb); | |||
1661 | buf_puts(newbuf, buf); | |||
1662 | ||||
1663 | buf_puts(newbuf, " "); | |||
1664 | buf_puts(newbuf, rdp->rd_author); | |||
1665 | buf_putc(newbuf, '\n'); | |||
1666 | ||||
1667 | for (i = 0; rdp->rd_log[i]; i += j) { | |||
1668 | j = strcspn(rdp->rd_log + i, "\n"); | |||
1669 | if (j == 0) | |||
1670 | buf_append(newbuf, line, line2 - line); | |||
1671 | else | |||
1672 | buf_append(newbuf, line, kw - 1 - line); | |||
1673 | if (rdp->rd_log[i + j]) | |||
1674 | ++j; | |||
1675 | buf_append(newbuf, rdp->rd_log + i, j); | |||
1676 | } | |||
1677 | ||||
1678 | if (i > 0 && rdp->rd_log[i - 1] != '\n') | |||
1679 | buf_putc(newbuf, '\n'); | |||
1680 | ||||
1681 | buf_append(newbuf, line, line2 - line); | |||
1682 | for (j = 0; c + j < fin; ++j) { | |||
1683 | if (c[j] != ' ') | |||
1684 | break; | |||
1685 | } | |||
1686 | if (c + j == fin || c[j] == '\n') | |||
1687 | c += j; | |||
1688 | } | |||
1689 | } | |||
1690 | ||||
1691 | if (found) { | |||
1692 | buf_append(newbuf, c, fin - c); | |||
1693 | buf_free(bp); | |||
1694 | return (newbuf); | |||
1695 | } else { | |||
1696 | buf_free(newbuf); | |||
1697 | return (bp); | |||
1698 | } | |||
1699 | } | |||
1700 | ||||
1701 | /* | |||
1702 | * rcs_deltatext_set() | |||
1703 | * | |||
1704 | * Set deltatext for <rev> in RCS file <rfp> to <dtext> | |||
1705 | * Returns -1 on error, 0 on success. | |||
1706 | */ | |||
1707 | int | |||
1708 | rcs_deltatext_set(RCSFILE *rfp, RCSNUM *rev, BUF *bp) | |||
1709 | { | |||
1710 | size_t len; | |||
1711 | u_char *dtext; | |||
1712 | struct rcs_delta *rdp; | |||
1713 | ||||
1714 | /* Write operations require full parsing */ | |||
1715 | if (rcsparse_deltatexts(rfp, NULL((void *)0))) | |||
1716 | return (-1); | |||
1717 | ||||
1718 | if ((rdp = rcs_findrev(rfp, rev)) == NULL((void *)0)) | |||
1719 | return (-1); | |||
1720 | ||||
1721 | free(rdp->rd_text); | |||
1722 | ||||
1723 | len = buf_len(bp); | |||
1724 | dtext = buf_release(bp); | |||
1725 | bp = NULL((void *)0); | |||
1726 | ||||
1727 | if (len != 0) { | |||
1728 | rdp->rd_text = xmalloc(len); | |||
1729 | rdp->rd_tlen = len; | |||
1730 | (void)memcpy(rdp->rd_text, dtext, len); | |||
1731 | } else { | |||
1732 | rdp->rd_text = NULL((void *)0); | |||
1733 | rdp->rd_tlen = 0; | |||
1734 | } | |||
1735 | ||||
1736 | free(dtext); | |||
1737 | ||||
1738 | return (0); | |||
1739 | } | |||
1740 | ||||
1741 | /* | |||
1742 | * rcs_rev_setlog() | |||
1743 | * | |||
1744 | * Sets the log message of revision <rev> to <logtext>. | |||
1745 | */ | |||
1746 | int | |||
1747 | rcs_rev_setlog(RCSFILE *rfp, RCSNUM *rev, const char *logtext) | |||
1748 | { | |||
1749 | struct rcs_delta *rdp; | |||
1750 | ||||
1751 | if ((rdp = rcs_findrev(rfp, rev)) == NULL((void *)0)) | |||
1752 | return (-1); | |||
1753 | ||||
1754 | free(rdp->rd_log); | |||
1755 | ||||
1756 | rdp->rd_log = xstrdup(logtext); | |||
1757 | rfp->rf_flags &= ~RCS_SYNCED(1<<5); | |||
1758 | return (0); | |||
1759 | } | |||
1760 | /* | |||
1761 | * rcs_rev_getdate() | |||
1762 | * | |||
1763 | * Get the date corresponding to a given revision. | |||
1764 | * Returns the date on success, -1 on failure. | |||
1765 | */ | |||
1766 | time_t | |||
1767 | rcs_rev_getdate(RCSFILE *rfp, RCSNUM *rev) | |||
1768 | { | |||
1769 | struct rcs_delta *rdp; | |||
1770 | ||||
1771 | if ((rdp = rcs_findrev(rfp, rev)) == NULL((void *)0)) | |||
1772 | return (-1); | |||
1773 | ||||
1774 | return (mktime(&rdp->rd_date)); | |||
1775 | } | |||
1776 | ||||
1777 | /* | |||
1778 | * rcs_state_set() | |||
1779 | * | |||
1780 | * Sets the state of revision <rev> to <state> | |||
1781 | * NOTE: default state is 'Exp'. States may not contain spaces. | |||
1782 | * | |||
1783 | * Returns -1 on failure, 0 on success. | |||
1784 | */ | |||
1785 | int | |||
1786 | rcs_state_set(RCSFILE *rfp, RCSNUM *rev, const char *state) | |||
1787 | { | |||
1788 | struct rcs_delta *rdp; | |||
1789 | ||||
1790 | if ((rdp = rcs_findrev(rfp, rev)) == NULL((void *)0)) | |||
1791 | return (-1); | |||
1792 | ||||
1793 | free(rdp->rd_state); | |||
1794 | ||||
1795 | rdp->rd_state = xstrdup(state); | |||
1796 | ||||
1797 | rfp->rf_flags &= ~RCS_SYNCED(1<<5); | |||
1798 | ||||
1799 | return (0); | |||
1800 | } | |||
1801 | ||||
1802 | /* | |||
1803 | * rcs_state_check() | |||
1804 | * | |||
1805 | * Check if string <state> is valid. | |||
1806 | * | |||
1807 | * Returns 0 if the string is valid, -1 otherwise. | |||
1808 | */ | |||
1809 | int | |||
1810 | rcs_state_check(const char *state) | |||
1811 | { | |||
1812 | int ret; | |||
1813 | const unsigned char *cp; | |||
1814 | ||||
1815 | ret = 0; | |||
1816 | cp = state; | |||
1817 | if (!isalpha(*cp++)) | |||
1818 | return (-1); | |||
1819 | ||||
1820 | for (; *cp != '\0'; cp++) | |||
1821 | if (!isgraph(*cp) || (strchr(rcs_state_invch, *cp) != NULL((void *)0))) { | |||
1822 | ret = -1; | |||
1823 | break; | |||
1824 | } | |||
1825 | ||||
1826 | return (ret); | |||
1827 | } | |||
1828 | ||||
1829 | /* | |||
1830 | * rcs_kwexp_buf() | |||
1831 | * | |||
1832 | * Do keyword expansion on a buffer if necessary | |||
1833 | * | |||
1834 | */ | |||
1835 | BUF * | |||
1836 | rcs_kwexp_buf(BUF *bp, RCSFILE *rf, RCSNUM *rev) | |||
1837 | { | |||
1838 | struct rcs_delta *rdp; | |||
1839 | int expmode; | |||
1840 | ||||
1841 | /* | |||
1842 | * Do keyword expansion if required. | |||
1843 | */ | |||
1844 | expmode = rcs_kwexp_get(rf); | |||
1845 | ||||
1846 | if (!(expmode & RCS_KWEXP_NONE0x00)) { | |||
1847 | if ((rdp = rcs_findrev(rf, rev)) == NULL((void *)0)) | |||
1848 | errx(1, "could not fetch revision"); | |||
1849 | return (rcs_expand_keywords(rf->rf_path, rdp, bp, expmode)); | |||
1850 | } | |||
1851 | return (bp); | |||
1852 | } |