[BACK]Return to rcs.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / cvs

Annotation of src/usr.bin/cvs/rcs.c, Revision 1.221

1.221   ! joris       1: /*     $OpenBSD: rcs.c,v 1.220 2007/09/22 15:41:46 joris Exp $ */
1.1       jfb         2: /*
                      3:  * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
1.15      tedu        4:  * All rights reserved.
1.1       jfb         5:  *
1.15      tedu        6:  * Redistribution and use in source and binary forms, with or without
                      7:  * modification, are permitted provided that the following conditions
                      8:  * are met:
1.1       jfb         9:  *
1.15      tedu       10:  * 1. Redistributions of source code must retain the above copyright
                     11:  *    notice, this list of conditions and the following disclaimer.
1.1       jfb        12:  * 2. The name of the author may not be used to endorse or promote products
1.15      tedu       13:  *    derived from this software without specific prior written permission.
1.1       jfb        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
1.15      tedu       24:  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1.1       jfb        25:  */
                     26:
1.210     otto       27: #include <sys/stat.h>
                     28:
                     29: #include <ctype.h>
                     30: #include <errno.h>
                     31: #include <libgen.h>
                     32: #include <pwd.h>
                     33: #include <stdlib.h>
                     34: #include <string.h>
                     35: #include <unistd.h>
1.1       jfb        36:
1.219     tobias     37: #include "atomicio.h"
1.94      joris      38: #include "cvs.h"
1.172     joris      39: #include "diff.h"
1.1       jfb        40: #include "rcs.h"
                     41:
1.57      xsa        42: #define RCS_BUFSIZE    16384
                     43: #define RCS_BUFEXTSIZE 8192
1.117     niallo     44: #define RCS_KWEXP_SIZE  1024
1.1       jfb        45:
                     46: /* RCS token types */
1.57      xsa        47: #define RCS_TOK_ERR    -1
                     48: #define RCS_TOK_EOF    0
                     49: #define RCS_TOK_NUM    1
                     50: #define RCS_TOK_ID     2
                     51: #define RCS_TOK_STRING 3
                     52: #define RCS_TOK_SCOLON 4
                     53: #define RCS_TOK_COLON  5
                     54:
                     55: #define RCS_TOK_HEAD           8
                     56: #define RCS_TOK_BRANCH         9
                     57: #define RCS_TOK_ACCESS         10
                     58: #define RCS_TOK_SYMBOLS                11
                     59: #define RCS_TOK_LOCKS          12
                     60: #define RCS_TOK_COMMENT                13
                     61: #define RCS_TOK_EXPAND         14
                     62: #define RCS_TOK_DATE           15
                     63: #define RCS_TOK_AUTHOR         16
                     64: #define RCS_TOK_STATE          17
                     65: #define RCS_TOK_NEXT           18
                     66: #define RCS_TOK_BRANCHES       19
                     67: #define RCS_TOK_DESC           20
                     68: #define RCS_TOK_LOG            21
                     69: #define RCS_TOK_TEXT           22
                     70: #define RCS_TOK_STRICT         23
1.1       jfb        71:
1.57      xsa        72: #define RCS_ISKEY(t)   (((t) >= RCS_TOK_HEAD) && ((t) <= RCS_TOK_BRANCHES))
1.1       jfb        73:
1.57      xsa        74: #define RCS_NOSCOL     0x01    /* no terminating semi-colon */
                     75: #define RCS_VOPT       0x02    /* value is optional */
1.1       jfb        76:
1.218     tobias     77: #define ANNOTATE_NEVER 0
                     78: #define ANNOTATE_NOW   1
                     79: #define ANNOTATE_LATER 2
                     80:
1.1       jfb        81: /* opaque parse data */
                     82: struct rcs_pdata {
1.57      xsa        83:        u_int   rp_lines;
1.1       jfb        84:
1.57      xsa        85:        char    *rp_buf;
                     86:        size_t   rp_blen;
                     87:        char    *rp_bufend;
                     88:        size_t   rp_tlen;
1.1       jfb        89:
                     90:        /* pushback token buffer */
1.57      xsa        91:        char    rp_ptok[128];
                     92:        int     rp_pttype;      /* token type, RCS_TOK_ERR if no token */
1.1       jfb        93:
1.57      xsa        94:        FILE    *rp_file;
1.1       jfb        95: };
                     96:
1.57      xsa        97: #define RCS_TOKSTR(rfp)        ((struct rcs_pdata *)rfp->rf_pdata)->rp_buf
                     98: #define RCS_TOKLEN(rfp)        ((struct rcs_pdata *)rfp->rf_pdata)->rp_tlen
1.1       jfb        99:
1.47      jfb       100: /* invalid characters in RCS symbol names */
1.49      jfb       101: static const char rcs_sym_invch[] = RCS_SYM_INVALCHAR;
1.47      jfb       102:
1.51      jfb       103: /* comment leaders, depending on the file's suffix */
                    104: static const struct rcs_comment {
1.57      xsa       105:        const char      *rc_suffix;
                    106:        const char      *rc_cstr;
1.51      jfb       107: } rcs_comments[] = {
                    108:        { "1",    ".\\\" " },
                    109:        { "2",    ".\\\" " },
                    110:        { "3",    ".\\\" " },
                    111:        { "4",    ".\\\" " },
                    112:        { "5",    ".\\\" " },
                    113:        { "6",    ".\\\" " },
                    114:        { "7",    ".\\\" " },
                    115:        { "8",    ".\\\" " },
                    116:        { "9",    ".\\\" " },
                    117:        { "a",    "-- "    },   /* Ada           */
                    118:        { "ada",  "-- "    },
                    119:        { "adb",  "-- "    },
                    120:        { "asm",  ";; "    },   /* assembler (MS-DOS) */
                    121:        { "ads",  "-- "    },   /* Ada */
                    122:        { "bat",  ":: "    },   /* batch (MS-DOS) */
                    123:        { "body", "-- "    },   /* Ada */
                    124:        { "c",    " * "    },   /* C */
                    125:        { "c++",  "// "    },   /* C++ */
                    126:        { "cc",   "// "    },
                    127:        { "cpp",  "// "    },
                    128:        { "cxx",  "// "    },
                    129:        { "m",    "// "    },   /* Objective-C */
                    130:        { "cl",   ";;; "   },   /* Common Lisp   */
                    131:        { "cmd",  ":: "    },   /* command (OS/2) */
                    132:        { "cmf",  "c "     },   /* CM Fortran    */
                    133:        { "csh",  "# "     },   /* shell         */
                    134:        { "e",    "# "     },   /* efl           */
                    135:        { "epsf", "% "     },   /* encapsulated postscript */
                    136:        { "epsi", "% "     },   /* encapsulated postscript */
                    137:        { "el",   "; "     },   /* Emacs Lisp    */
                    138:        { "f",    "c "     },   /* Fortran       */
                    139:        { "for",  "c "     },
                    140:        { "h",    " * "    },   /* C-header      */
                    141:        { "hh",   "// "    },   /* C++ header    */
                    142:        { "hpp",  "// "    },
                    143:        { "hxx",  "// "    },
                    144:        { "in",   "# "     },   /* for Makefile.in */
                    145:        { "l",    " * "    },   /* lex */
                    146:        { "mac",  ";; "    },   /* macro (DEC-10, MS-DOS, PDP-11, VMS, etc) */
                    147:        { "mak",  "# "     },   /* makefile, e.g. Visual C++ */
                    148:        { "me",   ".\\\" " },   /* me-macros    t/nroff  */
                    149:        { "ml",   "; "     },   /* mocklisp      */
                    150:        { "mm",   ".\\\" " },   /* mm-macros    t/nroff  */
                    151:        { "ms",   ".\\\" " },   /* ms-macros    t/nroff  */
                    152:        { "man",  ".\\\" " },   /* man-macros   t/nroff  */
                    153:        { "p",    " * "    },   /* pascal        */
                    154:        { "pas",  " * "    },
1.52      jfb       155:        { "pl",   "# "     },   /* Perl (conflict with Prolog) */
                    156:        { "pm",   "# "     },   /* Perl module */
1.51      jfb       157:        { "ps",   "% "     },   /* postscript */
                    158:        { "psw",  "% "     },   /* postscript wrap */
                    159:        { "pswm", "% "     },   /* postscript wrap */
                    160:        { "r",    "# "     },   /* ratfor        */
                    161:        { "rc",   " * "    },   /* Microsoft Windows resource file */
                    162:        { "red",  "% "     },   /* psl/rlisp     */
                    163:        { "sh",   "# "     },   /* shell         */
                    164:        { "sl",   "% "     },   /* psl           */
                    165:        { "spec", "-- "    },   /* Ada           */
                    166:        { "tex",  "% "     },   /* tex           */
                    167:        { "y",    " * "    },   /* yacc          */
                    168:        { "ye",   " * "    },   /* yacc-efl      */
                    169:        { "yr",   " * "    },   /* yacc-ratfor   */
                    170: };
                    171:
1.128     niallo    172: struct rcs_kw rcs_expkw[] =  {
                    173:        { "Author",     RCS_KW_AUTHOR   },
                    174:        { "Date",       RCS_KW_DATE     },
                    175:        { "Header",     RCS_KW_HEADER   },
                    176:        { "Id",         RCS_KW_ID       },
                    177:        { "Log",        RCS_KW_LOG      },
                    178:        { "Name",       RCS_KW_NAME     },
                    179:        { "RCSfile",    RCS_KW_RCSFILE  },
                    180:        { "Revision",   RCS_KW_REVISION },
                    181:        { "Source",     RCS_KW_SOURCE   },
                    182:        { "State",      RCS_KW_STATE    },
1.211     niallo    183:        { "Mdocdate",   RCS_KW_MDOCDATE },
1.128     niallo    184: };
                    185:
1.57      xsa       186: #define NB_COMTYPES    (sizeof(rcs_comments)/sizeof(rcs_comments[0]))
1.51      jfb       187:
1.1       jfb       188: static struct rcs_key {
1.57      xsa       189:        char    rk_str[16];
                    190:        int     rk_id;
                    191:        int     rk_val;
                    192:        int     rk_flags;
1.1       jfb       193: } rcs_keys[] = {
                    194:        { "access",   RCS_TOK_ACCESS,   RCS_TOK_ID,     RCS_VOPT     },
1.41      jfb       195:        { "author",   RCS_TOK_AUTHOR,   RCS_TOK_ID,     0            },
1.1       jfb       196:        { "branch",   RCS_TOK_BRANCH,   RCS_TOK_NUM,    RCS_VOPT     },
                    197:        { "branches", RCS_TOK_BRANCHES, RCS_TOK_NUM,    RCS_VOPT     },
                    198:        { "comment",  RCS_TOK_COMMENT,  RCS_TOK_STRING, RCS_VOPT     },
                    199:        { "date",     RCS_TOK_DATE,     RCS_TOK_NUM,    0            },
                    200:        { "desc",     RCS_TOK_DESC,     RCS_TOK_STRING, RCS_NOSCOL   },
                    201:        { "expand",   RCS_TOK_EXPAND,   RCS_TOK_STRING, RCS_VOPT     },
                    202:        { "head",     RCS_TOK_HEAD,     RCS_TOK_NUM,    RCS_VOPT     },
                    203:        { "locks",    RCS_TOK_LOCKS,    RCS_TOK_ID,     0            },
                    204:        { "log",      RCS_TOK_LOG,      RCS_TOK_STRING, RCS_NOSCOL   },
                    205:        { "next",     RCS_TOK_NEXT,     RCS_TOK_NUM,    RCS_VOPT     },
1.41      jfb       206:        { "state",    RCS_TOK_STATE,    RCS_TOK_ID,     RCS_VOPT     },
1.1       jfb       207:        { "strict",   RCS_TOK_STRICT,   0,              0,           },
                    208:        { "symbols",  RCS_TOK_SYMBOLS,  0,              0            },
                    209:        { "text",     RCS_TOK_TEXT,     RCS_TOK_STRING, RCS_NOSCOL   },
                    210: };
                    211:
1.57      xsa       212: #define RCS_NKEYS      (sizeof(rcs_keys)/sizeof(rcs_keys[0]))
1.1       jfb       213:
1.32      jfb       214: static const char *rcs_errstrs[] = {
                    215:        "No error",
                    216:        "No such entry",
                    217:        "Duplicate entry found",
                    218:        "Bad RCS number",
1.48      jfb       219:        "Invalid RCS symbol",
                    220:        "Parse error",
1.32      jfb       221: };
                    222:
                    223: #define RCS_NERR   (sizeof(rcs_errstrs)/sizeof(rcs_errstrs[0]))
                    224:
                    225: int rcs_errno = RCS_ERR_NOERR;
1.1       jfb       226:
1.218     tobias    227: int            rcs_patch_lines(struct cvs_lines *, struct cvs_lines *,
                    228:                    struct cvs_line **, struct rcs_delta *);
1.167     ray       229: static void    rcs_parse_init(RCSFILE *);
1.57      xsa       230: static int     rcs_parse_admin(RCSFILE *);
                    231: static int     rcs_parse_delta(RCSFILE *);
1.146     xsa       232: static void    rcs_parse_deltas(RCSFILE *, RCSNUM *);
1.57      xsa       233: static int     rcs_parse_deltatext(RCSFILE *);
1.146     xsa       234: static void    rcs_parse_deltatexts(RCSFILE *, RCSNUM *);
1.148     xsa       235: static void    rcs_parse_desc(RCSFILE *, RCSNUM *);
1.57      xsa       236:
                    237: static int     rcs_parse_access(RCSFILE *);
                    238: static int     rcs_parse_symbols(RCSFILE *);
                    239: static int     rcs_parse_locks(RCSFILE *);
                    240: static int     rcs_parse_branches(RCSFILE *, struct rcs_delta *);
                    241: static void    rcs_freedelta(struct rcs_delta *);
                    242: static void    rcs_freepdata(struct rcs_pdata *);
                    243: static int     rcs_gettok(RCSFILE *);
                    244: static int     rcs_pushtok(RCSFILE *, const char *, int);
1.151     xsa       245: static void    rcs_growbuf(RCSFILE *);
1.155     ray       246: static void    rcs_strprint(const u_char *, size_t, FILE *);
1.57      xsa       247:
1.196     niallo    248: static void    rcs_kwexp_line(char *, struct rcs_delta *, struct cvs_line *,
                    249:                    int mode);
1.26      jfb       250:
1.60      xsa       251: RCSFILE *
1.172     joris     252: rcs_open(const char *path, int fd, int flags, ...)
1.1       jfb       253: {
1.172     joris     254:        int mode;
1.26      jfb       255:        mode_t fmode;
1.1       jfb       256:        RCSFILE *rfp;
1.26      jfb       257:        va_list vap;
1.109     joris     258:        struct rcs_delta *rdp;
                    259:        struct rcs_lock *lkr;
1.26      jfb       260:
1.152     niallo    261:        fmode = S_IRUSR|S_IRGRP|S_IROTH;
1.26      jfb       262:        flags &= 0xffff;        /* ditch any internal flags */
1.1       jfb       263:
1.172     joris     264:        if (flags & RCS_CREATE) {
                    265:                va_start(vap, flags);
                    266:                mode = va_arg(vap, int);
                    267:                va_end(vap);
                    268:                fmode = (mode_t)mode;
1.1       jfb       269:        }
                    270:
1.161     ray       271:        rfp = xcalloc(1, sizeof(*rfp));
1.1       jfb       272:
1.110     joris     273:        rfp->rf_path = xstrdup(path);
1.142     niallo    274:        rfp->rf_flags = flags | RCS_SLOCK | RCS_SYNCED;
1.26      jfb       275:        rfp->rf_mode = fmode;
1.172     joris     276:        rfp->fd = fd;
1.175     joris     277:        rfp->rf_dead = 0;
1.1       jfb       278:
                    279:        TAILQ_INIT(&(rfp->rf_delta));
1.29      jfb       280:        TAILQ_INIT(&(rfp->rf_access));
1.1       jfb       281:        TAILQ_INIT(&(rfp->rf_symbols));
                    282:        TAILQ_INIT(&(rfp->rf_locks));
                    283:
1.167     ray       284:        if (!(rfp->rf_flags & RCS_CREATE))
                    285:                rcs_parse_init(rfp);
1.1       jfb       286:
1.109     joris     287:        /* fill in rd_locker */
                    288:        TAILQ_FOREACH(lkr, &(rfp->rf_locks), rl_list) {
                    289:                if ((rdp = rcs_findrev(rfp, lkr->rl_num)) == NULL) {
                    290:                        rcs_close(rfp);
                    291:                        return (NULL);
                    292:                }
                    293:
1.110     joris     294:                rdp->rd_locker = xstrdup(lkr->rl_name);
1.109     joris     295:        }
                    296:
1.1       jfb       297:        return (rfp);
                    298: }
                    299:
                    300: /*
                    301:  * rcs_close()
                    302:  *
                    303:  * Close an RCS file handle.
                    304:  */
                    305: void
                    306: rcs_close(RCSFILE *rfp)
                    307: {
                    308:        struct rcs_delta *rdp;
1.71      moritz    309:        struct rcs_access *rap;
1.13      jfb       310:        struct rcs_lock *rlp;
                    311:        struct rcs_sym *rsp;
1.1       jfb       312:
1.26      jfb       313:        if ((rfp->rf_flags & RCS_WRITE) && !(rfp->rf_flags & RCS_SYNCED))
                    314:                rcs_write(rfp);
                    315:
1.1       jfb       316:        while (!TAILQ_EMPTY(&(rfp->rf_delta))) {
                    317:                rdp = TAILQ_FIRST(&(rfp->rf_delta));
                    318:                TAILQ_REMOVE(&(rfp->rf_delta), rdp, rd_list);
                    319:                rcs_freedelta(rdp);
1.71      moritz    320:        }
                    321:
                    322:        while (!TAILQ_EMPTY(&(rfp->rf_access))) {
                    323:                rap = TAILQ_FIRST(&(rfp->rf_access));
                    324:                TAILQ_REMOVE(&(rfp->rf_access), rap, ra_list);
1.110     joris     325:                xfree(rap->ra_name);
                    326:                xfree(rap);
1.1       jfb       327:        }
                    328:
1.13      jfb       329:        while (!TAILQ_EMPTY(&(rfp->rf_symbols))) {
                    330:                rsp = TAILQ_FIRST(&(rfp->rf_symbols));
                    331:                TAILQ_REMOVE(&(rfp->rf_symbols), rsp, rs_list);
                    332:                rcsnum_free(rsp->rs_num);
1.110     joris     333:                xfree(rsp->rs_name);
                    334:                xfree(rsp);
1.13      jfb       335:        }
                    336:
                    337:        while (!TAILQ_EMPTY(&(rfp->rf_locks))) {
                    338:                rlp = TAILQ_FIRST(&(rfp->rf_locks));
                    339:                TAILQ_REMOVE(&(rfp->rf_locks), rlp, rl_list);
                    340:                rcsnum_free(rlp->rl_num);
1.110     joris     341:                xfree(rlp->rl_name);
                    342:                xfree(rlp);
1.13      jfb       343:        }
                    344:
1.1       jfb       345:        if (rfp->rf_head != NULL)
                    346:                rcsnum_free(rfp->rf_head);
1.11      joris     347:        if (rfp->rf_branch != NULL)
                    348:                rcsnum_free(rfp->rf_branch);
1.1       jfb       349:
                    350:        if (rfp->rf_path != NULL)
1.110     joris     351:                xfree(rfp->rf_path);
1.1       jfb       352:        if (rfp->rf_comment != NULL)
1.110     joris     353:                xfree(rfp->rf_comment);
1.1       jfb       354:        if (rfp->rf_expand != NULL)
1.110     joris     355:                xfree(rfp->rf_expand);
1.1       jfb       356:        if (rfp->rf_desc != NULL)
1.110     joris     357:                xfree(rfp->rf_desc);
1.118     joris     358:        if (rfp->rf_pdata != NULL)
                    359:                rcs_freepdata(rfp->rf_pdata);
1.110     joris     360:        xfree(rfp);
1.1       jfb       361: }
                    362:
                    363: /*
                    364:  * rcs_write()
                    365:  *
                    366:  * Write the contents of the RCS file handle <rfp> to disk in the file whose
                    367:  * path is in <rf_path>.
                    368:  */
