File: | src/usr.bin/rcs/rcs.c |
Warning: | line 1126, column 8 Although the value stored to 'rdp' is used in the enclosing expression, the value is never actually read from 'rdp' |
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 == NULL((void *)0)) |
849 | errx(1, "can't find referenced line in RCS patch"); |
850 | |
851 | if (op == 'd') { |
852 | for (i = 0; (i < nbln) && (dlp != NULL((void *)0)); i++) { |
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 == NULL((void *)0)) { |
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)) { |
Although the value stored to 'rdp' is used in the enclosing expression, the value is never actually read from 'rdp' | |
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 | } |