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

Annotation of src/usr.bin/cvs/entries.c, Revision 1.69

1.69    ! otto        1: /*     $OpenBSD: entries.c,v 1.68 2007/01/24 13:55:11 pyr Exp $        */
1.1       jfb         2: /*
1.57      joris       3:  * Copyright (c) 2006 Joris Vink <joris@openbsd.org>
1.1       jfb         4:  *
1.57      joris       5:  * Permission to use, copy, modify, and distribute this software for any
                      6:  * purpose with or without fee is hereby granted, provided that the above
                      7:  * copyright notice and this permission notice appear in all copies.
                      8:  *
                      9:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     10:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     11:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     12:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     13:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
                     14:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
                     15:  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1.1       jfb        16:  */
                     17:
1.54      xsa        18: #include "includes.h"
1.1       jfb        19:
1.34      xsa        20: #include "cvs.h"
1.1       jfb        21: #include "log.h"
                     22:
1.42      xsa        23: #define CVS_ENTRIES_NFIELDS    6
                     24: #define CVS_ENTRIES_DELIM      '/'
1.1       jfb        25:
1.57      joris      26: static struct cvs_ent_line *ent_get_line(CVSENTRIES *, const char *);
1.1       jfb        27:
1.42      xsa        28: CVSENTRIES *
1.57      joris      29: cvs_ent_open(const char *dir)
1.1       jfb        30: {
1.57      joris      31:        FILE *fp;
1.1       jfb        32:        size_t len;
1.57      joris      33:        CVSENTRIES *ep;
                     34:        char *p, buf[MAXPATHLEN];
1.1       jfb        35:        struct cvs_ent *ent;
1.57      joris      36:        struct cvs_ent_line *line;
1.36      xsa        37:
1.57      joris      38:        ep = (CVSENTRIES *)xmalloc(sizeof(*ep));
                     39:        memset(ep, 0, sizeof(*ep));
1.52      joris      40:
1.64      xsa        41:        if (cvs_path_cat(dir, CVS_PATH_ENTRIES, buf, sizeof(buf)) >=
                     42:            sizeof(buf))
                     43:                fatal("cvs_ent_open: truncation");
                     44:
1.57      joris      45:        ep->cef_path = xstrdup(buf);
1.8       jfb        46:
1.64      xsa        47:        if (cvs_path_cat(dir, CVS_PATH_BACKUPENTRIES, buf, sizeof(buf)) >=
                     48:            sizeof(buf))
                     49:                fatal("cvs_ent_open: truncation");
                     50:
1.57      joris      51:        ep->cef_bpath = xstrdup(buf);
1.3       jfb        52:
1.64      xsa        53:        if (cvs_path_cat(dir, CVS_PATH_LOGENTRIES, buf, sizeof(buf)) >=
                     54:            sizeof(buf))
                     55:                fatal("cvs_ent_open: truncation");
                     56:
1.57      joris      57:        ep->cef_lpath = xstrdup(buf);
1.1       jfb        58:
1.4       jfb        59:        TAILQ_INIT(&(ep->cef_ent));
1.3       jfb        60:
1.57      joris      61:        if ((fp = fopen(ep->cef_path, "r")) != NULL) {
                     62:                while (fgets(buf, sizeof(buf), fp)) {
                     63:                        len = strlen(buf);
                     64:                        if (len > 0 && buf[len - 1] == '\n')
                     65:                                buf[len - 1] = '\0';
                     66:
                     67:                        if (buf[0] == 'D' && buf[1] == '\0')
                     68:                                break;
                     69:
                     70:                        line = (struct cvs_ent_line *)xmalloc(sizeof(*line));
                     71:                        line->buf = xstrdup(buf);
                     72:                        TAILQ_INSERT_TAIL(&(ep->cef_ent), line, entries_list);
                     73:                }
1.52      joris      74:
1.25      jfb        75:                (void)fclose(fp);
1.12      jfb        76:        }
1.1       jfb        77:
1.57      joris      78:        if ((fp = fopen(ep->cef_lpath, "r")) != NULL) {
                     79:                while (fgets(buf, sizeof(buf), fp)) {
                     80:                        len = strlen(buf);
1.62      ray        81:                        if (len > 0 && buf[len - 1] == '\n')
                     82:                                buf[len - 1] = '\0';
1.57      joris      83:
                     84:                        p = &buf[1];
                     85:
                     86:                        if (buf[0] == 'A') {
                     87:                                line = xmalloc(sizeof(*line));
                     88:                                line->buf = xstrdup(p);
                     89:                                TAILQ_INSERT_TAIL(&(ep->cef_ent), line,
                     90:                                    entries_list);
                     91:                        } else if (buf[0] == 'R') {
                     92:                                ent = cvs_ent_parse(p);
                     93:                                line = ent_get_line(ep, ent->ce_name);
1.65      joris      94:                                if (line != NULL) {
1.57      joris      95:                                        TAILQ_REMOVE(&(ep->cef_ent), line,
                     96:                                            entries_list);
1.65      joris      97:                                        xfree(line->buf);
                     98:                                        xfree(line);
                     99:                                }
1.57      joris     100:                                cvs_ent_free(ent);
                    101:                        }
                    102:                }
1.4       jfb       103:
1.52      joris     104:                (void)fclose(fp);
                    105:        }
1.12      jfb       106:
1.1       jfb       107:        return (ep);
                    108: }
                    109:
1.57      joris     110: struct cvs_ent *
                    111: cvs_ent_parse(const char *entry)
1.1       jfb       112: {
1.57      joris     113:        int i;
1.5       jfb       114:        struct cvs_ent *ent;
1.57      joris     115:        char *fields[CVS_ENTRIES_NFIELDS], *buf, *sp, *dp;
1.5       jfb       116:
1.57      joris     117:        buf = xstrdup(entry);
                    118:        sp = buf;
                    119:        i = 0;
                    120:        do {
                    121:                dp = strchr(sp, CVS_ENTRIES_DELIM);
                    122:                if (dp != NULL)
                    123:                        *(dp++) = '\0';
                    124:                fields[i++] = sp;
                    125:                sp = dp;
                    126:        } while (dp != NULL && i < CVS_ENTRIES_NFIELDS);
1.8       jfb       127:
1.57      joris     128:        if (i < CVS_ENTRIES_NFIELDS)
                    129:                fatal("missing fields in entry line '%s'", entry);
1.5       jfb       130:
1.57      joris     131:        ent = (struct cvs_ent *)xmalloc(sizeof(*ent));
                    132:        ent->ce_buf = buf;
1.52      joris     133:
1.57      joris     134:        if (*fields[0] == '\0')
                    135:                ent->ce_type = CVS_ENT_FILE;
                    136:        else if (*fields[0] == 'D')
                    137:                ent->ce_type = CVS_ENT_DIR;
                    138:        else
                    139:                ent->ce_type = CVS_ENT_NONE;
                    140:
                    141:        ent->ce_status = CVS_ENT_REG;
                    142:        ent->ce_name = fields[1];
                    143:        ent->ce_rev = NULL;
1.5       jfb       144:
1.57      joris     145:        if (ent->ce_type == CVS_ENT_FILE) {
                    146:                if (*fields[2] == '-') {
                    147:                        ent->ce_status = CVS_ENT_REMOVED;
                    148:                        sp = fields[2] + 1;
                    149:                } else {
                    150:                        sp = fields[2];
                    151:                        if (fields[2][0] == '0' && fields[2][1] == '\0')
                    152:                                ent->ce_status = CVS_ENT_ADDED;
                    153:                }
1.1       jfb       154:
1.57      joris     155:                if ((ent->ce_rev = rcsnum_parse(sp)) == NULL)
                    156:                        fatal("failed to parse entry revision '%s'", entry);
1.1       jfb       157:
1.57      joris     158:                if (strcmp(fields[3], CVS_DATE_DUMMY) == 0 ||
                    159:                    strncmp(fields[3], "Initial ", 8) == 0 ||
                    160:                    strncmp(fields[3], "Result of merge", 15) == 0)
                    161:                        ent->ce_mtime = CVS_DATE_DMSEC;
                    162:                else
                    163:                        ent->ce_mtime = cvs_date_parse(fields[3]);
1.3       jfb       164:        }
1.1       jfb       165:
1.57      joris     166:        ent->ce_conflict = fields[3];
                    167:        if ((dp = strchr(ent->ce_conflict, '+')) != NULL)
                    168:                *dp = '\0';
                    169:        else
                    170:                ent->ce_conflict = NULL;
1.1       jfb       171:
1.57      joris     172:        if (strcmp(fields[4], ""))
                    173:                ent->ce_opts = fields[4];
                    174:        else
                    175:                ent->ce_opts = NULL;
1.8       jfb       176:
1.57      joris     177:        if (strcmp(fields[5], ""))
1.58      joris     178:                ent->ce_tag = fields[5] + 1;
1.57      joris     179:        else
                    180:                ent->ce_tag = NULL;
1.3       jfb       181:
1.57      joris     182:        return (ent);
1.3       jfb       183: }
                    184:
1.57      joris     185: struct cvs_ent *
                    186: cvs_ent_get(CVSENTRIES *ep, const char *name)
1.3       jfb       187: {
                    188:        struct cvs_ent *ent;
1.57      joris     189:        struct cvs_ent_line *l;
1.3       jfb       190:
1.57      joris     191:        l = ent_get_line(ep, name);
                    192:        if (l == NULL)
                    193:                return (NULL);
1.3       jfb       194:
1.57      joris     195:        ent = cvs_ent_parse(l->buf);
                    196:        return (ent);
                    197: }
1.3       jfb       198:
1.57      joris     199: int
                    200: cvs_ent_exists(CVSENTRIES *ep, const char *name)
                    201: {
                    202:        struct cvs_ent_line *l;
1.1       jfb       203:
1.57      joris     204:        l = ent_get_line(ep, name);
                    205:        if (l == NULL)
                    206:                return (0);
1.8       jfb       207:
1.57      joris     208:        return (1);
1.1       jfb       209: }
                    210:
1.57      joris     211: void
                    212: cvs_ent_close(CVSENTRIES *ep, int writefile)
1.9       jfb       213: {
1.57      joris     214:        FILE *fp;
                    215:        struct cvs_ent_line *l;
1.44      xsa       216:
1.57      joris     217:        if (writefile) {
                    218:                if ((fp = fopen(ep->cef_bpath, "w")) == NULL)
1.63      xsa       219:                        fatal("cvs_ent_close: fopen: `%s': %s",
                    220:                            ep->cef_path, strerror(errno));
1.57      joris     221:        }
1.16      jfb       222:
1.57      joris     223:        while ((l = TAILQ_FIRST(&(ep->cef_ent))) != NULL) {
                    224:                if (writefile) {
                    225:                        fputs(l->buf, fp);
                    226:                        fputc('\n', fp);
1.51      joris     227:                }
1.57      joris     228:
                    229:                TAILQ_REMOVE(&(ep->cef_ent), l, entries_list);
                    230:                xfree(l->buf);
                    231:                xfree(l);
1.22      jfb       232:        }
1.9       jfb       233:
1.57      joris     234:        if (writefile) {
                    235:                fputc('D', fp);
1.68      pyr       236:                fputc('\n', fp);
1.57      joris     237:                (void)fclose(fp);
                    238:
                    239:                if (rename(ep->cef_bpath, ep->cef_path) == -1)
1.63      xsa       240:                        fatal("cvs_ent_close: rename: `%s'->`%s': %s",
                    241:                            ep->cef_bpath, ep->cef_path, strerror(errno));
1.57      joris     242:
                    243:                (void)unlink(ep->cef_lpath);
                    244:        }
1.9       jfb       245:
1.57      joris     246:        xfree(ep->cef_path);
                    247:        xfree(ep->cef_bpath);
                    248:        xfree(ep->cef_lpath);
                    249:        xfree(ep);
1.9       jfb       250: }
                    251:
1.57      joris     252: void
                    253: cvs_ent_add(CVSENTRIES *ep, const char *line)