1.172     joris     369: void
1.1       jfb       370: rcs_write(RCSFILE *rfp)
                    371: {
                    372:        FILE *fp;
1.214     xsa       373:        char buf[1024], numbuf[CVS_REV_BUFSZ], *fn, tmpdir[MAXPATHLEN];
1.29      jfb       374:        struct rcs_access *ap;
1.1       jfb       375:        struct rcs_sym *symp;
1.46      jfb       376:        struct rcs_branch *brp;
1.1       jfb       377:        struct rcs_delta *rdp;
1.75      joris     378:        struct rcs_lock *lkp;
1.100     xsa       379:        size_t len;
1.207     otto      380:        int fd, saved_errno;
1.75      joris     381:
1.207     otto      382:        fd = -1;
1.1       jfb       383:
1.137     joris     384:        if (rfp->rf_flags & RCS_SYNCED)
1.181     joris     385:                return;
                    386:
                    387:        if (cvs_noexec == 1)
1.172     joris     388:                return;
1.137     joris     389:
1.117     niallo    390:        /* Write operations need the whole file parsed */
                    391:        rcs_parse_deltatexts(rfp, NULL);
1.1       jfb       392:
1.207     otto      393:        if (strlcpy(tmpdir, rfp->rf_path, sizeof(tmpdir)) >= sizeof(tmpdir))
                    394:                fatal("rcs_write: truncation");
                    395:        (void)xasprintf(&fn, "%s/rcs.XXXXXXXXXX", dirname(tmpdir));
1.172     joris     396:
1.113     xsa       397:        if ((fd = mkstemp(fn)) == -1)
1.172     joris     398:                fatal("%s", fn);
1.113     xsa       399:
1.207     otto      400:        if ((fp = fdopen(fd, "w")) == NULL) {
1.172     joris     401:                saved_errno = errno;
                    402:                (void)unlink(fn);
1.207     otto      403:                fatal("fdopen %s: %s", fn, strerror(saved_errno));
1.1       jfb       404:        }
                    405:
1.28      jfb       406:        if (rfp->rf_head != NULL)
                    407:                rcsnum_tostr(rfp->rf_head, numbuf, sizeof(numbuf));
                    408:        else
                    409:                numbuf[0] = '\0';
                    410:
1.1       jfb       411:        fprintf(fp, "head\t%s;\n", numbuf);
1.35      jfb       412:
                    413:        if (rfp->rf_branch != NULL) {
                    414:                rcsnum_tostr(rfp->rf_branch, numbuf, sizeof(numbuf));
                    415:                fprintf(fp, "branch\t%s;\n", numbuf);
                    416:        }
                    417:
1.29      jfb       418:        fputs("access", fp);
                    419:        TAILQ_FOREACH(ap, &(rfp->rf_access), ra_list) {
                    420:                fprintf(fp, "\n\t%s", ap->ra_name);
                    421:        }
                    422:        fputs(";\n", fp);
1.1       jfb       423:
1.85      joris     424:        fprintf(fp, "symbols");
1.1       jfb       425:        TAILQ_FOREACH(symp, &(rfp->rf_symbols), rs_list) {
                    426:                rcsnum_tostr(symp->rs_num, numbuf, sizeof(numbuf));
1.172     joris     427:                if (strlcpy(buf, symp->rs_name, sizeof(buf)) >= sizeof(buf) ||
                    428:                    strlcat(buf, ":", sizeof(buf)) >= sizeof(buf) ||
                    429:                    strlcat(buf, numbuf, sizeof(buf)) >= sizeof(buf))
                    430:                        fatal("rcs_write: string overflow");
1.85      joris     431:                fprintf(fp, "\n\t%s", buf);
1.1       jfb       432:        }
                    433:        fprintf(fp, ";\n");
                    434:
1.75      joris     435:        fprintf(fp, "locks");
                    436:        TAILQ_FOREACH(lkp, &(rfp->rf_locks), rl_list) {
                    437:                rcsnum_tostr(lkp->rl_num, numbuf, sizeof(numbuf));
                    438:                fprintf(fp, "\n\t%s:%s", lkp->rl_name, numbuf);
                    439:        }
                    440:
                    441:        fprintf(fp, ";");
1.1       jfb       442:
1.26      jfb       443:        if (rfp->rf_flags & RCS_SLOCK)
1.1       jfb       444:                fprintf(fp, " strict;");
                    445:        fputc('\n', fp);
                    446:
1.129     xsa       447:        fputs("comment\t@", fp);
1.42      jfb       448:        if (rfp->rf_comment != NULL) {
1.58      xsa       449:                rcs_strprint((const u_char *)rfp->rf_comment,
                    450:                    strlen(rfp->rf_comment), fp);
1.42      jfb       451:                fputs("@;\n", fp);
1.129     xsa       452:        } else
                    453:                fputs("# @;\n", fp);
1.1       jfb       454:
1.42      jfb       455:        if (rfp->rf_expand != NULL) {
                    456:                fputs("expand @", fp);
1.58      xsa       457:                rcs_strprint((const u_char *)rfp->rf_expand,
                    458:                    strlen(rfp->rf_expand), fp);
1.42      jfb       459:                fputs("@;\n", fp);
                    460:        }
1.1       jfb       461:
1.46      jfb       462:        fputs("\n\n", fp);
1.1       jfb       463:
                    464:        TAILQ_FOREACH(rdp, &(rfp->rf_delta), rd_list) {
                    465:                fprintf(fp, "%s\n", rcsnum_tostr(rdp->rd_num, numbuf,
                    466:                    sizeof(numbuf)));
                    467:                fprintf(fp, "date\t%d.%02d.%02d.%02d.%02d.%02d;",
1.44      jfb       468:                    rdp->rd_date.tm_year + 1900, rdp->rd_date.tm_mon + 1,
1.1       jfb       469:                    rdp->rd_date.tm_mday, rdp->rd_date.tm_hour,
                    470:                    rdp->rd_date.tm_min, rdp->rd_date.tm_sec);
                    471:                fprintf(fp, "\tauthor %s;\tstate %s;\n",
                    472:                    rdp->rd_author, rdp->rd_state);
1.46      jfb       473:                fputs("branches", fp);
                    474:                TAILQ_FOREACH(brp, &(rdp->rd_branches), rb_list) {
                    475:                        fprintf(fp, " %s", rcsnum_tostr(brp->rb_num, numbuf,
                    476:                            sizeof(numbuf)));
                    477:                }
                    478:                fputs(";\n", fp);
1.1       jfb       479:                fprintf(fp, "next\t%s;\n\n", rcsnum_tostr(rdp->rd_next,
                    480:                    numbuf, sizeof(numbuf)));
                    481:        }
                    482:
1.42      jfb       483:        fputs("\ndesc\n@", fp);
1.141     ray       484:        if (rfp->rf_desc != NULL && (len = strlen(rfp->rf_desc)) > 0) {
1.100     xsa       485:                rcs_strprint((const u_char *)rfp->rf_desc, len, fp);
                    486:                if (rfp->rf_desc[len-1] != '\n')
                    487:                        fputc('\n', fp);
                    488:        }
                    489:        fputs("@\n", fp);
1.1       jfb       490:
                    491:        /* deltatexts */
                    492:        TAILQ_FOREACH(rdp, &(rfp->rf_delta), rd_list) {
1.100     xsa       493:                fprintf(fp, "\n\n%s\n", rcsnum_tostr(rdp->rd_num, numbuf,
1.1       jfb       494:                    sizeof(numbuf)));
1.42      jfb       495:                fputs("log\n@", fp);
1.100     xsa       496:                if (rdp->rd_log != NULL) {
                    497:                        len = strlen(rdp->rd_log);
                    498:                        rcs_strprint((const u_char *)rdp->rd_log, len, fp);
                    499:                        if (rdp->rd_log[len-1] != '\n')
                    500:                                fputc('\n', fp);
                    501:                }
1.42      jfb       502:                fputs("@\ntext\n@", fp);
1.100     xsa       503:                if (rdp->rd_text != NULL) {
                    504:                        rcs_strprint(rdp->rd_text, rdp->rd_tlen, fp);
                    505:                }
                    506:                fputs("@\n", fp);
1.1       jfb       507:        }
1.207     otto      508:        if (fchmod(fd, rfp->rf_mode) == -1) {
                    509:                saved_errno = errno;
                    510:                (void)unlink(fn);
                    511:                fatal("fchmod %s: %s", fn, strerror(saved_errno));
                    512:        }
                    513:
1.172     joris     514:        (void)fclose(fp);
1.73      joris     515:
1.207     otto      516:        if (rename(fn, rfp->rf_path) == -1) {
                    517:                saved_errno = errno;
1.172     joris     518:                (void)unlink(fn);
1.207     otto      519:                fatal("rename(%s, %s): %s", fn, rfp->rf_path,
                    520:                    strerror(saved_errno));
1.172     joris     521:        }
1.73      joris     522:
1.172     joris     523:        rfp->rf_flags |= RCS_SYNCED;
1.73      joris     524:
1.172     joris     525:        if (fn != NULL)
                    526:                xfree(fn);
1.1       jfb       527: }
                    528:
                    529: /*
1.43      jfb       530:  * rcs_head_get()
                    531:  *
                    532:  * Retrieve the revision number of the head revision for the RCS file <file>.
                    533:  */
1.180     joris     534: RCSNUM *
1.43      jfb       535: rcs_head_get(RCSFILE *file)
                    536: {
1.213     niallo    537:        struct rcs_branch *brp;
                    538:        struct rcs_delta *rdp;
                    539:        RCSNUM *rev, *rootrev;
1.180     joris     540:
1.213     niallo    541:        rev = rcsnum_alloc();
1.180     joris     542:        if (file->rf_branch != NULL) {
1.213     niallo    543:                /* we have a default branch, use that to calculate the
                    544:                 * real HEAD*/
                    545:                rootrev = rcsnum_alloc();
                    546:                rcsnum_cpy(file->rf_branch, rootrev, 2);
                    547:                if ((rdp = rcs_findrev(file, rootrev)) == NULL)
                    548:                        fatal("rcs_head_get: could not find root revision");
                    549:
                    550:                /* HEAD should be the last revision on the default branch */
                    551:                TAILQ_FOREACH(brp, &(rdp->rd_branches), rb_list) {
                    552:                        if (TAILQ_NEXT(brp, rb_list) == NULL)
                    553:                                break;
                    554:                }
                    555:                rcsnum_free(rootrev);
                    556:                rcsnum_cpy(brp->rb_num, rev, 0);
1.195     joris     557:        } else {
                    558:                rcsnum_cpy(file->rf_head, rev, 0);
1.180     joris     559:        }
                    560:
1.195     joris     561:        return (rev);
1.43      jfb       562: }
                    563:
                    564: /*
                    565:  * rcs_head_set()
                    566:  *
                    567:  * Set the revision number of the head revision for the RCS file <file> to
                    568:  * <rev>, which must reference a valid revision within the file.
                    569:  */
                    570: int
1.117     niallo    571: rcs_head_set(RCSFILE *file, RCSNUM *rev)
1.43      jfb       572: {
1.167     ray       573:        if (rcs_findrev(file, rev) == NULL)
1.43      jfb       574:                return (-1);
                    575:
1.111     joris     576:        if (file->rf_head == NULL)
                    577:                file->rf_head = rcsnum_alloc();
1.43      jfb       578:
1.111     joris     579:        rcsnum_cpy(rev, file->rf_head, 0);
1.70      moritz    580:        file->rf_flags &= ~RCS_SYNCED;
1.43      jfb       581:        return (0);
                    582: }
                    583:
                    584:
                    585: /*
1.35      jfb       586:  * rcs_branch_get()
                    587:  *
                    588:  * Retrieve the default branch number for the RCS file <file>.
                    589:  * Returns the number on success.  If NULL is returned, then there is no
                    590:  * default branch for this file.
                    591:  */
1.60      xsa       592: const RCSNUM *
1.35      jfb       593: rcs_branch_get(RCSFILE *file)
                    594: {
                    595:        return (file->rf_branch);
                    596: }
                    597:
                    598: /*
                    599:  * rcs_branch_set()
                    600:  *
                    601:  * Set the default branch for the RCS file <file> to <bnum>.
                    602:  * Returns 0 on success, -1 on failure.
                    603:  */
                    604: int
                    605: rcs_branch_set(RCSFILE *file, const RCSNUM *bnum)
                    606: {
1.111     joris     607:        if (file->rf_branch == NULL)
                    608:                file->rf_branch = rcsnum_alloc();
1.35      jfb       609:
1.111     joris     610:        rcsnum_cpy(bnum, file->rf_branch, 0);
1.70      moritz    611:        file->rf_flags &= ~RCS_SYNCED;
1.35      jfb       612:        return (0);
                    613: }
                    614:
                    615: /*
1.29      jfb       616:  * rcs_access_add()
                    617:  *
                    618:  * Add the login name <login> to the access list for the RCS file <file>.
                    619:  * Returns 0 on success, or -1 on failure.
                    620:  */
                    621: int
                    622: rcs_access_add(RCSFILE *file, const char *login)
                    623: {
                    624:        struct rcs_access *ap;
                    625:
                    626:        /* first look for duplication */
                    627:        TAILQ_FOREACH(ap, &(file->rf_access), ra_list) {
                    628:                if (strcmp(ap->ra_name, login) == 0) {
1.32      jfb       629:                        rcs_errno = RCS_ERR_DUPENT;
1.29      jfb       630:                        return (-1);
                    631:                }
                    632:        }
                    633:
1.161     ray       634:        ap = xmalloc(sizeof(*ap));
1.110     joris     635:        ap->ra_name = xstrdup(login);
1.29      jfb       636:        TAILQ_INSERT_TAIL(&(file->rf_access), ap, ra_list);
                    637:
                    638:        /* not synced anymore */
                    639:        file->rf_flags &= ~RCS_SYNCED;
                    640:        return (0);
                    641: }
                    642:
                    643: /*
                    644:  * rcs_access_remove()
                    645:  *
                    646:  * Remove an entry with login name <login> from the access list of the RCS
                    647:  * file <file>.
                    648:  * Returns 0 on success, or -1 on failure.
                    649:  */
                    650: int
                    651: rcs_access_remove(RCSFILE *file, const char *login)
                    652: {
                    653:        struct rcs_access *ap;
                    654:
                    655:        TAILQ_FOREACH(ap, &(file->rf_access), ra_list)
                    656:                if (strcmp(ap->ra_name, login) == 0)
                    657:                        break;
                    658:
                    659:        if (ap == NULL) {
1.32      jfb       660:                rcs_errno = RCS_ERR_NOENT;
1.29      jfb       661:                return (-1);
                    662:        }
                    663:
                    664:        TAILQ_REMOVE(&(file->rf_access), ap, ra_list);
1.110     joris     665:        xfree(ap->ra_name);
                    666:        xfree(ap);
1.29      jfb       667:
                    668:        /* not synced anymore */
                    669:        file->rf_flags &= ~RCS_SYNCED;
                    670:        return (0);
                    671: }
                    672:
                    673: /*
1.26      jfb       674:  * rcs_sym_add()
1.1       jfb       675:  *
                    676:  * Add a symbol to the list of symbols for the RCS file <rfp>.  The new symbol
                    677:  * is named <sym> and is bound to the RCS revision <snum>.
                    678:  * Returns 0 on success, or -1 on failure.
                    679:  */
                    680: int
1.26      jfb       681: rcs_sym_add(RCSFILE *rfp, const char *sym, RCSNUM *snum)
1.1       jfb       682: {
                    683:        struct rcs_sym *symp;
                    684:
1.47      jfb       685:        if (!rcs_sym_check(sym)) {
                    686:                rcs_errno = RCS_ERR_BADSYM;
1.69      moritz    687:                return (-1);
1.47      jfb       688:        }
                    689:
1.1       jfb       690:        /* first look for duplication */
                    691:        TAILQ_FOREACH(symp, &(rfp->rf_symbols), rs_list) {
                    692:                if (strcmp(symp->rs_name, sym) == 0) {
1.32      jfb       693:                        rcs_errno = RCS_ERR_DUPENT;
1.1       jfb       694:                        return (-1);
                    695:                }
                    696:        }
                    697:
1.161     ray       698:        symp = xmalloc(sizeof(*symp));
1.110     joris     699:        symp->rs_name = xstrdup(sym);
1.111     joris     700:        symp->rs_num = rcsnum_alloc();
1.1       jfb       701:        rcsnum_cpy(snum, symp->rs_num, 0);
                    702:
                    703:        TAILQ_INSERT_HEAD(&(rfp->rf_symbols), symp, rs_list);
                    704:
                    705:        /* not synced anymore */
1.26      jfb       706:        rfp->rf_flags &= ~RCS_SYNCED;
1.1       jfb       707:        return (0);
                    708: }
                    709:
                    710: /*
1.27      jfb       711:  * rcs_sym_remove()
                    712:  *
                    713:  * Remove the symbol with name <sym> from the symbol list for the RCS file
                    714:  * <file>.  If no such symbol is found, the call fails and returns with an
                    715:  * error.
                    716:  * Returns 0 on success, or -1 on failure.
                    717:  */
                    718: int
                    719: rcs_sym_remove(RCSFILE *file, const char *sym)
                    720: {
                    721:        struct rcs_sym *symp;
                    722:
1.47      jfb       723:        if (!rcs_sym_check(sym)) {
                    724:                rcs_errno = RCS_ERR_BADSYM;
1.69      moritz    725:                return (-1);
1.47      jfb       726:        }
                    727:
1.27      jfb       728:        TAILQ_FOREACH(symp, &(file->rf_symbols), rs_list)
                    729:                if (strcmp(symp->rs_name, sym) == 0)
                    730:                        break;
                    731:
                    732:        if (symp == NULL) {
1.32      jfb       733:                rcs_errno = RCS_ERR_NOENT;
1.27      jfb       734:                return (-1);
                    735:        }
                    736:
                    737:        TAILQ_REMOVE(&(file->rf_symbols), symp, rs_list);
1.110     joris     738:        xfree(symp->rs_name);
1.27      jfb       739:        rcsnum_free(symp->rs_num);
1.110     joris     740:        xfree(symp);
1.27      jfb       741:
                    742:        /* not synced anymore */
                    743:        file->rf_flags &= ~RCS_SYNCED;
                    744:        return (0);
1.184     xsa       745: }
                    746:
                    747: /*
                    748:  * rcs_sym_get()
                    749:  *
                    750:  * Find a specific symbol <sym> entry in the tree of the RCS file <file>.
                    751:  *
                    752:  * Returns a pointer to the symbol on success, or NULL on failure.
                    753:  */
                    754: struct rcs_sym *
                    755: rcs_sym_get(RCSFILE *file, const char *sym)
                    756: {
                    757:        struct rcs_sym *symp;
                    758:
                    759:        TAILQ_FOREACH(symp, &(file->rf_symbols), rs_list)
                    760:                if (strcmp(symp->rs_name, sym) == 0)
                    761:                        return (symp);
                    762:
                    763:        return (NULL);
1.27      jfb       764: }
                    765:
                    766: /*
                    767:  * rcs_sym_getrev()
                    768:  *
                    769:  * Retrieve the RCS revision number associated with the symbol <sym> for the
                    770:  * RCS file <file>.  The returned value is a dynamically-allocated copy and
                    771:  * should be freed by the caller once they are done with it.
                    772:  * Returns the RCSNUM on success, or NULL on failure.
                    773:  */
1.60      xsa       774: RCSNUM *
1.27      jfb       775: rcs_sym_getrev(RCSFILE *file, const char *sym)
                    776: {
                    777:        RCSNUM *num;
                    778:        struct rcs_sym *symp;
                    779:
1.47      jfb       780:        if (!rcs_sym_check(sym)) {
                    781:                rcs_errno = RCS_ERR_BADSYM;
                    782:                return (NULL);
                    783:        }
                    784:
1.176     joris     785:        if (!strcmp(sym, RCS_HEAD_BRANCH)) {
                    786:                num = rcsnum_alloc();
                    787:                rcsnum_cpy(file->rf_head, num, 0);
                    788:                return (num);
                    789:        }
                    790:
1.27      jfb       791:        num = NULL;
                    792:        TAILQ_FOREACH(symp, &(file->rf_symbols), rs_list)
                    793:                if (strcmp(symp->rs_name, sym) == 0)
                    794:                        break;
                    795:
1.111     joris     796:        if (symp == NULL) {
1.36      jfb       797:                rcs_errno = RCS_ERR_NOENT;
1.111     joris     798:        } else {
                    799:                num = rcsnum_alloc();
                    800:                rcsnum_cpy(symp->rs_num, num, 0);
1.27      jfb       801:        }
                    802:
                    803:        return (num);
1.47      jfb       804: }
                    805:
                    806: /*
                    807:  * rcs_sym_check()
                    808:  *
                    809:  * Check the RCS symbol name <sym> for any unsupported characters.
                    810:  * Returns 1 if the tag is correct, 0 if it isn't valid.
                    811:  */
                    812: int
                    813: rcs_sym_check(const char *sym)
                    814: {
                    815:        int ret;
                    816:        const char *cp;
                    817:
                    818:        ret = 1;
                    819:        cp = sym;
                    820:        if (!isalpha(*cp++))
                    821:                return (0);
                    822:
                    823:        for (; *cp != '\0'; cp++)
                    824:                if (!isgraph(*cp) || (strchr(rcs_sym_invch, *cp) != NULL)) {
                    825:                        ret = 0;
                    826:                        break;
                    827:                }
                    828:
                    829:        return (ret);
1.30      jfb       830: }
                    831:
                    832: /*
                    833:  * rcs_lock_getmode()
                    834:  *
                    835:  * Retrieve the locking mode of the RCS file <file>.
                    836:  */
                    837: int
                    838: rcs_lock_getmode(RCSFILE *file)
                    839: {
                    840:        return (file->rf_flags & RCS_SLOCK) ? RCS_LOCK_STRICT : RCS_LOCK_LOOSE;
                    841: }
                    842:
                    843: /*
                    844:  * rcs_lock_setmode()
                    845:  *
                    846:  * Set the locking mode of the RCS file <file> to <mode>, which must either
                    847:  * be RCS_LOCK_LOOSE or RCS_LOCK_STRICT.
                    848:  * Returns the previous mode on success, or -1 on failure.
                    849:  */
                    850: int
                    851: rcs_lock_setmode(RCSFILE *file, int mode)
                    852: {
                    853:        int pmode;
                    854:        pmode = rcs_lock_getmode(file);
                    855:
                    856:        if (mode == RCS_LOCK_STRICT)
                    857:                file->rf_flags |= RCS_SLOCK;
                    858:        else if (mode == RCS_LOCK_LOOSE)
                    859:                file->rf_flags &= ~RCS_SLOCK;
1.145     xsa       860:        else
                    861:                fatal("rcs_lock_setmode: invalid mode `%d'", mode);
1.30      jfb       862:
1.70      moritz    863:        file->rf_flags &= ~RCS_SYNCED;
1.30      jfb       864:        return (pmode);
1.27      jfb       865: }
                    866:
                    867: /*
1.40      jfb       868:  * rcs_lock_add()
                    869:  *
                    870:  * Add an RCS lock for the user <user> on revision <rev>.
                    871:  * Returns 0 on success, or -1 on failure.
                    872:  */
                    873: int
                    874: rcs_lock_add(RCSFILE *file, const char *user, RCSNUM *rev)
                    875: {
                    876:        struct rcs_lock *lkp;
                    877:
                    878:        /* first look for duplication */
                    879:        TAILQ_FOREACH(lkp, &(file->rf_locks), rl_list) {
1.168     deraadt   880:                if (strcmp(lkp->rl_name, user) == 0 &&
                    881:                    rcsnum_cmp(rev, lkp->rl_num, 0) == 0) {
1.40      jfb       882:                        rcs_errno = RCS_ERR_DUPENT;
                    883:                        return (-1);
                    884:                }
                    885:        }
                    886:
1.161     ray       887:        lkp = xmalloc(sizeof(*lkp));
1.110     joris     888:        lkp->rl_name = xstrdup(user);
1.111     joris     889:        lkp->rl_num = rcsnum_alloc();
1.68      moritz    890:        rcsnum_cpy(rev, lkp->rl_num, 0);
1.40      jfb       891:
                    892:        TAILQ_INSERT_TAIL(&(file->rf_locks), lkp, rl_list);
                    893:
                    894:        /* not synced anymore */
                    895:        file->rf_flags &= ~RCS_SYNCED;
                    896:        return (0);
                    897: }
                    898:
                    899:
                    900: /*
                    901:  * rcs_lock_remove()
                    902:  *
                    903:  * Remove the RCS lock on revision <rev>.
                    904:  * Returns 0 on success, or -1 on failure.
                    905:  */
                    906: int
1.109     joris     907: rcs_lock_remove(RCSFILE *file, const char *user, RCSNUM *rev)
1.40      jfb       908: {
                    909:        struct rcs_lock *lkp;
                    910:
1.109     joris     911:        TAILQ_FOREACH(lkp, &(file->rf_locks), rl_list) {
1.168     deraadt   912:                if (strcmp(lkp->rl_name, user) == 0 &&
                    913:                    rcsnum_cmp(lkp->rl_num, rev, 0) == 0)
1.40      jfb       914:                        break;
1.109     joris     915:        }
1.40      jfb       916:
                    917:        if (lkp == NULL) {
                    918:                rcs_errno = RCS_ERR_NOENT;
                    919:                return (-1);
                    920:        }
                    921:
                    922:        TAILQ_REMOVE(&(file->rf_locks), lkp, rl_list);
                    923:        rcsnum_free(lkp->rl_num);
1.110     joris     924:        xfree(lkp->rl_name);
                    925:        xfree(lkp);
1.40      jfb       926:
                    927:        /* not synced anymore */
                    928:        file->rf_flags &= ~RCS_SYNCED;
                    929:        return (0);
                    930: }
                    931:
                    932: /*
1.27      jfb       933:  * rcs_desc_get()
                    934:  *
                    935:  * Retrieve the description for the RCS file <file>.
                    936:  */
1.57      xsa       937: const char *
1.27      jfb       938: rcs_desc_get(RCSFILE *file)
                    939: {
                    940:        return (file->rf_desc);
                    941: }
                    942:
                    943: /*
                    944:  * rcs_desc_set()
                    945:  *
                    946:  * Set the description for the RCS file <file>.
                    947:  */
1.149     xsa       948: void
1.27      jfb       949: rcs_desc_set(RCSFILE *file, const char *desc)
                    950: {
                    951:        char *tmp;
                    952:
1.110     joris     953:        tmp = xstrdup(desc);
1.27      jfb       954:        if (file->rf_desc != NULL)
1.110     joris     955:                xfree(file->rf_desc);
1.27      jfb       956:        file->rf_desc = tmp;
                    957:        file->rf_flags &= ~RCS_SYNCED;
1.51      jfb       958: }
                    959:
                    960: /*
                    961:  * rcs_comment_lookup()
                    962:  *
                    963:  * Lookup the assumed comment leader based on a file's suffix.
                    964:  * Returns a pointer to the string on success, or NULL on failure.
                    965:  */
1.57      xsa       966: const char *
1.51      jfb       967: rcs_comment_lookup(const char *filename)
                    968: {
                    969:        int i;
                    970:        const char *sp;
                    971:
                    972:        if ((sp = strrchr(filename, '.')) == NULL) {
                    973:                rcs_errno = RCS_ERR_NOENT;
                    974:                return (NULL);
                    975:        }
                    976:        sp++;
                    977:
                    978:        for (i = 0; i < (int)NB_COMTYPES; i++)
                    979:                if (strcmp(rcs_comments[i].rc_suffix, sp) == 0)
                    980:                        return (rcs_comments[i].rc_cstr);
                    981:        return (NULL);
1.27      jfb       982: }
                    983:
1.33      jfb       984: /*
                    985:  * rcs_comment_get()
                    986:  *
                    987:  * Retrieve the comment leader for the RCS file <file>.
                    988:  */
1.57      xsa       989: const char *
1.33      jfb       990: rcs_comment_get(RCSFILE *file)
                    991: {
                    992:        return (file->rf_comment);
                    993: }
                    994:
                    995: /*
                    996:  * rcs_comment_set()
                    997:  *
                    998:  * Set the comment leader for the RCS file <file>.
                    999:  */
1.150     xsa      1000: void
1.33      jfb      1001: rcs_comment_set(RCSFILE *file, const char *comment)
                   1002: {
                   1003:        char *tmp;
                   1004:
1.110     joris    1005:        tmp = xstrdup(comment);
1.33      jfb      1006:        if (file->rf_comment != NULL)
1.110     joris    1007:                xfree(file->rf_comment);
1.33      jfb      1008:        file->rf_comment = tmp;
                   1009:        file->rf_flags &= ~RCS_SYNCED;
1.40      jfb      1010: }
                   1011:
1.94      joris    1012: int
1.218     tobias   1013: rcs_patch_lines(struct cvs_lines *dlines, struct cvs_lines *plines,
                   1014:     struct cvs_line **alines, struct rcs_delta *rdp)
1.5       vincent  1015: {
1.209     otto     1016:        u_char op;
                   1017:        char *ep;
1.94      joris    1018:        struct cvs_line *lp, *dlp, *ndlp;
1.5       vincent  1019:        int i, lineno, nbln;
1.193     niallo   1020:        u_char tmp;
1.1       jfb      1021:
1.94      joris    1022:        dlp = TAILQ_FIRST(&(dlines->l_lines));
                   1023:        lp = TAILQ_FIRST(&(plines->l_lines));
1.1       jfb      1024:
                   1025:        /* skip first bogus line */
1.94      joris    1026:        for (lp = TAILQ_NEXT(lp, l_list); lp != NULL;
                   1027:            lp = TAILQ_NEXT(lp, l_list)) {
1.193     niallo   1028:                if (lp->l_len < 2)
                   1029:                        fatal("line too short, RCS patch seems broken");
1.94      joris    1030:                op = *(lp->l_line);
1.193     niallo   1031:                /* NUL-terminate line buffer for strtol() safety. */
                   1032:                tmp = lp->l_line[lp->l_len - 1];
                   1033:                lp->l_line[lp->l_len - 1] = '\0';
1.209     otto     1034:                lineno = (int)strtol((char*)(lp->l_line + 1), &ep, 10);
1.193     niallo   1035:                if (lineno - 1 > dlines->l_nblines || lineno < 0) {
                   1036:                        fatal("invalid line specification in RCS patch");
                   1037:                }
1.1       jfb      1038:                ep++;
                   1039:                nbln = (int)strtol(ep, &ep, 10);
1.193     niallo   1040:                /* Restore the last byte of the buffer */
                   1041:                lp->l_line[lp->l_len - 1] = tmp;
                   1042:                if (nbln < 0)
1.132     niallo   1043:                        fatal("invalid line number specification in RCS patch");
1.1       jfb      1044:
                   1045:                /* find the appropriate line */
                   1046:                for (;;) {
                   1047:                        if (dlp == NULL)
                   1048:                                break;
1.94      joris    1049:                        if (dlp->l_lineno == lineno)
1.1       jfb      1050:                                break;
1.94      joris    1051:                        if (dlp->l_lineno > lineno) {
                   1052:                                dlp = TAILQ_PREV(dlp, cvs_tqh, l_list);
                   1053:                        } else if (dlp->l_lineno < lineno) {
1.133     niallo   1054:                                if (((ndlp = TAILQ_NEXT(dlp, l_list)) == NULL) ||
1.168     deraadt  1055:                                    ndlp->l_lineno > lineno)
1.1       jfb      1056:                                        break;
                   1057:                                dlp = ndlp;
                   1058:                        }
                   1059:                }
1.132     niallo   1060:                if (dlp == NULL)
                   1061:                        fatal("can't find referenced line in RCS patch");
1.1       jfb      1062:
                   1063:                if (op == 'd') {
                   1064:                        for (i = 0; (i < nbln) && (dlp != NULL); i++) {
1.94      joris    1065:                                ndlp = TAILQ_NEXT(dlp, l_list);
                   1066:                                TAILQ_REMOVE(&(dlines->l_lines), dlp, l_list);
1.218     tobias   1067:                                if (alines != NULL && dlp->l_line != NULL) {
                   1068:                                        dlp->l_delta = rdp;
                   1069:                                        alines[dlp->l_lineno_orig - 1] =
                   1070:                                                dlp;
                   1071:                                } else
                   1072:                                        xfree(dlp);
1.1       jfb      1073:                                dlp = ndlp;
1.133     niallo   1074:                                /* last line is gone - reset dlp */
                   1075:                                if (dlp == NULL) {
                   1076:                                        ndlp = TAILQ_LAST(&(dlines->l_lines),
                   1077:                                            cvs_tqh);
                   1078:                                        dlp = ndlp;
                   1079:                                }
1.1       jfb      1080:                        }
1.14      deraadt  1081:                } else if (op == 'a') {
1.1       jfb      1082:                        for (i = 0; i < nbln; i++) {
                   1083:                                ndlp = lp;
1.94      joris    1084:                                lp = TAILQ_NEXT(lp, l_list);
1.132     niallo   1085:                                if (lp == NULL)
                   1086:                                        fatal("truncated RCS patch");
1.94      joris    1087:                                TAILQ_REMOVE(&(plines->l_lines), lp, l_list);
1.218     tobias   1088:                                if (alines != NULL) {
                   1089:                                        if (lp->l_needsfree == 1)
                   1090:                                                xfree(lp->l_line);
                   1091:                                        lp->l_line = NULL;
                   1092:                                        lp->l_needsfree = 0;
                   1093:                                }
1.94      joris    1094:                                TAILQ_INSERT_AFTER(&(dlines->l_lines), dlp,
                   1095:                                    lp, l_list);
1.1       jfb      1096:                                dlp = lp;
                   1097:
                   1098:                                /* we don't want lookup to block on those */
1.94      joris    1099:                                lp->l_lineno = lineno;
1.1       jfb      1100:
                   1101:                                lp = ndlp;
                   1102:                        }
1.132     niallo   1103:                } else
                   1104:                        fatal("unknown RCS patch operation `%c'", op);
1.1       jfb      1105:
                   1106:                /* last line of the patch, done */
1.94      joris    1107:                if (lp->l_lineno == plines->l_nblines)
1.1       jfb      1108:                        break;
                   1109:        }
                   1110:
                   1111:        /* once we're done patching, rebuild the line numbers */
1.2       vincent  1112:        lineno = 0;
1.94      joris    1113:        TAILQ_FOREACH(lp, &(dlines->l_lines), l_list)
                   1114:                lp->l_lineno = lineno++;
                   1115:        dlines->l_nblines = lineno - 1;
1.1       jfb      1116:
1.5       vincent  1117:        return (0);
1.1       jfb      1118: }
                   1119:
                   1120: /*
1.52      jfb      1121:  * rcs_rev_add()
                   1122:  *
1.53      jfb      1123:  * Add a revision to the RCS file <rf>.  The new revision's number can be
                   1124:  * specified in <rev> (which can also be RCS_HEAD_REV, in which case the
                   1125:  * new revision will have a number equal to the previous head revision plus
                   1126:  * one).  The <msg> argument specifies the log message for that revision, and
                   1127:  * <date> specifies the revision's date (a value of -1 is
                   1128:  * equivalent to using the current time).
1.96      xsa      1129:  * If <username> is NULL, set the author for this revision to the current user.
1.90      niallo   1130:  * Otherwise, set it to <username>.
1.52      jfb      1131:  * Returns 0 on success, or -1 on failure.
                   1132:  */
                   1133: int
1.90      niallo   1134: rcs_rev_add(RCSFILE *rf, RCSNUM *rev, const char *msg, time_t date,
                   1135:     const char *username)