1.1       jfb       254: {
1.57      joris     255:        FILE *fp;
                    256:        struct cvs_ent_line *l;
1.39      xsa       257:        struct cvs_ent *ent;
1.1       jfb       258:
1.57      joris     259:        if ((ent = cvs_ent_parse(line)) == NULL)
                    260:                fatal("cvs_ent_add: parsing failed '%s'", line);
1.1       jfb       261:
1.57      joris     262:        l = ent_get_line(ep, ent->ce_name);
                    263:        if (l != NULL)
                    264:                cvs_ent_remove(ep, ent->ce_name);
1.1       jfb       265:
1.57      joris     266:        cvs_ent_free(ent);
1.1       jfb       267:
1.61      joris     268:        if (cvs_server_active == 0)
                    269:                cvs_log(LP_TRACE, "cvs_ent_add(%s, %s)", ep->cef_path, line);
1.1       jfb       270:
1.57      joris     271:        if ((fp = fopen(ep->cef_lpath, "a")) == NULL)
1.63      xsa       272:                fatal("cvs_ent_add: fopen: `%s': %s",
                    273:                    ep->cef_lpath, strerror(errno));
1.1       jfb       274:
1.57      joris     275:        fputc('A', fp);
                    276:        fputs(line, fp);
                    277:        fputc('\n', fp);
1.1       jfb       278:
1.57      joris     279:        (void)fclose(fp);
1.10      jfb       280:
1.57      joris     281:        l = (struct cvs_ent_line *)xmalloc(sizeof(*l));
                    282:        l->buf = xstrdup(line);
                    283:        TAILQ_INSERT_TAIL(&(ep->cef_ent), l, entries_list);
                    284: }
1.10      jfb       285:
1.57      joris     286: void
                    287: cvs_ent_remove(CVSENTRIES *ep, const char *name)
                    288: {
                    289:        FILE *fp;
                    290:        struct cvs_ent_line *l;
1.1       jfb       291:
1.61      joris     292:        if (cvs_server_active == 0)
                    293:                cvs_log(LP_TRACE, "cvs_ent_remove(%s, %s)", ep->cef_path, name);
1.1       jfb       294:
1.57      joris     295:        l = ent_get_line(ep, name);
                    296:        if (l == NULL)
                    297:                return;
1.1       jfb       298:
1.57      joris     299:        if ((fp = fopen(ep->cef_lpath, "a")) == NULL)
1.63      xsa       300:                fatal("cvs_ent_remove: fopen: `%s': %s", ep->cef_lpath,
                    301:                    strerror(errno));
1.38      joris     302:
1.57      joris     303:        fputc('R', fp);
                    304:        fputs(l->buf, fp);
                    305:        fputc('\n', fp);
1.24      jfb       306:
1.57      joris     307:        (void)fclose(fp);
1.24      jfb       308:
1.57      joris     309:        TAILQ_REMOVE(&(ep->cef_ent), l, entries_list);
                    310:        xfree(l->buf);
                    311:        xfree(l);
1.5       jfb       312: }
                    313:
                    314: void
                    315: cvs_ent_free(struct cvs_ent *ent)
                    316: {
                    317:        if (ent->ce_rev != NULL)
                    318:                rcsnum_free(ent->ce_rev);
1.57      joris     319:        xfree(ent->ce_buf);
1.53      joris     320:        xfree(ent);
1.5       jfb       321: }
1.8       jfb       322:
1.57      joris     323: static struct cvs_ent_line *
                    324: ent_get_line(CVSENTRIES *ep, const char *name)