1.52      jfb      1136: {
                   1137:        time_t now;
                   1138:        struct passwd *pw;
1.180     joris    1139:        struct rcs_branch *brp;
1.83      joris    1140:        struct rcs_delta *ordp, *rdp;
                   1141:
1.52      jfb      1142:        if (rev == RCS_HEAD_REV) {
1.101     niallo   1143:                if (rf->rf_flags & RCS_CREATE) {
                   1144:                        if ((rev = rcsnum_parse(RCS_HEAD_INIT)) == NULL)
                   1145:                                return (-1);
1.111     joris    1146:                        rf->rf_head = rcsnum_alloc();
1.101     niallo   1147:                        rcsnum_cpy(rev, rf->rf_head, 0);
                   1148:                } else {
                   1149:                        rev = rcsnum_inc(rf->rf_head);
                   1150:                }
1.83      joris    1151:        } else {
                   1152:                if ((rdp = rcs_findrev(rf, rev)) != NULL) {
                   1153:                        rcs_errno = RCS_ERR_DUPENT;
                   1154:                        return (-1);
                   1155:                }
1.52      jfb      1156:        }
                   1157:
1.112     xsa      1158:        if ((pw = getpwuid(getuid())) == NULL)
                   1159:                fatal("getpwuid failed");
1.52      jfb      1160:
1.161     ray      1161:        rdp = xcalloc(1, sizeof(*rdp));
1.52      jfb      1162:
                   1163:        TAILQ_INIT(&(rdp->rd_branches));
                   1164:
1.111     joris    1165:        rdp->rd_num = rcsnum_alloc();
1.52      jfb      1166:        rcsnum_cpy(rev, rdp->rd_num, 0);
1.83      joris    1167:
1.111     joris    1168:        rdp->rd_next = rcsnum_alloc();
1.92      joris    1169:
1.90      niallo   1170:        if (username == NULL)
                   1171:                username = pw->pw_name;
                   1172:
1.110     joris    1173:        rdp->rd_author = xstrdup(username);
                   1174:        rdp->rd_state = xstrdup(RCS_STATE_EXP);
                   1175:        rdp->rd_log = xstrdup(msg);
1.52      jfb      1176:
1.53      jfb      1177:        if (date != (time_t)(-1))
                   1178:                now = date;
                   1179:        else
                   1180:                time(&now);
1.52      jfb      1181:        gmtime_r(&now, &(rdp->rd_date));
                   1182:
1.180     joris    1183:        if (RCSNUM_ISBRANCHREV(rev))
                   1184:                TAILQ_INSERT_TAIL(&(rf->rf_delta), rdp, rd_list);
                   1185:        else
                   1186:                TAILQ_INSERT_HEAD(&(rf->rf_delta), rdp, rd_list);
1.52      jfb      1187:        rf->rf_ndelta++;
1.81      niallo   1188:
1.180     joris    1189:        if (!(rf->rf_flags & RCS_CREATE)) {
                   1190:                if (RCSNUM_ISBRANCHREV(rev)) {
                   1191:                        brp = xmalloc(sizeof(*brp));
                   1192:                        brp->rb_num = rcsnum_alloc();
                   1193:                        rcsnum_cpy(rdp->rd_num, brp->rb_num, 0);
                   1194:                        TAILQ_INSERT_TAIL(&(rdp->rd_branches), brp, rb_list);
1.208     otto     1195:                        ordp = TAILQ_PREV(rdp, rcs_dlist, rd_list);
1.180     joris    1196:                        rcsnum_cpy(rdp->rd_num, ordp->rd_next, 0);
                   1197:                } else {
                   1198:                        ordp = TAILQ_NEXT(rdp, rd_list);
                   1199:                        rcsnum_cpy(ordp->rd_num, rdp->rd_next, 0);
                   1200:                }
                   1201:        }
                   1202:
1.64      niallo   1203:        /* not synced anymore */
                   1204:        rf->rf_flags &= ~RCS_SYNCED;
1.52      jfb      1205:
                   1206:        return (0);
                   1207: }
                   1208:
                   1209: /*
                   1210:  * rcs_rev_remove()
                   1211:  *
                   1212:  * Remove the revision whose number is <rev> from the RCS file <rf>.
                   1213:  */
                   1214: int
                   1215: rcs_rev_remove(RCSFILE *rf, RCSNUM *rev)
                   1216: {
1.194     joris    1217:        char *path_tmp1, *path_tmp2;
1.166     joris    1218:        struct rcs_delta *rdp, *prevrdp, *nextrdp;
1.209     otto     1219:        BUF *prevbuf, *newdiff, *newdeltatext;
1.166     joris    1220:
1.52      jfb      1221:        if (rev == RCS_HEAD_REV)
                   1222:                rev = rf->rf_head;
                   1223:
                   1224:        /* do we actually have that revision? */
                   1225:        if ((rdp = rcs_findrev(rf, rev)) == NULL) {
                   1226:                rcs_errno = RCS_ERR_NOENT;
1.166     joris    1227:                return (-1);
                   1228:        }
                   1229:
                   1230:        /*
                   1231:         * This is confusing, the previous delta is next in the TAILQ list.
                   1232:         * the next delta is the previous one in the TAILQ list.
                   1233:         *
                   1234:         * When the HEAD revision got specified, nextrdp will be NULL.
                   1235:         * When the first revision got specified, prevrdp will be NULL.
                   1236:         */
                   1237:        prevrdp = (struct rcs_delta *)TAILQ_NEXT(rdp, rd_list);
                   1238:        nextrdp = (struct rcs_delta *)TAILQ_PREV(rdp, cvs_tqh, rd_list);
                   1239:
                   1240:        newdeltatext = NULL;
1.209     otto     1241:        prevbuf = NULL;
1.166     joris    1242:
1.168     deraadt  1243:        if (prevrdp != NULL && nextrdp != NULL) {
1.166     joris    1244:                newdiff = cvs_buf_alloc(64, BUF_AUTOEXT);
                   1245:
                   1246:                /* calculate new diff */
1.172     joris    1247:                (void)xasprintf(&path_tmp1, "%s/diff1.XXXXXXXXXX", cvs_tmpdir);
1.196     niallo   1248:                rcs_rev_write_stmp(rf, nextrdp->rd_num, path_tmp1, 0);
1.166     joris    1249:
1.172     joris    1250:                (void)xasprintf(&path_tmp2, "%s/diff2.XXXXXXXXXX", cvs_tmpdir);
1.196     niallo   1251:                rcs_rev_write_stmp(rf, prevrdp->rd_num, path_tmp2, 0);
1.166     joris    1252:
                   1253:                diff_format = D_RCSDIFF;
1.172     joris    1254:                if (cvs_diffreg(path_tmp1, path_tmp2, newdiff) == D_ERROR)
                   1255:                        fatal("rcs_diffreg failed");
1.166     joris    1256:
1.194     joris    1257:                newdeltatext = newdiff;
1.168     deraadt  1258:        } else if (nextrdp == NULL && prevrdp != NULL) {
1.194     joris    1259:                newdeltatext = prevbuf;
1.166     joris    1260:        }
                   1261:
                   1262:        if (newdeltatext != NULL) {
                   1263:                if (rcs_deltatext_set(rf, prevrdp->rd_num, newdeltatext) < 0)
                   1264:                        fatal("error setting new deltatext");
                   1265:        }
                   1266:
                   1267:        TAILQ_REMOVE(&(rf->rf_delta), rdp, rd_list);
                   1268:
                   1269:        /* update pointers */
1.168     deraadt  1270:        if (prevrdp != NULL && nextrdp != NULL) {
1.166     joris    1271:                rcsnum_cpy(prevrdp->rd_num, nextrdp->rd_next, 0);
                   1272:        } else if (prevrdp != NULL) {
1.170     xsa      1273:                if (rcs_head_set(rf, prevrdp->rd_num) < 0)
                   1274:                        fatal("rcs_head_set failed");
1.166     joris    1275:        } else if (nextrdp != NULL) {
                   1276:                rcsnum_free(nextrdp->rd_next);
                   1277:                nextrdp->rd_next = rcsnum_alloc();
1.52      jfb      1278:        } else {
1.166     joris    1279:                rcsnum_free(rf->rf_head);
                   1280:                rf->rf_head = NULL;
1.52      jfb      1281:        }
                   1282:
1.166     joris    1283:        rf->rf_ndelta--;
                   1284:        rf->rf_flags &= ~RCS_SYNCED;
                   1285:
                   1286:        rcs_freedelta(rdp);
                   1287:
                   1288:        if (newdeltatext != NULL)
                   1289:                xfree(newdeltatext);
1.52      jfb      1290:
1.172     joris    1291:        if (path_tmp1 != NULL)
                   1292:                xfree(path_tmp1);
                   1293:        if (path_tmp2 != NULL)
                   1294:                xfree(path_tmp2);
                   1295:
1.166     joris    1296:        return (0);
1.52      jfb      1297: }
                   1298:
                   1299: /*
1.1       jfb      1300:  * rcs_findrev()
                   1301:  *
                   1302:  * Find a specific revision's delta entry in the tree of the RCS file <rfp>.
                   1303:  * The revision number is given in <rev>.
1.156     joris    1304:  *
1.1       jfb      1305:  * Returns a pointer to the delta on success, or NULL on failure.
                   1306:  */
1.102     xsa      1307: struct rcs_delta *
1.117     niallo   1308: rcs_findrev(RCSFILE *rfp, RCSNUM *rev)
1.1       jfb      1309: {
1.178     joris    1310:        int isbrev;
1.156     joris    1311:        struct rcs_delta *rdp;
1.178     joris    1312:
                   1313:        isbrev = RCSNUM_ISBRANCHREV(rev);
1.26      jfb      1314:
1.117     niallo   1315:        /*
                   1316:         * We need to do more parsing if the last revision in the linked list
                   1317:         * is greater than the requested revision.
                   1318:         */
1.156     joris    1319:        rdp = TAILQ_LAST(&(rfp->rf_delta), rcs_dlist);
1.168     deraadt  1320:        if (rdp == NULL ||
1.178     joris    1321:            (!isbrev && rcsnum_cmp(rdp->rd_num, rev, 0) == -1) ||
                   1322:            ((isbrev && rdp->rd_num->rn_len < 4) ||
                   1323:            (isbrev && rcsnum_differ(rev, rdp->rd_num)))) {
1.117     niallo   1324:                rcs_parse_deltas(rfp, rev);
                   1325:        }
                   1326:
1.156     joris    1327:        TAILQ_FOREACH(rdp, &(rfp->rf_delta), rd_list) {
1.178     joris    1328:                if (rcsnum_differ(rdp->rd_num, rev))
                   1329:                        continue;
                   1330:                else
1.156     joris    1331:                        return (rdp);
                   1332:        }
1.1       jfb      1333:
                   1334:        return (NULL);
1.20      jfb      1335: }
                   1336:
                   1337: /*
1.26      jfb      1338:  * rcs_kwexp_set()
                   1339:  *
                   1340:  * Set the keyword expansion mode to use on the RCS file <file> to <mode>.
                   1341:  */
1.162     xsa      1342: void
1.26      jfb      1343: rcs_kwexp_set(RCSFILE *file, int mode)
                   1344: {
                   1345:        int i;
                   1346:        char *tmp, buf[8] = "";
                   1347:
                   1348:        if (RCS_KWEXP_INVAL(mode))
1.162     xsa      1349:                return;
1.26      jfb      1350:
                   1351:        i = 0;
                   1352:        if (mode == RCS_KWEXP_NONE)
                   1353:                buf[0] = 'b';
                   1354:        else if (mode == RCS_KWEXP_OLD)
                   1355:                buf[0] = 'o';
                   1356:        else {
                   1357:                if (mode & RCS_KWEXP_NAME)
                   1358:                        buf[i++] = 'k';
                   1359:                if (mode & RCS_KWEXP_VAL)
                   1360:                        buf[i++] = 'v';
                   1361:                if (mode & RCS_KWEXP_LKR)
                   1362:                        buf[i++] = 'l';
                   1363:        }
                   1364:
1.110     joris    1365:        tmp = xstrdup(buf);
1.27      jfb      1366:        if (file->rf_expand != NULL)
1.147     ray      1367:                xfree(file->rf_expand);
1.26      jfb      1368:        file->rf_expand = tmp;
1.64      niallo   1369:        /* not synced anymore */
                   1370:        file->rf_flags &= ~RCS_SYNCED;
1.26      jfb      1371: }
                   1372:
                   1373: /*
                   1374:  * rcs_kwexp_get()
                   1375:  *
                   1376:  * Retrieve the keyword expansion mode to be used for the RCS file <file>.
                   1377:  */
                   1378: int
                   1379: rcs_kwexp_get(RCSFILE *file)
                   1380: {
                   1381:        return rcs_kflag_get(file->rf_expand);
                   1382: }
                   1383:
                   1384: /*
1.20      jfb      1385:  * rcs_kflag_get()
                   1386:  *
                   1387:  * Get the keyword expansion mode from a set of character flags given in
                   1388:  * <flags> and return the appropriate flag mask.  In case of an error, the
                   1389:  * returned mask will have the RCS_KWEXP_ERR bit set to 1.
                   1390:  */
                   1391: int
                   1392: rcs_kflag_get(const char *flags)
                   1393: {
                   1394:        int fl;
                   1395:        size_t len;
                   1396:        const char *fp;
                   1397:
                   1398:        fl = 0;
                   1399:        len = strlen(flags);
                   1400:
                   1401:        for (fp = flags; *fp != '\0'; fp++) {
                   1402:                if (*fp == 'k')
                   1403:                        fl |= RCS_KWEXP_NAME;
                   1404:                else if (*fp == 'v')
                   1405:                        fl |= RCS_KWEXP_VAL;
                   1406:                else if (*fp == 'l')
                   1407:                        fl |= RCS_KWEXP_LKR;
                   1408:                else if (*fp == 'o') {
                   1409:                        if (len != 1)
                   1410:                                fl |= RCS_KWEXP_ERR;
                   1411:                        fl |= RCS_KWEXP_OLD;
                   1412:                } else if (*fp == 'b') {
                   1413:                        if (len != 1)
                   1414:                                fl |= RCS_KWEXP_ERR;
1.205     xsa      1415:                        fl |= RCS_KWEXP_NONE;
1.20      jfb      1416:                } else  /* unknown letter */
                   1417:                        fl |= RCS_KWEXP_ERR;
                   1418:        }
                   1419:
                   1420:        return (fl);
1.32      jfb      1421: }
                   1422:
                   1423: /*
                   1424:  * rcs_errstr()
                   1425:  *
                   1426:  * Get the error string matching the RCS error code <code>.
                   1427:  */
1.57      xsa      1428: const char *
1.32      jfb      1429: rcs_errstr(int code)
                   1430: {
1.50      jfb      1431:        const char *esp;
                   1432:
1.168     deraadt  1433:        if (code < 0 || (code >= (int)RCS_NERR && code != RCS_ERR_ERRNO))
1.50      jfb      1434:                esp = NULL;
                   1435:        else if (code == RCS_ERR_ERRNO)
                   1436:                esp = strerror(errno);
                   1437:        else
                   1438:                esp = rcs_errstrs[code];
                   1439:        return (esp);
1.1       jfb      1440: }
                   1441:
1.117     niallo   1442: /* rcs_parse_deltas()
                   1443:  *
                   1444:  * Parse deltas. If <rev> is not NULL, parse only as far as that
                   1445:  * revision. If <rev> is NULL, parse all deltas.
                   1446:  */
1.146     xsa      1447: static void
1.117     niallo   1448: rcs_parse_deltas(RCSFILE *rfp, RCSNUM *rev)
                   1449: {
                   1450:        int ret;
                   1451:        struct rcs_delta *enddelta;
1.146     xsa      1452:
                   1453:        if ((rfp->rf_flags & PARSED_DELTAS) || (rfp->rf_flags & RCS_CREATE))
                   1454:                return;
                   1455:
1.117     niallo   1456:        for (;;) {
                   1457:                ret = rcs_parse_delta(rfp);
                   1458:                if (rev != NULL) {
                   1459:                        enddelta = TAILQ_LAST(&(rfp->rf_delta), rcs_dlist);
1.155     ray      1460:                        if (rcsnum_cmp(enddelta->rd_num, rev, 0) == 0)
1.117     niallo   1461:                                break;
                   1462:                }
1.180     joris    1463:
1.117     niallo   1464:                if (ret == 0) {
                   1465:                        rfp->rf_flags |= PARSED_DELTAS;
                   1466:                        break;
                   1467:                }
                   1468:                else if (ret == -1)
                   1469:                        fatal("error parsing deltas");
                   1470:        }
                   1471: }
                   1472:
                   1473: /* rcs_parse_deltatexts()
                   1474:  *
                   1475:  * Parse deltatexts. If <rev> is not NULL, parse only as far as that
                   1476:  * revision. If <rev> is NULL, parse everything.
                   1477:  */
1.146     xsa      1478: static void
1.117     niallo   1479: rcs_parse_deltatexts(RCSFILE *rfp, RCSNUM *rev)
                   1480: {
                   1481:        int ret;
                   1482:        struct rcs_delta *rdp;
1.146     xsa      1483:
1.168     deraadt  1484:        if ((rfp->rf_flags & PARSED_DELTATEXTS) ||
                   1485:            (rfp->rf_flags & RCS_CREATE))
1.146     xsa      1486:                return;
                   1487:
1.117     niallo   1488:        if (!(rfp->rf_flags & PARSED_DESC))
                   1489:                rcs_parse_desc(rfp, rev);
                   1490:        for (;;) {
                   1491:                if (rev != NULL) {
                   1492:                        rdp = rcs_findrev(rfp, rev);
                   1493:                        if (rdp->rd_text != NULL)
                   1494:                                break;
                   1495:                        else
                   1496:                                ret = rcs_parse_deltatext(rfp);
                   1497:                } else
                   1498:                        ret = rcs_parse_deltatext(rfp);
                   1499:                if (ret == 0) {
                   1500:                        rfp->rf_flags |= PARSED_DELTATEXTS;
                   1501:                        break;
                   1502:                }
1.146     xsa      1503:                else if (ret == -1)
1.117     niallo   1504:                        fatal("problem parsing deltatexts");
                   1505:        }
                   1506: }
                   1507:
                   1508: /* rcs_parse_desc()
                   1509:  *
                   1510:  * Parse RCS description.
                   1511:  */
1.148     xsa      1512: static void
1.117     niallo   1513: rcs_parse_desc(RCSFILE *rfp, RCSNUM *rev)
                   1514: {
                   1515:        int ret = 0;
1.148     xsa      1516:
                   1517:        if ((rfp->rf_flags & PARSED_DESC) || (rfp->rf_flags & RCS_CREATE))
                   1518:                return;
1.122     reyk     1519:        if (!(rfp->rf_flags & PARSED_DELTAS))
1.117     niallo   1520:                rcs_parse_deltas(rfp, rev);
                   1521:        /* do parsing */
                   1522:        ret = rcs_gettok(rfp);
1.148     xsa      1523:        if (ret != RCS_TOK_DESC)
                   1524:                fatal("token `%s' found where RCS desc expected",
1.117     niallo   1525:                    RCS_TOKSTR(rfp));
                   1526:
                   1527:        ret = rcs_gettok(rfp);
1.148     xsa      1528:        if (ret != RCS_TOK_STRING)
                   1529:                fatal("token `%s' found where RCS desc expected",
1.117     niallo   1530:                    RCS_TOKSTR(rfp));
                   1531:
                   1532:        rfp->rf_desc = xstrdup(RCS_TOKSTR(rfp));
                   1533:        rfp->rf_flags |= PARSED_DESC;
                   1534: }
                   1535:
1.1       jfb      1536: /*
1.117     niallo   1537:  * rcs_parse_init()
1.1       jfb      1538:  *
1.117     niallo   1539:  * Initial parsing of file <path>, which are in the RCS format.
1.167     ray      1540:  * Just does admin section.
1.1       jfb      1541:  */
1.167     ray      1542: static void
1.117     niallo   1543: rcs_parse_init(RCSFILE *rfp)
1.1       jfb      1544: {
                   1545:        struct rcs_pdata *pdp;
                   1546:
1.26      jfb      1547:        if (rfp->rf_flags & RCS_PARSED)
1.167     ray      1548:                return;
1.1       jfb      1549:
1.161     ray      1550:        pdp = xcalloc(1, sizeof(*pdp));
1.1       jfb      1551:
1.18      jfb      1552:        pdp->rp_lines = 0;
1.1       jfb      1553:        pdp->rp_pttype = RCS_TOK_ERR;
                   1554:
1.172     joris    1555:        if ((pdp->rp_file = fdopen(rfp->fd, "r")) == NULL)
1.216     xsa      1556:                fatal("fdopen: `%s'", rfp->rf_path);
1.1       jfb      1557:
1.161     ray      1558:        pdp->rp_buf = xmalloc((size_t)RCS_BUFSIZE);
1.1       jfb      1559:        pdp->rp_blen = RCS_BUFSIZE;
1.18      jfb      1560:        pdp->rp_bufend = pdp->rp_buf + pdp->rp_blen - 1;
1.1       jfb      1561:
                   1562:        /* ditch the strict lock */
1.26      jfb      1563:        rfp->rf_flags &= ~RCS_SLOCK;
1.1       jfb      1564:        rfp->rf_pdata = pdp;
                   1565:
1.167     ray      1566:        if (rcs_parse_admin(rfp) < 0) {
1.1       jfb      1567:                rcs_freepdata(pdp);
1.117     niallo   1568:                fatal("could not parse admin data");
1.1       jfb      1569:        }
                   1570:
1.117     niallo   1571:        if (rfp->rf_flags & RCS_PARSE_FULLY)
                   1572:                rcs_parse_deltatexts(rfp, NULL);
1.1       jfb      1573:
1.117     niallo   1574:        rfp->rf_flags |= RCS_SYNCED;
1.1       jfb      1575: }
                   1576:
                   1577: /*
                   1578:  * rcs_parse_admin()
                   1579:  *
                   1580:  * Parse the administrative portion of an RCS file.
1.31      jfb      1581:  * Returns the type of the first token found after the admin section on
                   1582:  * success, or -1 on failure.
1.1       jfb      1583:  */
                   1584: static int
                   1585: rcs_parse_admin(RCSFILE *rfp)
                   1586: {
                   1587:        u_int i;
                   1588:        int tok, ntok, hmask;
                   1589:        struct rcs_key *rk;
                   1590:
1.180     joris    1591:        rfp->rf_head = NULL;
                   1592:        rfp->rf_branch = NULL;
                   1593:
1.1       jfb      1594:        /* hmask is a mask of the headers already encountered */
                   1595:        hmask = 0;
                   1596:        for (;;) {
                   1597:                tok = rcs_gettok(rfp);
                   1598:                if (tok == RCS_TOK_ERR) {
1.50      jfb      1599:                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1600:                        cvs_log(LP_ERR, "parse error in RCS admin section");
1.147     ray      1601:                        goto fail;
1.168     deraadt  1602:                } else if (tok == RCS_TOK_NUM || tok == RCS_TOK_DESC) {
1.31      jfb      1603:                        /*
                   1604:                         * Assume this is the start of the first delta or
                   1605:                         * that we are dealing with an empty RCS file and
                   1606:                         * we just found the description.
                   1607:                         */
1.1       jfb      1608:                        rcs_pushtok(rfp, RCS_TOKSTR(rfp), tok);
1.31      jfb      1609:                        return (tok);
1.1       jfb      1610:                }
                   1611:
                   1612:                rk = NULL;
1.18      jfb      1613:                for (i = 0; i < RCS_NKEYS; i++)
1.1       jfb      1614:                        if (rcs_keys[i].rk_id == tok)
                   1615:                                rk = &(rcs_keys[i]);
                   1616:
                   1617:                if (hmask & (1 << tok)) {
1.50      jfb      1618:                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1619:                        cvs_log(LP_ERR, "duplicate RCS key");
1.147     ray      1620:                        goto fail;
1.1       jfb      1621:                }
                   1622:                hmask |= (1 << tok);
                   1623:
                   1624:                switch (tok) {
                   1625:                case RCS_TOK_HEAD:
                   1626:                case RCS_TOK_BRANCH:
                   1627:                case RCS_TOK_COMMENT:
                   1628:                case RCS_TOK_EXPAND:
                   1629:                        ntok = rcs_gettok(rfp);
                   1630:                        if (ntok == RCS_TOK_SCOLON)
                   1631:                                break;
                   1632:                        if (ntok != rk->rk_val) {
1.50      jfb      1633:                                rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1634:                                cvs_log(LP_ERR,
                   1635:                                    "invalid value type for RCS key `%s'",
                   1636:                                    rk->rk_str);
                   1637:                        }
                   1638:
                   1639:                        if (tok == RCS_TOK_HEAD) {
1.111     joris    1640:                                if (rfp->rf_head == NULL)
1.28      jfb      1641:                                        rfp->rf_head = rcsnum_alloc();
1.1       jfb      1642:                                rcsnum_aton(RCS_TOKSTR(rfp), NULL,
                   1643:                                    rfp->rf_head);
1.14      deraadt  1644:                        } else if (tok == RCS_TOK_BRANCH) {
1.111     joris    1645:                                if (rfp->rf_branch == NULL)
1.35      jfb      1646:                                        rfp->rf_branch = rcsnum_alloc();
                   1647:                                if (rcsnum_aton(RCS_TOKSTR(rfp), NULL,
                   1648:                                    rfp->rf_branch) < 0)
1.147     ray      1649:                                        goto fail;
1.14      deraadt  1650:                        } else if (tok == RCS_TOK_COMMENT) {
1.110     joris    1651:                                rfp->rf_comment = xstrdup(RCS_TOKSTR(rfp));
1.14      deraadt  1652:                        } else if (tok == RCS_TOK_EXPAND) {
1.110     joris    1653:                                rfp->rf_expand = xstrdup(RCS_TOKSTR(rfp));
1.1       jfb      1654:                        }
                   1655:
                   1656:                        /* now get the expected semi-colon */
                   1657:                        ntok = rcs_gettok(rfp);
                   1658:                        if (ntok != RCS_TOK_SCOLON) {
1.50      jfb      1659:                                rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1660:                                cvs_log(LP_ERR,
                   1661:                                    "missing semi-colon after RCS `%s' key",
1.26      jfb      1662:                                    rk->rk_str);
1.147     ray      1663:                                goto fail;
1.1       jfb      1664:                        }
                   1665:                        break;
                   1666:                case RCS_TOK_ACCESS:
1.29      jfb      1667:                        if (rcs_parse_access(rfp) < 0)
1.147     ray      1668:                                goto fail;
1.1       jfb      1669:                        break;
                   1670:                case RCS_TOK_SYMBOLS:
1.29      jfb      1671:                        if (rcs_parse_symbols(rfp) < 0)
1.147     ray      1672:                                goto fail;
1.1       jfb      1673:                        break;
                   1674:                case RCS_TOK_LOCKS:
1.29      jfb      1675:                        if (rcs_parse_locks(rfp) < 0)
1.147     ray      1676:                                goto fail;
1.1       jfb      1677:                        break;
                   1678:                default:
1.50      jfb      1679:                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1680:                        cvs_log(LP_ERR,
                   1681:                            "unexpected token `%s' in RCS admin section",
                   1682:                            RCS_TOKSTR(rfp));
1.147     ray      1683:                        goto fail;
1.1       jfb      1684:                }
                   1685:        }
                   1686:
1.147     ray      1687: fail:
                   1688:        return (-1);
1.1       jfb      1689: }
                   1690:
                   1691: /*
                   1692:  * rcs_parse_delta()
                   1693:  *
                   1694:  * Parse an RCS delta section and allocate the structure to store that delta's
                   1695:  * information in the <rfp> delta list.
                   1696:  * Returns 1 if the section was parsed OK, 0 if it is the last delta, and
                   1697:  * -1 on error.
                   1698:  */
                   1699: static int
                   1700: rcs_parse_delta(RCSFILE *rfp)
                   1701: {
                   1702:        int ret, tok, ntok, hmask;
                   1703:        u_int i;
                   1704:        char *tokstr;
1.3       vincent  1705:        RCSNUM *datenum;
1.1       jfb      1706:        struct rcs_delta *rdp;
                   1707:        struct rcs_key *rk;
                   1708:
                   1709:        tok = rcs_gettok(rfp);
1.154     ray      1710:        if (tok == RCS_TOK_DESC) {
                   1711:                rcs_pushtok(rfp, RCS_TOKSTR(rfp), tok);
                   1712:                return (0);
                   1713:        } else if (tok != RCS_TOK_NUM) {
1.52      jfb      1714:                rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1715:                cvs_log(LP_ERR, "unexpected token `%s' at start of delta",
                   1716:                    RCS_TOKSTR(rfp));
                   1717:                return (-1);
                   1718:        }
1.192     niallo   1719:
                   1720:        rdp = xcalloc(1, sizeof(*rdp));
                   1721:
                   1722:        rdp->rd_num = rcsnum_alloc();
                   1723:        rdp->rd_next = rcsnum_alloc();
                   1724:
                   1725:        TAILQ_INIT(&(rdp->rd_branches));
                   1726:
1.1       jfb      1727:        rcsnum_aton(RCS_TOKSTR(rfp), NULL, rdp->rd_num);
                   1728:
                   1729:        hmask = 0;
                   1730:        ret = 0;
                   1731:        tokstr = NULL;
                   1732:
                   1733:        for (;;) {
                   1734:                tok = rcs_gettok(rfp);
                   1735:                if (tok == RCS_TOK_ERR) {
1.50      jfb      1736:                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1737:                        cvs_log(LP_ERR, "parse error in RCS delta section");
                   1738:                        rcs_freedelta(rdp);
                   1739:                        return (-1);
1.14      deraadt  1740:                } else if (tok == RCS_TOK_NUM || tok == RCS_TOK_DESC) {
1.15      tedu     1741:                        rcs_pushtok(rfp, RCS_TOKSTR(rfp), tok);
1.1       jfb      1742:                        ret = (tok == RCS_TOK_NUM ? 1 : 0);
                   1743:                        break;
                   1744:                }
                   1745:
                   1746:                rk = NULL;
1.18      jfb      1747:                for (i = 0; i < RCS_NKEYS; i++)
1.1       jfb      1748:                        if (rcs_keys[i].rk_id == tok)
                   1749:                                rk = &(rcs_keys[i]);
                   1750:
                   1751:                if (hmask & (1 << tok)) {
1.50      jfb      1752:                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1753:                        cvs_log(LP_ERR, "duplicate RCS key");
                   1754:                        rcs_freedelta(rdp);
                   1755:                        return (-1);
                   1756:                }
                   1757:                hmask |= (1 << tok);
                   1758:
                   1759:                switch (tok) {
                   1760:                case RCS_TOK_DATE:
                   1761:                case RCS_TOK_AUTHOR:
                   1762:                case RCS_TOK_STATE:
                   1763:                case RCS_TOK_NEXT:
                   1764:                        ntok = rcs_gettok(rfp);
                   1765:                        if (ntok == RCS_TOK_SCOLON) {
                   1766:                                if (rk->rk_flags & RCS_VOPT)
                   1767:                                        break;
                   1768:                                else {
1.50      jfb      1769:                                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1770:                                        cvs_log(LP_ERR, "missing mandatory "
                   1771:                                            "value to RCS key `%s'",
                   1772:                                            rk->rk_str);
                   1773:                                        rcs_freedelta(rdp);
                   1774:                                        return (-1);
                   1775:                                }
                   1776:                        }
                   1777:
                   1778:                        if (ntok != rk->rk_val) {
1.50      jfb      1779:                                rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1780:                                cvs_log(LP_ERR,
                   1781:                                    "invalid value type for RCS key `%s'",
                   1782:                                    rk->rk_str);
                   1783:                                rcs_freedelta(rdp);
                   1784:                                return (-1);
                   1785:                        }
                   1786:
                   1787:                        if (tokstr != NULL)
1.110     joris    1788:                                xfree(tokstr);
                   1789:                        tokstr = xstrdup(RCS_TOKSTR(rfp));
1.1       jfb      1790:                        /* now get the expected semi-colon */
                   1791:                        ntok = rcs_gettok(rfp);
                   1792:                        if (ntok != RCS_TOK_SCOLON) {
1.50      jfb      1793:                                rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1794:                                cvs_log(LP_ERR,
                   1795:                                    "missing semi-colon after RCS `%s' key",
1.26      jfb      1796:                                    rk->rk_str);
1.110     joris    1797:                                xfree(tokstr);
1.1       jfb      1798:                                rcs_freedelta(rdp);
                   1799:                                return (-1);
                   1800:                        }
                   1801:
                   1802:                        if (tok == RCS_TOK_DATE) {
1.25      jfb      1803:                                if ((datenum = rcsnum_parse(tokstr)) == NULL) {
1.110     joris    1804:                                        xfree(tokstr);
1.11      joris    1805:                                        rcs_freedelta(rdp);
                   1806:                                        return (-1);
                   1807:                                }
1.3       vincent  1808:                                if (datenum->rn_len != 6) {
1.50      jfb      1809:                                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1810:                                        cvs_log(LP_ERR,
                   1811:                                            "RCS date specification has %s "
                   1812:                                            "fields",
1.3       vincent  1813:                                            (datenum->rn_len > 6) ? "too many" :
1.1       jfb      1814:                                            "missing");
1.110     joris    1815:                                        xfree(tokstr);
1.1       jfb      1816:                                        rcs_freedelta(rdp);
1.37      tedu     1817:                                        rcsnum_free(datenum);
                   1818:                                        return (-1);
1.1       jfb      1819:                                }
1.3       vincent  1820:                                rdp->rd_date.tm_year = datenum->rn_id[0];
1.19      jfb      1821:                                if (rdp->rd_date.tm_year >= 1900)
                   1822:                                        rdp->rd_date.tm_year -= 1900;
1.3       vincent  1823:                                rdp->rd_date.tm_mon = datenum->rn_id[1] - 1;
                   1824:                                rdp->rd_date.tm_mday = datenum->rn_id[2];
                   1825:                                rdp->rd_date.tm_hour = datenum->rn_id[3];
                   1826:                                rdp->rd_date.tm_min = datenum->rn_id[4];
                   1827:                                rdp->rd_date.tm_sec = datenum->rn_id[5];
                   1828:                                rcsnum_free(datenum);
1.14      deraadt  1829:                        } else if (tok == RCS_TOK_AUTHOR) {
1.1       jfb      1830:                                rdp->rd_author = tokstr;
                   1831:                                tokstr = NULL;
1.14      deraadt  1832:                        } else if (tok == RCS_TOK_STATE) {
1.1       jfb      1833:                                rdp->rd_state = tokstr;
                   1834:                                tokstr = NULL;
1.14      deraadt  1835:                        } else if (tok == RCS_TOK_NEXT) {
1.1       jfb      1836:                                rcsnum_aton(tokstr, NULL, rdp->rd_next);
                   1837:                        }
                   1838:                        break;
                   1839:                case RCS_TOK_BRANCHES:
1.46      jfb      1840:                        if (rcs_parse_branches(rfp, rdp) < 0) {
                   1841:                                rcs_freedelta(rdp);
                   1842:                                return (-1);
                   1843:                        }
1.1       jfb      1844:                        break;
                   1845:                default:
1.50      jfb      1846:                        rcs_errno = RCS_ERR_PARSE;
1.172     joris    1847:                        cvs_log(LP_ERR, "unexpected token `%s' in RCS delta",
1.1       jfb      1848:                            RCS_TOKSTR(rfp));
                   1849:                        rcs_freedelta(rdp);
                   1850:                        return (-1);
                   1851:                }
                   1852:        }
                   1853:
1.13      jfb      1854:        if (tokstr != NULL)
1.110     joris    1855:                xfree(tokstr);
1.13      jfb      1856:
1.1       jfb      1857:        TAILQ_INSERT_TAIL(&(rfp->rf_delta), rdp, rd_list);
1.26      jfb      1858:        rfp->rf_ndelta++;
1.1       jfb      1859:
                   1860:        return (ret);
                   1861: }
                   1862:
                   1863: /*
                   1864:  * rcs_parse_deltatext()
                   1865:  *
                   1866:  * Parse an RCS delta text section and fill in the log and text field of the
                   1867:  * appropriate delta section.
                   1868:  * Returns 1 if the section was parsed OK, 0 if it is the last delta, and
                   1869:  * -1 on error.
                   1870:  */
                   1871: static int
                   1872: rcs_parse_deltatext(RCSFILE *rfp)
                   1873: {
                   1874:        int tok;
                   1875:        RCSNUM *tnum;
                   1876:        struct rcs_delta *rdp;
                   1877:
                   1878:        tok = rcs_gettok(rfp);
                   1879:        if (tok == RCS_TOK_EOF)
                   1880:                return (0);
                   1881:
                   1882:        if (tok != RCS_TOK_NUM) {
1.50      jfb      1883:                rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1884:                cvs_log(LP_ERR,
                   1885:                    "unexpected token `%s' at start of RCS delta text",
                   1886:                    RCS_TOKSTR(rfp));
                   1887:                return (-1);
                   1888:        }
1.13      jfb      1889:
                   1890:        tnum = rcsnum_alloc();
1.1       jfb      1891:        rcsnum_aton(RCS_TOKSTR(rfp), NULL, tnum);
                   1892:
                   1893:        TAILQ_FOREACH(rdp, &(rfp->rf_delta), rd_list) {
                   1894:                if (rcsnum_cmp(tnum, rdp->rd_num, 0) == 0)
                   1895:                        break;
                   1896:        }
1.13      jfb      1897:        rcsnum_free(tnum);
                   1898:
1.1       jfb      1899:        if (rdp == NULL) {
                   1900:                cvs_log(LP_ERR, "RCS delta text `%s' has no matching delta",
                   1901:                    RCS_TOKSTR(rfp));
                   1902:                return (-1);
                   1903:        }
                   1904:
                   1905:        tok = rcs_gettok(rfp);
                   1906:        if (tok != RCS_TOK_LOG) {
1.50      jfb      1907:                rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1908:                cvs_log(LP_ERR, "unexpected token `%s' where RCS log expected",
                   1909:                    RCS_TOKSTR(rfp));
                   1910:                return (-1);
                   1911:        }
                   1912:
                   1913:        tok = rcs_gettok(rfp);
                   1914:        if (tok != RCS_TOK_STRING) {
1.50      jfb      1915:                rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1916:                cvs_log(LP_ERR, "unexpected token `%s' where RCS log expected",
                   1917:                    RCS_TOKSTR(rfp));
                   1918:                return (-1);
                   1919:        }
1.110     joris    1920:        rdp->rd_log = xstrdup(RCS_TOKSTR(rfp));
1.1       jfb      1921:        tok = rcs_gettok(rfp);
                   1922:        if (tok != RCS_TOK_TEXT) {
1.50      jfb      1923:                rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1924:                cvs_log(LP_ERR, "unexpected token `%s' where RCS text expected",
                   1925:                    RCS_TOKSTR(rfp));
                   1926:                return (-1);
                   1927:        }
                   1928:
                   1929:        tok = rcs_gettok(rfp);
                   1930:        if (tok != RCS_TOK_STRING) {
1.50      jfb      1931:                rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1932:                cvs_log(LP_ERR, "unexpected token `%s' where RCS text expected",
                   1933:                    RCS_TOKSTR(rfp));
                   1934:                return (-1);
                   1935:        }
                   1936:
1.193     niallo   1937:        if (RCS_TOKLEN(rfp) == 0) {
                   1938:                rdp->rd_text = xmalloc(1);
                   1939:                rdp->rd_text[0] = '\0';
                   1940:                rdp->rd_tlen = 0;
                   1941:        } else {
                   1942:                rdp->rd_text = xmalloc(RCS_TOKLEN(rfp));
                   1943:                memcpy(rdp->rd_text, RCS_TOKSTR(rfp), RCS_TOKLEN(rfp));
                   1944:                rdp->rd_tlen = RCS_TOKLEN(rfp);
                   1945:        }
1.1       jfb      1946:
                   1947:        return (1);
                   1948: }
                   1949:
                   1950: /*
                   1951:  * rcs_parse_access()
                   1952:  *
                   1953:  * Parse the access list given as value to the `access' keyword.
                   1954:  * Returns 0 on success, or -1 on failure.
                   1955:  */
                   1956: static int
                   1957: rcs_parse_access(RCSFILE *rfp)
                   1958: {
                   1959:        int type;
                   1960:
                   1961:        while ((type = rcs_gettok(rfp)) != RCS_TOK_SCOLON) {
                   1962:                if (type != RCS_TOK_ID) {
1.50      jfb      1963:                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1964:                        cvs_log(LP_ERR, "unexpected token `%s' in access list",
                   1965:                            RCS_TOKSTR(rfp));
                   1966:                        return (-1);
                   1967:                }
1.29      jfb      1968:
                   1969:                if (rcs_access_add(rfp, RCS_TOKSTR(rfp)) < 0)
                   1970:                        return (-1);
1.1       jfb      1971:        }
                   1972:
                   1973:        return (0);
                   1974: }
                   1975:
                   1976: /*
                   1977:  * rcs_parse_symbols()
                   1978:  *
                   1979:  * Parse the symbol list given as value to the `symbols' keyword.
                   1980:  * Returns 0 on success, or -1 on failure.
                   1981:  */
                   1982: static int
                   1983: rcs_parse_symbols(RCSFILE *rfp)
                   1984: {
                   1985:        int type;
                   1986:        struct rcs_sym *symp;
                   1987:
                   1988:        for (;;) {
                   1989:                type = rcs_gettok(rfp);
                   1990:                if (type == RCS_TOK_SCOLON)
                   1991:                        break;
                   1992:
1.41      jfb      1993:                if (type != RCS_TOK_ID) {
1.50      jfb      1994:                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      1995:                        cvs_log(LP_ERR, "unexpected token `%s' in symbol list",
                   1996:                            RCS_TOKSTR(rfp));
                   1997:                        return (-1);
                   1998:                }
                   1999:
1.161     ray      2000:                symp = xmalloc(sizeof(*symp));
1.110     joris    2001:                symp->rs_name = xstrdup(RCS_TOKSTR(rfp));
1.1       jfb      2002:                symp->rs_num = rcsnum_alloc();
                   2003:
                   2004:                type = rcs_gettok(rfp);
                   2005:                if (type != RCS_TOK_COLON) {
1.50      jfb      2006:                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      2007:                        cvs_log(LP_ERR, "unexpected token `%s' in symbol list",
                   2008:                            RCS_TOKSTR(rfp));
1.11      joris    2009:                        rcsnum_free(symp->rs_num);
1.110     joris    2010:                        xfree(symp->rs_name);
                   2011:                        xfree(symp);
1.1       jfb      2012:                        return (-1);
                   2013:                }
                   2014:
                   2015:                type = rcs_gettok(rfp);
                   2016:                if (type != RCS_TOK_NUM) {
1.50      jfb      2017:                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      2018:                        cvs_log(LP_ERR, "unexpected token `%s' in symbol list",
                   2019:                            RCS_TOKSTR(rfp));
1.11      joris    2020:                        rcsnum_free(symp->rs_num);
1.110     joris    2021:                        xfree(symp->rs_name);
                   2022:                        xfree(symp);
1.1       jfb      2023:                        return (-1);
                   2024:                }
                   2025:
                   2026:                if (rcsnum_aton(RCS_TOKSTR(rfp), NULL, symp->rs_num) < 0) {
                   2027:                        cvs_log(LP_ERR, "failed to parse RCS NUM `%s'",
                   2028:                            RCS_TOKSTR(rfp));
1.11      joris    2029:                        rcsnum_free(symp->rs_num);
1.110     joris    2030:                        xfree(symp->rs_name);
                   2031:                        xfree(symp);
1.1       jfb      2032:                        return (-1);
                   2033:                }
                   2034:
1.43      jfb      2035:                TAILQ_INSERT_TAIL(&(rfp->rf_symbols), symp, rs_list);
1.1       jfb      2036:        }
                   2037:
                   2038:        return (0);
                   2039: }
                   2040:
                   2041: /*
                   2042:  * rcs_parse_locks()
                   2043:  *
                   2044:  * Parse the lock list given as value to the `locks' keyword.
                   2045:  * Returns 0 on success, or -1 on failure.
                   2046:  */
                   2047: static int
                   2048: rcs_parse_locks(RCSFILE *rfp)
                   2049: {
                   2050:        int type;
                   2051:        struct rcs_lock *lkp;
                   2052:
                   2053:        for (;;) {
                   2054:                type = rcs_gettok(rfp);
                   2055:                if (type == RCS_TOK_SCOLON)
                   2056:                        break;
                   2057:
                   2058:                if (type != RCS_TOK_ID) {
1.50      jfb      2059:                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      2060:                        cvs_log(LP_ERR, "unexpected token `%s' in lock list",
                   2061:                            RCS_TOKSTR(rfp));
                   2062:                        return (-1);
                   2063:                }
                   2064:
1.161     ray      2065:                lkp = xmalloc(sizeof(*lkp));
1.110     joris    2066:                lkp->rl_name = xstrdup(RCS_TOKSTR(rfp));
1.1       jfb      2067:                lkp->rl_num = rcsnum_alloc();
                   2068:
                   2069:                type = rcs_gettok(rfp);
                   2070:                if (type != RCS_TOK_COLON) {
1.50      jfb      2071:                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      2072:                        cvs_log(LP_ERR, "unexpected token `%s' in symbol list",
                   2073:                            RCS_TOKSTR(rfp));
1.37      tedu     2074:                        rcsnum_free(lkp->rl_num);
1.110     joris    2075:                        xfree(lkp->rl_name);
                   2076:                        xfree(lkp);
1.1       jfb      2077:                        return (-1);
                   2078:                }
                   2079:
                   2080:                type = rcs_gettok(rfp);
                   2081:                if (type != RCS_TOK_NUM) {
1.50      jfb      2082:                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      2083:                        cvs_log(LP_ERR, "unexpected token `%s' in symbol list",
                   2084:                            RCS_TOKSTR(rfp));
1.37      tedu     2085:                        rcsnum_free(lkp->rl_num);
1.110     joris    2086:                        xfree(lkp->rl_name);
                   2087:                        xfree(lkp);
1.1       jfb      2088:                        return (-1);
                   2089:                }
                   2090:
                   2091:                if (rcsnum_aton(RCS_TOKSTR(rfp), NULL, lkp->rl_num) < 0) {
                   2092:                        cvs_log(LP_ERR, "failed to parse RCS NUM `%s'",
                   2093:                            RCS_TOKSTR(rfp));
1.37      tedu     2094:                        rcsnum_free(lkp->rl_num);
1.110     joris    2095:                        xfree(lkp->rl_name);
                   2096:                        xfree(lkp);
1.1       jfb      2097:                        return (-1);
                   2098:                }
                   2099:
                   2100:                TAILQ_INSERT_HEAD(&(rfp->rf_locks), lkp, rl_list);
                   2101:        }
                   2102:
                   2103:        /* check if we have a `strict' */
                   2104:        type = rcs_gettok(rfp);
                   2105:        if (type != RCS_TOK_STRICT) {
                   2106:                rcs_pushtok(rfp, RCS_TOKSTR(rfp), type);
1.14      deraadt  2107:        } else {
1.26      jfb      2108:                rfp->rf_flags |= RCS_SLOCK;
1.1       jfb      2109:
                   2110:                type = rcs_gettok(rfp);
                   2111:                if (type != RCS_TOK_SCOLON) {
1.50      jfb      2112:                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      2113:                        cvs_log(LP_ERR,
                   2114:                            "missing semi-colon after `strict' keyword");
                   2115:                        return (-1);
                   2116:                }
                   2117:        }
                   2118:
                   2119:        return (0);
                   2120: }
                   2121:
                   2122: /*
                   2123:  * rcs_parse_branches()
                   2124:  *
                   2125:  * Parse the list of branches following a `branches' keyword in a delta.
                   2126:  * Returns 0 on success, or -1 on failure.
                   2127:  */
                   2128: static int
                   2129: rcs_parse_branches(RCSFILE *rfp, struct rcs_delta *rdp)
                   2130: {
                   2131:        int type;
                   2132:        struct rcs_branch *brp;
                   2133:
                   2134:        for (;;) {
                   2135:                type = rcs_gettok(rfp);
                   2136:                if (type == RCS_TOK_SCOLON)
                   2137:                        break;
                   2138:
                   2139:                if (type != RCS_TOK_NUM) {
1.50      jfb      2140:                        rcs_errno = RCS_ERR_PARSE;
1.1       jfb      2141:                        cvs_log(LP_ERR,
                   2142:                            "unexpected token `%s' in list of branches",
                   2143:                            RCS_TOKSTR(rfp));
                   2144:                        return (-1);
                   2145:                }
                   2146:
1.161     ray      2147:                brp = xmalloc(sizeof(*brp));
1.46      jfb      2148:                brp->rb_num = rcsnum_parse(RCS_TOKSTR(rfp));
1.11      joris    2149:                if (brp->rb_num == NULL) {
1.110     joris    2150:                        xfree(brp);
1.11      joris    2151:                        return (-1);
                   2152:                }
1.1       jfb      2153:
                   2154:                TAILQ_INSERT_TAIL(&(rdp->rd_branches), brp, rb_list);
                   2155:        }
                   2156:
                   2157:        return (0);
                   2158: }
                   2159:
                   2160: /*
                   2161:  * rcs_freedelta()
                   2162:  *
                   2163:  * Free the contents of a delta structure.
                   2164:  */