1.8       jfb       325: {
1.57      joris     326:        char *p, *s;
                    327:        struct cvs_ent_line *l;
1.8       jfb       328:
1.57      joris     329:        TAILQ_FOREACH(l, &(ep->cef_ent), entries_list) {
                    330:                if (l->buf[0] == 'D')
                    331:                        p = &(l->buf[2]);
                    332:                else
                    333:                        p = &(l->buf[1]);
                    334:
                    335:                if ((s = strchr(p, '/')) == NULL)
                    336:                        fatal("ent_get_line: bad entry line '%s'", l->buf);
                    337:
                    338:                *s = '\0';
                    339:
                    340:                if (!strcmp(p, name)) {
                    341:                        *s = '/';
                    342:                        return (l);
1.15      jfb       343:                }
1.8       jfb       344:
1.57      joris     345:                *s = '/';
1.8       jfb       346:        }
                    347:
1.57      joris     348:        return (NULL);
1.59      xsa       349: }
                    350:
                    351: void
                    352: cvs_parse_tagfile(char *dir, char **tagp, char **datep, int *nbp)
                    353: {
                    354:        FILE *fp;
                    355:        int linenum;
                    356:        size_t len;
1.69    ! otto      357:        char linebuf[128], tagpath[MAXPATHLEN];
1.59      xsa       358:
                    359:        if (tagp != NULL)
1.60      joris     360:                *tagp = NULL;
1.59      xsa       361:
                    362:        if (datep != NULL)
1.60      joris     363:                *datep = NULL;
1.59      xsa       364:
                    365:        if (nbp != NULL)
                    366:                *nbp = 0;
                    367:
                    368:        if (cvs_path_cat(dir, CVS_PATH_TAG, tagpath, MAXPATHLEN) >= MAXPATHLEN)
1.69    ! otto      369:                return;
1.59      xsa       370:
                    371:        if ((fp = fopen(tagpath, "r")) == NULL) {
                    372:                if (errno != ENOENT)
                    373:                        cvs_log(LP_NOTICE, "failed to open `%s' : %s", tagpath,
                    374:                            strerror(errno));
1.69    ! otto      375:                return;
1.59      xsa       376:         }
                    377:
                    378:        linenum = 0;
                    379:
                    380:        while (fgets(linebuf, (int)sizeof(linebuf), fp) != NULL) {
                    381:                linenum++;
                    382:                if ((len = strlen(linebuf)) == 0)
                    383:                        continue;
                    384:                if (linebuf[len - 1] != '\n') {
                    385:                        cvs_log(LP_NOTICE, "line too long in `%s:%d'",
                    386:                            tagpath, linenum);
                    387:                        break;
                    388:                }
                    389:                linebuf[--len] = '\0';
                    390:
                    391:                switch (*linebuf) {
                    392:                case 'T':
                    393:                        if (tagp != NULL)
                    394:                                *tagp = xstrdup(linebuf + 1);
                    395:                        break;
                    396:                case 'D':
                    397:                        if (datep != NULL)
                    398:                                *datep = xstrdup(linebuf + 1);
                    399:                        break;
                    400:                case 'N':
                    401:                        if (tagp != NULL)
                    402:                                *tagp = xstrdup(linebuf + 1);
                    403:                        if (nbp != NULL)
                    404:                                *nbp = 1;
                    405:                        break;
                    406:                default:
                    407:                        break;
                    408:                }
                    409:        }
                    410:        if (ferror(fp))
                    411:                cvs_log(LP_NOTICE, "failed to read line from `%s'", tagpath);
                    412:
                    413:        (void)fclose(fp);
                    414: }
                    415:
                    416: void
                    417: cvs_write_tagfile(char *dir, char *tag, char *date, int nb)
                    418: {
                    419:        FILE *fp;
1.69    ! otto      420:        char tagpath[MAXPATHLEN];
1.59      xsa       421:
                    422:        if (cvs_noexec == 1)
                    423:                return;
                    424:
                    425:        if (cvs_path_cat(dir, CVS_PATH_TAG, tagpath, MAXPATHLEN) >= MAXPATHLEN)
1.69    ! otto      426:                return;
1.59      xsa       427:
                    428:        if ((tag != NULL) || (date != NULL)) {
                    429:                if ((fp = fopen(tagpath, "w+")) == NULL) {
                    430:                        if (errno != ENOENT) {
                    431:                                cvs_log(LP_NOTICE, "failed to open `%s' : %s",
                    432:                                    tagpath, strerror(errno));
                    433:                        }
1.69    ! otto      434:                        return;
1.59      xsa       435:                }
                    436:                if (tag != NULL) {
                    437:                        if (nb != 0)
                    438:                                (void)fprintf(fp, "N%s\n", tag);
                    439:                        else
                    440:                                (void)fprintf(fp, "T%s\n", tag);
                    441:                } else
                    442:                        (void)fprintf(fp, "D%s\n", date);
                    443:
                    444:                (void)fclose(fp);
                    445:        } else {
                    446:                (void)cvs_unlink(tagpath);
                    447:        }
1.1       jfb       448: }