1.18      jfb      2165: static void
1.1       jfb      2166: rcs_freedelta(struct rcs_delta *rdp)
                   2167: {
1.12      jfb      2168:        struct rcs_branch *rb;
1.1       jfb      2169:
1.12      jfb      2170:        if (rdp->rd_num != NULL)
                   2171:                rcsnum_free(rdp->rd_num);
                   2172:        if (rdp->rd_next != NULL)
                   2173:                rcsnum_free(rdp->rd_next);
                   2174:
1.1       jfb      2175:        if (rdp->rd_author != NULL)
1.110     joris    2176:                xfree(rdp->rd_author);
1.109     joris    2177:        if (rdp->rd_locker != NULL)
1.110     joris    2178:                xfree(rdp->rd_locker);
1.1       jfb      2179:        if (rdp->rd_state != NULL)
1.110     joris    2180:                xfree(rdp->rd_state);
1.1       jfb      2181:        if (rdp->rd_log != NULL)
1.110     joris    2182:                xfree(rdp->rd_log);
1.1       jfb      2183:        if (rdp->rd_text != NULL)
1.110     joris    2184:                xfree(rdp->rd_text);
1.12      jfb      2185:
                   2186:        while ((rb = TAILQ_FIRST(&(rdp->rd_branches))) != NULL) {
                   2187:                TAILQ_REMOVE(&(rdp->rd_branches), rb, rb_list);
                   2188:                rcsnum_free(rb->rb_num);
1.110     joris    2189:                xfree(rb);
1.1       jfb      2190:        }
                   2191:
1.110     joris    2192:        xfree(rdp);
1.1       jfb      2193: }
                   2194:
                   2195: /*
                   2196:  * rcs_freepdata()
                   2197:  *
                   2198:  * Free the contents of the parser data structure.
                   2199:  */
                   2200: static void
                   2201: rcs_freepdata(struct rcs_pdata *pd)
                   2202: {
                   2203:        if (pd->rp_file != NULL)
                   2204:                (void)fclose(pd->rp_file);
                   2205:        if (pd->rp_buf != NULL)
1.110     joris    2206:                xfree(pd->rp_buf);
                   2207:        xfree(pd);
1.1       jfb      2208: }
                   2209:
                   2210: /*
                   2211:  * rcs_gettok()
                   2212:  *
                   2213:  * Get the next RCS token from the string <str>.
                   2214:  */
                   2215: static int
                   2216: rcs_gettok(RCSFILE *rfp)
                   2217: {
                   2218:        u_int i;
                   2219:        int ch, last, type;
1.18      jfb      2220:        size_t len;
                   2221:        char *bp;
1.1       jfb      2222:        struct rcs_pdata *pdp = (struct rcs_pdata *)rfp->rf_pdata;
                   2223:
                   2224:        type = RCS_TOK_ERR;
                   2225:        bp = pdp->rp_buf;
1.42      jfb      2226:        pdp->rp_tlen = 0;
1.1       jfb      2227:        *bp = '\0';
                   2228:
                   2229:        if (pdp->rp_pttype != RCS_TOK_ERR) {
                   2230:                type = pdp->rp_pttype;
1.172     joris    2231:                if (strlcpy(pdp->rp_buf, pdp->rp_ptok, pdp->rp_blen) >=
                   2232:                    pdp->rp_blen)
                   2233:                        fatal("rcs_gettok: strlcpy");
1.1       jfb      2234:                pdp->rp_pttype = RCS_TOK_ERR;
                   2235:                return (type);
                   2236:        }
                   2237:
                   2238:        /* skip leading whitespace */
                   2239:        /* XXX we must skip backspace too for compatibility, should we? */
                   2240:        do {
                   2241:                ch = getc(pdp->rp_file);
                   2242:                if (ch == '\n')
1.18      jfb      2243:                        pdp->rp_lines++;
1.1       jfb      2244:        } while (isspace(ch));
                   2245:
                   2246:        if (ch == EOF) {
                   2247:                type = RCS_TOK_EOF;
1.14      deraadt  2248:        } else if (ch == ';') {
1.1       jfb      2249:                type = RCS_TOK_SCOLON;
1.14      deraadt  2250:        } else if (ch == ':') {
1.1       jfb      2251:                type = RCS_TOK_COLON;
1.14      deraadt  2252:        } else if (isalpha(ch)) {
1.31      jfb      2253:                type = RCS_TOK_ID;
1.1       jfb      2254:                *(bp++) = ch;
1.18      jfb      2255:                for (;;) {
1.1       jfb      2256:                        ch = getc(pdp->rp_file);
1.188     joris    2257:                        if (ch == EOF) {
                   2258:                                type = RCS_TOK_EOF;
                   2259:                                break;
                   2260:                        } else if (!isalnum(ch) && ch != '_' && ch != '-' &&
1.201     joris    2261:                            ch != '/' && ch != '+') {
1.1       jfb      2262:                                ungetc(ch, pdp->rp_file);
                   2263:                                break;
                   2264:                        }
                   2265:                        *(bp++) = ch;
1.42      jfb      2266:                        pdp->rp_tlen++;
1.18      jfb      2267:                        if (bp == pdp->rp_bufend - 1) {
                   2268:                                len = bp - pdp->rp_buf;
1.151     xsa      2269:                                rcs_growbuf(rfp);
1.18      jfb      2270:                                bp = pdp->rp_buf + len;
                   2271:                        }
1.1       jfb      2272:                }
                   2273:                *bp = '\0';
                   2274:
1.18      jfb      2275:                if (type != RCS_TOK_ERR) {
                   2276:                        for (i = 0; i < RCS_NKEYS; i++) {
                   2277:                                if (strcmp(rcs_keys[i].rk_str,
                   2278:                                    pdp->rp_buf) == 0) {
                   2279:                                        type = rcs_keys[i].rk_id;
                   2280:                                        break;
                   2281:                                }
1.1       jfb      2282:                        }
                   2283:                }
1.14      deraadt  2284:        } else if (ch == '@') {
1.1       jfb      2285:                /* we have a string */
1.18      jfb      2286:                type = RCS_TOK_STRING;
1.1       jfb      2287:                for (;;) {
                   2288:                        ch = getc(pdp->rp_file);
1.188     joris    2289:                        if (ch == EOF) {
                   2290:                                type = RCS_TOK_EOF;
                   2291:                                break;
                   2292:                        } else if (ch == '@') {
1.1       jfb      2293:                                ch = getc(pdp->rp_file);
                   2294:                                if (ch != '@') {
                   2295:                                        ungetc(ch, pdp->rp_file);
                   2296:                                        break;
                   2297:                                }
1.14      deraadt  2298:                        } else if (ch == '\n')
1.18      jfb      2299:                                pdp->rp_lines++;
1.1       jfb      2300:
                   2301:                        *(bp++) = ch;
1.42      jfb      2302:                        pdp->rp_tlen++;
1.18      jfb      2303:                        if (bp == pdp->rp_bufend - 1) {
                   2304:                                len = bp - pdp->rp_buf;
1.151     xsa      2305:                                rcs_growbuf(rfp);
1.18      jfb      2306:                                bp = pdp->rp_buf + len;
                   2307:                        }
1.1       jfb      2308:                }
                   2309:
                   2310:                *bp = '\0';
1.14      deraadt  2311:        } else if (isdigit(ch)) {
1.1       jfb      2312:                *(bp++) = ch;
                   2313:                last = ch;
                   2314:                type = RCS_TOK_NUM;
                   2315:
                   2316:                for (;;) {
                   2317:                        ch = getc(pdp->rp_file);
1.188     joris    2318:                        if (ch == EOF) {
                   2319:                                type = RCS_TOK_EOF;
                   2320:                                break;
                   2321:                        }
1.18      jfb      2322:                        if (bp == pdp->rp_bufend)
1.1       jfb      2323:                                break;
                   2324:                        if (!isdigit(ch) && ch != '.') {
                   2325:                                ungetc(ch, pdp->rp_file);
                   2326:                                break;
                   2327:                        }
                   2328:
                   2329:                        if (last == '.' && ch == '.') {
                   2330:                                type = RCS_TOK_ERR;
                   2331:                                break;
                   2332:                        }
                   2333:                        last = ch;
                   2334:                        *(bp++) = ch;
1.42      jfb      2335:                        pdp->rp_tlen++;
1.1       jfb      2336:                }
1.18      jfb      2337:                *bp = '\0';
1.1       jfb      2338:        }
                   2339:
                   2340:        return (type);
                   2341: }
                   2342:
                   2343: /*
                   2344:  * rcs_pushtok()
                   2345:  *
                   2346:  * Push a token back in the parser's token buffer.
                   2347:  */
                   2348: static int
                   2349: rcs_pushtok(RCSFILE *rfp, const char *tok, int type)
                   2350: {
                   2351:        struct rcs_pdata *pdp = (struct rcs_pdata *)rfp->rf_pdata;
                   2352:
                   2353:        if (pdp->rp_pttype != RCS_TOK_ERR)
                   2354:                return (-1);
                   2355:
                   2356:        pdp->rp_pttype = type;
1.172     joris    2357:        if (strlcpy(pdp->rp_ptok, tok, sizeof(pdp->rp_ptok)) >=
                   2358:            sizeof(pdp->rp_ptok))
                   2359:                fatal("rcs_pushtok: strlcpy");
1.1       jfb      2360:        return (0);
                   2361: }
                   2362:
1.18      jfb      2363:
                   2364: /*
                   2365:  * rcs_growbuf()
                   2366:  *
                   2367:  * Attempt to grow the internal parse buffer for the RCS file <rf> by
                   2368:  * RCS_BUFEXTSIZE.
                   2369:  * In case of failure, the original buffer is left unmodified.
                   2370:  */
1.151     xsa      2371: static void
1.18      jfb      2372: rcs_growbuf(RCSFILE *rf)
                   2373: {
                   2374:        struct rcs_pdata *pdp = (struct rcs_pdata *)rf->rf_pdata;
                   2375:
1.212     ray      2376:        pdp->rp_buf = xrealloc(pdp->rp_buf, 1,
                   2377:            pdp->rp_blen + RCS_BUFEXTSIZE);
1.18      jfb      2378:        pdp->rp_blen += RCS_BUFEXTSIZE;
                   2379:        pdp->rp_bufend = pdp->rp_buf + pdp->rp_blen - 1;
1.42      jfb      2380: }
                   2381:
                   2382: /*
                   2383:  * rcs_strprint()
                   2384:  *
                   2385:  * Output an RCS string <str> of size <slen> to the stream <stream>.  Any
                   2386:  * '@' characters are escaped.  Otherwise, the string can contain arbitrary
                   2387:  * binary data.
                   2388:  */
1.155     ray      2389: static void
1.42      jfb      2390: rcs_strprint(const u_char *str, size_t slen, FILE *stream)
                   2391: {
                   2392:        const u_char *ap, *ep, *sp;
1.52      jfb      2393:
                   2394:        if (slen == 0)
1.155     ray      2395:                return;
1.42      jfb      2396:
                   2397:        ep = str + slen - 1;
                   2398:
                   2399:        for (sp = str; sp <= ep;)  {
                   2400:                ap = memchr(sp, '@', ep - sp);
                   2401:                if (ap == NULL)
                   2402:                        ap = ep;
1.155     ray      2403:                (void)fwrite(sp, sizeof(u_char), ap - sp + 1, stream);
1.42      jfb      2404:
                   2405:                if (*ap == '@')
                   2406:                        putc('@', stream);
                   2407:                sp = ap + 1;
1.63      joris    2408:        }
                   2409: }
                   2410:
                   2411: /*
1.81      niallo   2412:  * rcs_deltatext_set()
                   2413:  *
                   2414:  * Set deltatext for <rev> in RCS file <rfp> to <dtext>
1.96      xsa      2415:  * Returns -1 on error, 0 on success.
1.81      niallo   2416:  */
                   2417: int
1.194     joris    2418: rcs_deltatext_set(RCSFILE *rfp, RCSNUM *rev, BUF *bp)
1.81      niallo   2419: {
                   2420:        size_t len;
1.194     joris    2421:        u_char *dtext;
1.81      niallo   2422:        struct rcs_delta *rdp;
1.117     niallo   2423:
                   2424:        /* Write operations require full parsing */
                   2425:        rcs_parse_deltatexts(rfp, NULL);
1.81      niallo   2426:
                   2427:        if ((rdp = rcs_findrev(rfp, rev)) == NULL)
                   2428:                return (-1);
                   2429:
                   2430:        if (rdp->rd_text != NULL)
1.110     joris    2431:                xfree(rdp->rd_text);
1.81      niallo   2432:
1.194     joris    2433:        len = cvs_buf_len(bp);
                   2434:        dtext = cvs_buf_release(bp);
                   2435:        bp = NULL;
                   2436:
1.103     joris    2437:        if (len != 0) {
1.194     joris    2438:                rdp->rd_text = xmalloc(len);
1.155     ray      2439:                rdp->rd_tlen = len;
1.194     joris    2440:                (void)memcpy(rdp->rd_text, dtext, len);
1.103     joris    2441:        } else {
                   2442:                rdp->rd_text = NULL;
                   2443:                rdp->rd_tlen = 0;
                   2444:        }
1.194     joris    2445:
                   2446:        if (dtext != NULL)
                   2447:                xfree(dtext);
1.18      jfb      2448:
1.86      joris    2449:        return (0);
                   2450: }
                   2451:
                   2452: /*
                   2453:  * rcs_rev_setlog()
                   2454:  *
                   2455:  * Sets the log message of revision <rev> to <logtext>
                   2456:  */
                   2457: int
                   2458: rcs_rev_setlog(RCSFILE *rfp, RCSNUM *rev, const char *logtext)
                   2459: {
                   2460:        struct rcs_delta *rdp;
1.214     xsa      2461:        char buf[CVS_REV_BUFSZ];
1.86      joris    2462:
                   2463:        rcsnum_tostr(rev, buf, sizeof(buf));
                   2464:
                   2465:        if ((rdp = rcs_findrev(rfp, rev)) == NULL)
                   2466:                return (-1);
                   2467:
                   2468:        if (rdp->rd_log != NULL)
1.110     joris    2469:                xfree(rdp->rd_log);
1.86      joris    2470:
1.110     joris    2471:        rdp->rd_log = xstrdup(logtext);
1.86      joris    2472:        rfp->rf_flags &= ~RCS_SYNCED;
1.95      niallo   2473:        return (0);
                   2474: }
1.97      niallo   2475: /*
                   2476:  * rcs_rev_getdate()
                   2477:  *
                   2478:  * Get the date corresponding to a given revision.
                   2479:  * Returns the date on success, -1 on failure.
                   2480:  */
                   2481: time_t
                   2482: rcs_rev_getdate(RCSFILE *rfp, RCSNUM *rev)
                   2483: {
                   2484:        struct rcs_delta *rdp;
                   2485:
                   2486:        if ((rdp = rcs_findrev(rfp, rev)) == NULL)
                   2487:                return (-1);
                   2488:
1.204     joris    2489:        return (timegm(&rdp->rd_date));
1.97      niallo   2490: }
1.95      niallo   2491:
                   2492: /*
                   2493:  * rcs_state_set()
                   2494:  *
                   2495:  * Sets the state of revision <rev> to <state>
                   2496:  * NOTE: default state is 'Exp'. States may not contain spaces.
                   2497:  *
                   2498:  * Returns -1 on failure, 0 on success.
                   2499:  */
                   2500: int
                   2501: rcs_state_set(RCSFILE *rfp, RCSNUM *rev, const char *state)
                   2502: {
                   2503:        struct rcs_delta *rdp;
                   2504:
                   2505:        if ((rdp = rcs_findrev(rfp, rev)) == NULL)
                   2506:                return (-1);
                   2507:
                   2508:        if (rdp->rd_state != NULL)
1.110     joris    2509:                xfree(rdp->rd_state);
1.95      niallo   2510:
1.110     joris    2511:        rdp->rd_state = xstrdup(state);
1.95      niallo   2512:
                   2513:        rfp->rf_flags &= ~RCS_SYNCED;
                   2514:
                   2515:        return (0);
                   2516: }
                   2517:
                   2518: /*
                   2519:  * rcs_state_check()
                   2520:  *
                   2521:  * Check if string <state> is valid.
                   2522:  *
1.96      xsa      2523:  * Returns 0 if the string is valid, -1 otherwise.
1.95      niallo   2524:  */
                   2525: int
                   2526: rcs_state_check(const char *state)
                   2527: {
                   2528:        if (strchr(state, ' ') != NULL)
                   2529:                return (-1);
                   2530:
1.18      jfb      2531:        return (0);
1.1       jfb      2532: }
1.97      niallo   2533:
                   2534: /*
                   2535:  * rcs_state_get()
                   2536:  *
                   2537:  * Get the state for a given revision of a specified RCSFILE.
                   2538:  *
                   2539:  * Returns NULL on failure.
                   2540:  */
                   2541: const char *
                   2542: rcs_state_get(RCSFILE *rfp, RCSNUM *rev)
                   2543: {
                   2544:        struct rcs_delta *rdp;
                   2545:
                   2546:        if ((rdp = rcs_findrev(rfp, rev)) == NULL)
                   2547:                return (NULL);
                   2548:
                   2549:        return (rdp->rd_state);
                   2550: }
                   2551:
1.213     niallo   2552: /* rcs_translate_tag() */
1.176     joris    2553: RCSNUM *
                   2554: rcs_translate_tag(const char *revstr, RCSFILE *rfp)
                   2555: {
1.213     niallo   2556:        RCSNUM *rev, *brev, *frev;
1.178     joris    2557:        struct rcs_branch *brp;
1.183     joris    2558:        struct rcs_delta *rdp;
1.213     niallo   2559:        size_t i;
1.183     joris    2560:
                   2561:        rdp = NULL;
1.215     joris    2562:
                   2563:        if (!strcmp(revstr, RCS_HEAD_BRANCH)) {
                   2564:                frev = rcsnum_alloc();
                   2565:                rcsnum_cpy(rfp->rf_head, frev, 0);
                   2566:                return (frev);
                   2567:        }
1.176     joris    2568:
1.213     niallo   2569:        /* Possibly we could be passed a version number */
                   2570:        if ((frev = rcsnum_parse(revstr)) != NULL)
                   2571:                return (frev);
                   2572:
                   2573:        /* More likely we will be passed a symbol */
1.176     joris    2574:        rev = rcs_sym_getrev(rfp, revstr);
1.213     niallo   2575:
                   2576:        if (rev == NULL)
                   2577:                return (NULL);
1.183     joris    2578:
1.220     joris    2579:        /*
                   2580:         * If it was not a branch, thats ok the symbolic
                   2581:         * name refered to a revision, so return the resolved
                   2582:         * revision for the given name.
                   2583:         */
1.213     niallo   2584:        if (!RCSNUM_ISBRANCH(rev))
1.220     joris    2585:                return (rev);
1.183     joris    2586:
1.213     niallo   2587:        brev = rcsnum_alloc();
                   2588:        rcsnum_cpy(rev, brev, rev->rn_len - 1);
1.178     joris    2589:
1.180     joris    2590:        if ((rdp = rcs_findrev(rfp, brev)) == NULL)
1.213     niallo   2591:                fatal("rcs_translate_tag: tag `%s' does not exist", revstr);
                   2592:        rcsnum_free(brev);
1.178     joris    2593:
1.213     niallo   2594:        TAILQ_FOREACH(brp, &(rdp->rd_branches), rb_list) {
                   2595:                for (i = 0; i < rev->rn_len; i++)
                   2596:                        if (brp->rb_num->rn_id[i] != rev->rn_id[i])
                   2597:                                break;
                   2598:                if (i != rev->rn_len)
                   2599:                        continue;
                   2600:                break;
                   2601:        }
1.178     joris    2602:
1.213     niallo   2603:        frev = rcsnum_alloc();
                   2604:        if (brp == NULL) {
                   2605:                rcsnum_cpy(rdp->rd_num, frev, 0);
                   2606:                return (frev);
                   2607:        } else {
                   2608:                /* Fetch the delta with the correct branch num */
1.180     joris    2609:                if ((rdp = rcs_findrev(rfp, brp->rb_num)) == NULL)
1.213     niallo   2610:                        fatal("rcs_translate_tag: could not fetch branch delta");
                   2611:                /* Find the latest delta on that branch */
                   2612:                for (;;) {
                   2613:                        if (rdp->rd_next->rn_len == 0)
                   2614:                                break;
1.180     joris    2615:                        if ((rdp = rcs_findrev(rfp, rdp->rd_next)) == NULL)
1.213     niallo   2616:                                fatal("rcs_translate_tag: could not fetch branch delta");
1.178     joris    2617:                }
1.213     niallo   2618:                rcsnum_cpy(rdp->rd_num, frev, 0);
                   2619:                return (frev);
1.176     joris    2620:        }
1.196     niallo   2621: }
                   2622:
                   2623: /*
                   2624:  * rcs_rev_getlines()
                   2625:  *
                   2626:  * Get the entire contents of revision <rev> from the RCSFILE <rfp> and
                   2627:  * return it as a pointer to a struct cvs_lines.
                   2628:  */
                   2629: struct cvs_lines *
1.218     tobias   2630: rcs_rev_getlines(RCSFILE *rfp, RCSNUM *frev, struct cvs_line ***alines)
1.196     niallo   2631: {
1.209     otto     2632:        size_t plen;
1.218     tobias   2633:        int annotate, done, i, nextroot;
1.196     niallo   2634:        RCSNUM *tnum, *bnum;
                   2635:        struct rcs_branch *brp;
1.218     tobias   2636:        struct rcs_delta *hrdp, *prdp, *rdp, *trdp;
1.196     niallo   2637:        u_char *patch;
1.218     tobias   2638:        struct cvs_line *line, *nline;
1.196     niallo   2639:        struct cvs_lines *dlines, *plines;
                   2640:
                   2641:        if ((hrdp = rcs_findrev(rfp, rfp->rf_head)) == NULL)
1.197     joris    2642:                fatal("rcs_rev_getlines: no HEAD revision");
1.196     niallo   2643:
                   2644:        tnum = frev;
                   2645:        rcs_parse_deltatexts(rfp, hrdp->rd_num);
                   2646:
                   2647:        /* revision on branch, get the branch root */
                   2648:        nextroot = 2;
                   2649:        if (RCSNUM_ISBRANCHREV(tnum)) {
                   2650:                bnum = rcsnum_alloc();
                   2651:                rcsnum_cpy(tnum, bnum, nextroot);
                   2652:        } else {
                   2653:                bnum = tnum;
                   2654:        }
                   2655:
1.218     tobias   2656:        if (alines != NULL) {
                   2657:                /* start with annotate first at requested revision */
                   2658:                annotate = ANNOTATE_LATER;
                   2659:                *alines = NULL;
                   2660:        } else
                   2661:                annotate = ANNOTATE_NEVER;
                   2662:
1.196     niallo   2663:        dlines = cvs_splitlines(hrdp->rd_text, hrdp->rd_tlen);
                   2664:
                   2665:        done = 0;
                   2666:
                   2667:        rdp = hrdp;
1.218     tobias   2668:        if (!rcsnum_differ(rdp->rd_num, bnum)) {
                   2669:                if (annotate == ANNOTATE_LATER) {
                   2670:                        /* found requested revision for annotate */
                   2671:                        i = 0;
                   2672:                        TAILQ_FOREACH(line, &(dlines->l_lines), l_list) {
                   2673:                                line->l_lineno_orig = line->l_lineno;
                   2674:                                i++;
                   2675:                        }
                   2676:
                   2677:                        *alines = xcalloc(i + 1, sizeof(struct cvs_line *));
                   2678:                        (*alines)[i] = NULL;
                   2679:                        annotate = ANNOTATE_NOW;
                   2680:
                   2681:                        /* annotate down to 1.1 from where we are */
                   2682:                        if (bnum == tnum)
                   2683:                                bnum = rcsnum_alloc();
                   2684:                        bnum = rcsnum_parse("1.1");
                   2685:                        if (!rcsnum_differ(rdp->rd_num, bnum)) {
                   2686:                                goto next;
                   2687:                        }
                   2688:                } else
                   2689:                        goto next;
                   2690:        }
1.196     niallo   2691:
1.218     tobias   2692:        prdp = hrdp;
1.196     niallo   2693:        if ((rdp = rcs_findrev(rfp, hrdp->rd_next)) == NULL)
                   2694:                goto done;
                   2695:
                   2696: again:
                   2697:        for (;;) {
                   2698:                if (rdp->rd_next->rn_len != 0) {
                   2699:                        trdp = rcs_findrev(rfp, rdp->rd_next);
                   2700:                        if (trdp == NULL)
                   2701:                                fatal("failed to grab next revision");
                   2702:                }
                   2703:
                   2704:                if (rdp->rd_tlen == 0) {
                   2705:                        rcs_parse_deltatexts(rfp, rdp->rd_num);
                   2706:                        if (rdp->rd_tlen == 0) {
                   2707:                                if (!rcsnum_differ(rdp->rd_num, bnum))
                   2708:                                        break;
                   2709:                                rdp = trdp;
                   2710:                                continue;
                   2711:                        }
                   2712:                }
                   2713:
                   2714:                plen = rdp->rd_tlen;
                   2715:                patch = rdp->rd_text;
                   2716:                plines = cvs_splitlines(patch, plen);
1.218     tobias   2717:                if (annotate == ANNOTATE_NOW)
                   2718:                        rcs_patch_lines(dlines, plines, *alines, prdp);
                   2719:                else
                   2720:                        rcs_patch_lines(dlines, plines, NULL, NULL);
1.196     niallo   2721:                cvs_freelines(plines);
                   2722:
1.218     tobias   2723:                if (!rcsnum_differ(rdp->rd_num, bnum)) {
                   2724:                        if (annotate != ANNOTATE_LATER)
                   2725:                                break;
                   2726:
                   2727:                        /* found requested revision for annotate */
                   2728:                        i = 0;
                   2729:                        TAILQ_FOREACH(line, &(dlines->l_lines), l_list) {
                   2730:                                line->l_lineno_orig = line->l_lineno;
                   2731:                                i++;
                   2732:                        }
                   2733:
                   2734:                        *alines = xcalloc(i + 1, sizeof(struct cvs_line *));
                   2735:                        (*alines)[i] = NULL;
                   2736:                        annotate = ANNOTATE_NOW;
                   2737:
                   2738:                        /* annotate down to 1.1 from where we are */
                   2739:                        if (bnum == tnum)
                   2740:                                bnum = rcsnum_alloc();
                   2741:                        bnum = rcsnum_parse("1.1");
                   2742:
                   2743:                        if (!rcsnum_differ(rdp->rd_num, bnum))
                   2744:                                break;
                   2745:                }
1.196     niallo   2746:
1.218     tobias   2747:                prdp = rdp;
1.196     niallo   2748:                rdp = trdp;
                   2749:        }
                   2750:
                   2751: next:
                   2752:        if (!rcsnum_differ(rdp->rd_num, frev))
                   2753:                done = 1;
                   2754:
                   2755:        if (RCSNUM_ISBRANCHREV(frev) && done != 1) {
                   2756:                nextroot += 2;
                   2757:                rcsnum_cpy(frev, bnum, nextroot);
                   2758:
                   2759:                TAILQ_FOREACH(brp, &(rdp->rd_branches), rb_list) {
1.213     niallo   2760:                        for (i = 0; i < nextroot - 1; i++)
                   2761:                                if (brp->rb_num->rn_id[i] != bnum->rn_id[i])
1.196     niallo   2762:                                        break;
1.213     niallo   2763:                        if (i == nextroot - 1)
                   2764:                                break;
1.196     niallo   2765:                }
                   2766:
1.218     tobias   2767:                if (brp == NULL) {
                   2768:                        if (annotate != ANNOTATE_NEVER) {
                   2769:                                if (*alines != NULL)
                   2770:                                        xfree(*alines);
                   2771:                                *alines = NULL;
                   2772:                                cvs_freelines(dlines);
                   2773:                                if (bnum != tnum)
                   2774:                                        rcsnum_free(bnum);
                   2775:                                return (NULL);
                   2776:                        }
1.196     niallo   2777:                        fatal("expected branch not found on branch list");
1.218     tobias   2778:                }
1.196     niallo   2779:
                   2780:                if ((rdp = rcs_findrev(rfp, brp->rb_num)) == NULL)
1.197     joris    2781:                        fatal("rcs_rev_getlines: failed to get delta for target rev");
1.196     niallo   2782:
                   2783:                goto again;
                   2784:        }
                   2785: done:
1.218     tobias   2786:        /* put remaining lines of 1.1 into annotate buffer */
                   2787:        if (annotate == ANNOTATE_NOW) {
                   2788:                for (line = TAILQ_FIRST(&(dlines->l_lines));
                   2789:                    line != NULL; line = nline) {
                   2790:                        nline = TAILQ_NEXT(line, l_list);
                   2791:                        TAILQ_REMOVE(&(dlines->l_lines), line, l_list);
                   2792:                        if (line->l_line == NULL) {
                   2793:                                xfree(line);
                   2794:                                continue;
                   2795:                        }
                   2796:
                   2797:                        line->l_delta = rdp;
                   2798:                        (*alines)[line->l_lineno_orig - 1] = line;
                   2799:                }
                   2800:
                   2801:                cvs_freelines(dlines);
                   2802:                dlines = NULL;
                   2803:        }
                   2804:
1.196     niallo   2805:        if (bnum != tnum)
                   2806:                rcsnum_free(bnum);
                   2807:
                   2808:        return (dlines);
                   2809: }
                   2810:
                   2811: /*
                   2812:  * rcs_rev_getbuf()
                   2813:  *
                   2814:  * XXX: This is really really slow and should be avoided if at all possible!
                   2815:  *
                   2816:  * Get the entire contents of revision <rev> from the RCSFILE <rfp> and
                   2817:  * return it as a BUF pointer.
                   2818:  */
                   2819: BUF *
1.200     joris    2820: rcs_rev_getbuf(RCSFILE *rfp, RCSNUM *rev, int mode)
1.196     niallo   2821: {
1.200     joris    2822:        int expmode, expand;
                   2823:        struct rcs_delta *rdp;
1.196     niallo   2824:        struct cvs_lines *lines;
                   2825:        struct cvs_line *lp;
                   2826:        BUF *bp;
                   2827:
1.200     joris    2828:        expand = 0;
1.218     tobias   2829:        lines = rcs_rev_getlines(rfp, rev, NULL);
1.196     niallo   2830:        bp = cvs_buf_alloc(1024, BUF_AUTOEXT);
1.200     joris    2831:
                   2832:        if (!(mode & RCS_KWEXP_NONE)) {
                   2833:                if (rfp->rf_expand != NULL)
                   2834:                        expmode = rcs_kwexp_get(rfp);
                   2835:                else
                   2836:                        expmode = RCS_KWEXP_DEFAULT;
                   2837:
                   2838:                if (!(expmode & RCS_KWEXP_NONE)) {
                   2839:                        if ((rdp = rcs_findrev(rfp, rev)) == NULL)
                   2840:                                fatal("could not fetch revision");
                   2841:                        expand = 1;
                   2842:                }
                   2843:        }
                   2844:
1.196     niallo   2845:        TAILQ_FOREACH(lp, &lines->l_lines, l_list) {
                   2846:                if (lp->l_line == NULL)
                   2847:                        continue;
1.200     joris    2848:
                   2849:                if (expand)
                   2850:                        rcs_kwexp_line(rfp->rf_path, rdp, lp, expmode);
                   2851:
1.196     niallo   2852:                cvs_buf_append(bp, lp->l_line, lp->l_len);
                   2853:        }
                   2854:
                   2855:        cvs_freelines(lines);
                   2856:
                   2857:        return (bp);
                   2858: }
                   2859:
                   2860: /*
                   2861:  * rcs_rev_write_fd()
                   2862:  *
                   2863:  * Write the entire contents of revision <frev> from the rcsfile <rfp> to
                   2864:  * file descriptor <fd>.
                   2865:  */
                   2866: void
                   2867: rcs_rev_write_fd(RCSFILE *rfp, RCSNUM *rev, int fd, int mode)
                   2868: {
1.200     joris    2869:        int expmode, expand;
1.196     niallo   2870:        struct rcs_delta *rdp;
                   2871:        struct cvs_lines *lines;
                   2872:        struct cvs_line *lp;
1.217     joris    2873:        extern int print_stdout;
1.196     niallo   2874:
1.200     joris    2875:        expand = 0;
1.218     tobias   2876:        lines = rcs_rev_getlines(rfp, rev, NULL);
1.200     joris    2877:
1.196     niallo   2878:        if (!(mode & RCS_KWEXP_NONE)) {
                   2879:                if (rfp->rf_expand != NULL)
                   2880:                        expmode = rcs_kwexp_get(rfp);
                   2881:                else
                   2882:                        expmode = RCS_KWEXP_DEFAULT;
                   2883:
                   2884:                if (!(expmode & RCS_KWEXP_NONE)) {
                   2885:                        if ((rdp = rcs_findrev(rfp, rev)) == NULL)
                   2886:                                fatal("could not fetch revision");
1.200     joris    2887:                        expand = 1;
1.196     niallo   2888:                }
                   2889:        }
1.200     joris    2890:
1.196     niallo   2891:        TAILQ_FOREACH(lp, &lines->l_lines, l_list) {
                   2892:                if (lp->l_line == NULL)
                   2893:                        continue;
1.200     joris    2894:
                   2895:                if (expand)
                   2896:                        rcs_kwexp_line(rfp->rf_path, rdp, lp, expmode);
1.217     joris    2897:
                   2898:                /*
                   2899:                 * Solely for the checkout and update -p options.
                   2900:                 */
                   2901:                if (cvs_server_active == 1 &&
                   2902:                    (cvs_cmdop == CVS_OP_CHECKOUT ||
                   2903:                    cvs_cmdop == CVS_OP_UPDATE) && print_stdout == 1) {
1.219     tobias   2904:                        if (atomicio(vwrite, fd, "M ", 2) != 2)
1.217     joris    2905:                                fatal("rcs_rev_write_fd: %s", strerror(errno));
                   2906:                }
1.200     joris    2907:
1.219     tobias   2908:                if (atomicio(vwrite, fd, lp->l_line, lp->l_len) != lp->l_len)
1.196     niallo   2909:                        fatal("rcs_rev_write_fd: %s", strerror(errno));
                   2910:        }
                   2911:
                   2912:        /* XXX: do we need to call futimes(2) on the output fd? */
                   2913:
                   2914:        cvs_freelines(lines);
                   2915:
                   2916: }
                   2917:
                   2918: /*
                   2919:  * rcs_rev_write_stmp()
                   2920:  *
                   2921:  * Write the contents of the rev <rev> to a temporary file whose path is
                   2922:  * specified using <template> (see mkstemp(3)). NB. This function will modify
                   2923:  * <template>, as per mkstemp.
                   2924:  */
                   2925: void
                   2926: rcs_rev_write_stmp(RCSFILE *rfp,  RCSNUM *rev, char *template, int mode)
                   2927: {
                   2928:        int fd;
                   2929:
                   2930:        if ((fd = mkstemp(template)) == -1)
                   2931:                fatal("mkstemp: `%s': %s", template, strerror(errno));
                   2932:
                   2933:        cvs_worklist_add(template, &temp_files);
                   2934:        rcs_rev_write_fd(rfp, rev, fd, mode);
                   2935:
                   2936:        (void)close(fd);
                   2937: }
                   2938:
                   2939: static void
                   2940: rcs_kwexp_line(char *rcsfile, struct rcs_delta *rdp, struct cvs_line *line,
                   2941:     int mode)
                   2942: {
                   2943:        int kwtype;
                   2944:        u_int j, found;
1.209     otto     2945:        const u_char *c, *start, *fin, *end;
                   2946:        char *kwstr;
1.196     niallo   2947:        char expbuf[256], buf[256];
                   2948:        char *fmt;
1.197     joris    2949:        size_t len, kwlen;
1.196     niallo   2950:
                   2951:        kwtype = 0;
                   2952:        kwstr = NULL;
                   2953:
                   2954:        len = line->l_len;
                   2955:        if (len == 0)
                   2956:                return;
                   2957:
                   2958:        c = line->l_line;
                   2959:        found = 0;
                   2960:        /* Final character in buffer. */
                   2961:        fin = c + len - 1;
                   2962:
                   2963:        /*
                   2964:         * Keyword formats:
                   2965:         * $Keyword$
                   2966:         * $Keyword: value$
                   2967:         */
                   2968:        for (; c < fin; c++) {
                   2969:                if (*c == '$') {
                   2970:                        BUF *tmpbuf;
                   2971:                        size_t clen, tlen;
                   2972:
                   2973:                        /* remember start of this possible keyword */
                   2974:                        start = c;
                   2975:
                   2976:                        /* first following character has to be alphanumeric */
                   2977:                        c++;
                   2978:                        if (!isalpha(*c)) {
                   2979:                                c = start;
                   2980:                                continue;
                   2981:                        }
                   2982:
                   2983:                        /* Number of characters between c and fin, inclusive. */
                   2984:                        clen = fin - c + 1;
                   2985:
                   2986:                        /* look for any matching keywords */
                   2987:                        found = 0;
                   2988:                        for (j = 0; j < RCS_NKWORDS; j++) {
                   2989:                                kwlen = strlen(rcs_expkw[j].kw_str);
                   2990:                                /*
                   2991:                                 * kwlen must be less than clen since clen
                   2992:                                 * includes either a terminating `$' or a `:'.
                   2993:                                 */
                   2994:                                if (kwlen < clen &&
                   2995:                                    memcmp(c, rcs_expkw[j].kw_str, kwlen) == 0 &&
                   2996:                                    (c[kwlen] == '$' || c[kwlen] == ':')) {
                   2997:                                        found = 1;
                   2998:                                        kwstr = rcs_expkw[j].kw_str;
                   2999:                                        kwtype = rcs_expkw[j].kw_type;
                   3000:                                        c += kwlen;
                   3001:                                        break;
                   3002:                                }
                   3003:                        }
                   3004:
1.197     joris    3005:                        if (found == 0 && cvs_tagname != NULL) {
                   3006:                                kwlen = strlen(cvs_tagname);
                   3007:                                if (kwlen < clen &&
                   3008:                                    memcmp(c, cvs_tagname, kwlen) == 0 &&
                   3009:                                    (c[kwlen] == '$' || c[kwlen] == ':')) {
                   3010:                                        found = 1;
                   3011:                                        kwstr = cvs_tagname;
                   3012:                                        kwtype = RCS_KW_ID;
                   3013:                                        c += kwlen;
                   3014:                                }
                   3015:                        }
                   3016:
1.196     niallo   3017:                        /* unknown keyword, continue looking */
                   3018:                        if (found == 0) {
                   3019:                                c = start;
                   3020:                                continue;
                   3021:                        }
                   3022:
                   3023:                        /*
                   3024:                         * if the next character was ':' we need to look for
                   3025:                         * an '$' before the end of the line to be sure it is
                   3026:                         * in fact a keyword.
                   3027:                         */
                   3028:                        if (*c == ':') {
                   3029:                                for (; c <= fin; ++c) {
                   3030:                                        if (*c == '$' || *c == '\n')
                   3031:                                                break;
                   3032:                                }
                   3033:
                   3034:                                if (*c != '$') {
                   3035:                                        c = start;
                   3036:                                        continue;
                   3037:                                }
                   3038:                        }
                   3039:                        end = c + 1;
                   3040:
                   3041:                        /* start constructing the expansion */
                   3042:                        expbuf[0] = '\0';
                   3043:
                   3044:                        if (mode & RCS_KWEXP_NAME) {
                   3045:                                if (strlcat(expbuf, "$", sizeof(expbuf)) >= sizeof(expbuf) ||
                   3046:                                    strlcat(expbuf, kwstr, sizeof(expbuf)) >= sizeof(expbuf))
1.200     joris    3047:                                        fatal("rcs_kwexp_line: truncated");
1.196     niallo   3048:                                if ((mode & RCS_KWEXP_VAL) &&
                   3049:                                    strlcat(expbuf, ": ", sizeof(expbuf)) >= sizeof(expbuf))
1.200     joris    3050:                                        fatal("rcs_kwexp_line: truncated");
1.196     niallo   3051:                        }
                   3052:
                   3053:                        /*
                   3054:                         * order matters because of RCS_KW_ID and
                   3055:                         * RCS_KW_HEADER here
                   3056:                         */
                   3057:                        if (mode & RCS_KWEXP_VAL) {
                   3058:                                if (kwtype & RCS_KW_RCSFILE) {
                   3059:                                        if (!(kwtype & RCS_KW_FULLPATH))
                   3060:                                                (void)strlcat(expbuf, basename(rcsfile), sizeof(expbuf));
                   3061:                                        else
                   3062:                                                (void)strlcat(expbuf, rcsfile, sizeof(expbuf));
                   3063:                                        if (strlcat(expbuf, " ", sizeof(expbuf)) >= sizeof(expbuf))
1.200     joris    3064:                                                fatal("rcs_kwexp_line: truncated");
1.196     niallo   3065:                                }
                   3066:
                   3067:                                if (kwtype & RCS_KW_REVISION) {
                   3068:                                        rcsnum_tostr(rdp->rd_num, buf, sizeof(buf));
                   3069:                                        if (strlcat(buf, " ", sizeof(buf)) >= sizeof(buf) ||
                   3070:                                            strlcat(expbuf, buf, sizeof(expbuf)) >= sizeof(buf))
1.200     joris    3071:                                                fatal("rcs_kwexp_line: truncated");
1.196     niallo   3072:                                }
                   3073:
                   3074:                                if (kwtype & RCS_KW_DATE) {
                   3075:                                        fmt = "%Y/%m/%d %H:%M:%S ";
                   3076:
1.211     niallo   3077:                                        if (strftime(buf, sizeof(buf), fmt, &rdp->rd_date) == 0)
                   3078:                                                fatal("rcs_kwexp_line: strftime failure");
                   3079:                                        if (strlcat(expbuf, buf, sizeof(expbuf)) >= sizeof(expbuf))
                   3080:                                                fatal("rcs_kwexp_line: string truncated");
                   3081:                                }
                   3082:
                   3083:                                if (kwtype & RCS_KW_MDOCDATE) {
                   3084:                                        fmt = "%B %e %Y ";
                   3085:
                   3086:                                        if (strftime(buf, sizeof(buf), fmt, &rdp->rd_date) == 0)
                   3087:                                                fatal("rcs_kwexp_line: strftime failure");
1.196     niallo   3088:                                        if (strlcat(expbuf, buf, sizeof(expbuf)) >= sizeof(expbuf))
1.200     joris    3089:                                                fatal("rcs_kwexp_line: string truncated");
1.196     niallo   3090:                                }
                   3091:
                   3092:                                if (kwtype & RCS_KW_AUTHOR) {
                   3093:                                        if (strlcat(expbuf, rdp->rd_author, sizeof(expbuf)) >= sizeof(expbuf) ||
                   3094:                                            strlcat(expbuf, " ", sizeof(expbuf)) >= sizeof(expbuf))
1.200     joris    3095:                                                fatal("rcs_kwexp_line: string truncated");
1.196     niallo   3096:                                }
                   3097:
                   3098:                                if (kwtype & RCS_KW_STATE) {
                   3099:                                        if (strlcat(expbuf, rdp->rd_state, sizeof(expbuf)) >= sizeof(expbuf) ||
                   3100:                                            strlcat(expbuf, " ", sizeof(expbuf)) >= sizeof(expbuf))
1.200     joris    3101:                                                fatal("rcs_kwexp_line: string truncated");
1.196     niallo   3102:                                }
                   3103:
                   3104:                                /* order does not matter anymore below */
                   3105:                                if (kwtype & RCS_KW_LOG)
                   3106:                                        if (strlcat(expbuf, " ", sizeof(expbuf)) >= sizeof(expbuf))
1.200     joris    3107:                                                fatal("rcs_kwexp_line: string truncated");
1.196     niallo   3108:
                   3109:                                if (kwtype & RCS_KW_SOURCE) {
                   3110:                                        if (strlcat(expbuf, rcsfile, sizeof(expbuf)) >= sizeof(expbuf) ||
                   3111:                                            strlcat(expbuf, " ", sizeof(expbuf)) >= sizeof(expbuf))
1.200     joris    3112:                                                fatal("rcs_kwexp_line: string truncated");
1.196     niallo   3113:                                }
                   3114:
                   3115:                                if (kwtype & RCS_KW_NAME)
                   3116:                                        if (strlcat(expbuf, " ", sizeof(expbuf)) >= sizeof(expbuf))
1.200     joris    3117:                                                fatal("rcs_kwexp_line: string truncated");
1.196     niallo   3118:                        }
                   3119:
                   3120:                        /* end the expansion */
                   3121:                        if (mode & RCS_KWEXP_NAME)
                   3122:                                if (strlcat(expbuf, "$",
                   3123:                                    sizeof(expbuf)) >= sizeof(expbuf))
1.200     joris    3124:                                        fatal("rcs_kwexp_line: truncated");
1.196     niallo   3125:
                   3126:                        /* Concatenate everything together. */
                   3127:                        tmpbuf = cvs_buf_alloc(len + strlen(expbuf), BUF_AUTOEXT);
                   3128:                        /* Append everything before keyword. */
                   3129:                        cvs_buf_append(tmpbuf, line->l_line,
1.209     otto     3130:                            start - line->l_line);
1.196     niallo   3131:                        /* Append keyword. */
                   3132:                        cvs_buf_append(tmpbuf, expbuf, strlen(expbuf));
                   3133:                        /* Point c to end of keyword. */
                   3134:                        tlen = cvs_buf_len(tmpbuf) - 1;
                   3135:                        /* Append everything after keyword. */
                   3136:                        cvs_buf_append(tmpbuf, end,
1.209     otto     3137:                            line->l_line + line->l_len - end);
1.196     niallo   3138:                        c = cvs_buf_get(tmpbuf) + tlen;
                   3139:                        /* Point fin to end of data. */
                   3140:                        fin = cvs_buf_get(tmpbuf) + cvs_buf_len(tmpbuf) - 1;
                   3141:                        /* Recalculate new length. */
                   3142:                        len = cvs_buf_len(tmpbuf);
                   3143:
                   3144:                        /* tmpbuf is now ready, convert to string */
1.203     otto     3145:                        if (line->l_needsfree)
                   3146:                                xfree(line->l_line);
1.196     niallo   3147:                        line->l_len = len;
                   3148:                        line->l_line = cvs_buf_release(tmpbuf);
1.202     niallo   3149:                        line->l_needsfree = 1;
1.196     niallo   3150:                }
                   3151:        }
1.131     niallo   3152: }