Annotation of src/usr.bin/cvs/util.c, Revision 1.101
1.101 ! thib 1: /* $OpenBSD: util.c,v 1.100 2007/01/20 01:07:51 niallo Exp $ */
1.1 jfb 2: /*
3: * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
1.71 xsa 4: * Copyright (c) 2005, 2006 Joris Vink <joris@openbsd.org>
5: * Copyright (c) 2005, 2006 Xavier Santolaria <xsa@openbsd.org>
1.9 jfb 6: * All rights reserved.
1.1 jfb 7: *
1.9 jfb 8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
1.1 jfb 11: *
1.9 jfb 12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
1.1 jfb 14: * 2. The name of the author may not be used to endorse or promote products
1.9 jfb 15: * derived from this software without specific prior written permission.
1.1 jfb 16: *
17: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
18: * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
19: * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
20: * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
23: * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
25: * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
1.9 jfb 26: * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1.1 jfb 27: */
28:
1.66 xsa 29: #include "includes.h"
1.1 jfb 30:
31: #include "cvs.h"
32: #include "log.h"
1.70 niallo 33: #include "util.h"
1.1 jfb 34:
35: /* letter -> mode type map */
36: static const int cvs_modetypes[26] = {
37: -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1,
38: -1, 2, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1,
39: };
40:
41: /* letter -> mode map */
42: static const mode_t cvs_modes[3][26] = {
43: {
44: 0, 0, 0, 0, 0, 0, 0, /* a - g */
45: 0, 0, 0, 0, 0, 0, 0, /* h - m */
46: 0, 0, 0, S_IRUSR, 0, 0, 0, /* n - u */
47: 0, S_IWUSR, S_IXUSR, 0, 0 /* v - z */
48: },
49: {
50: 0, 0, 0, 0, 0, 0, 0, /* a - g */
51: 0, 0, 0, 0, 0, 0, 0, /* h - m */
52: 0, 0, 0, S_IRGRP, 0, 0, 0, /* n - u */
53: 0, S_IWGRP, S_IXGRP, 0, 0 /* v - z */
54: },
55: {
56: 0, 0, 0, 0, 0, 0, 0, /* a - g */
57: 0, 0, 0, 0, 0, 0, 0, /* h - m */
58: 0, 0, 0, S_IROTH, 0, 0, 0, /* n - u */
59: 0, S_IWOTH, S_IXOTH, 0, 0 /* v - z */
60: }
61: };
62:
63:
64: /* octal -> string */
65: static const char *cvs_modestr[8] = {
66: "", "x", "w", "wx", "r", "rx", "rw", "rwx"
67: };
68:
1.9 jfb 69: /*
1.1 jfb 70: * cvs_strtomode()
71: *
72: * Read the contents of the string <str> and generate a permission mode from
73: * the contents of <str>, which is assumed to have the mode format of CVS.
74: * The CVS protocol specification states that any modes or mode types that are
75: * not recognized should be silently ignored. This function does not return
76: * an error in such cases, but will issue warnings.
77: */
1.64 joris 78: void
1.1 jfb 79: cvs_strtomode(const char *str, mode_t *mode)
80: {
1.2 jfb 81: char type;
1.64 joris 82: size_t l;
1.1 jfb 83: mode_t m;
84: char buf[32], ms[4], *sp, *ep;
85:
86: m = 0;
1.64 joris 87: l = strlcpy(buf, str, sizeof(buf));
88: if (l >= sizeof(buf))
89: fatal("cvs_strtomode: string truncation");
90:
1.1 jfb 91: sp = buf;
92: ep = sp;
93:
94: for (sp = buf; ep != NULL; sp = ep + 1) {
95: ep = strchr(sp, ',');
96: if (ep != NULL)
1.2 jfb 97: *ep = '\0';
1.1 jfb 98:
1.14 weingart 99: memset(ms, 0, sizeof ms);
100: if (sscanf(sp, "%c=%3s", &type, ms) != 2 &&
101: sscanf(sp, "%c=", &type) != 1) {
1.89 joris 102: fatal("failed to scan mode string `%s'", sp);
1.1 jfb 103: }
104:
1.78 deraadt 105: if (type <= 'a' || type >= 'z' ||
106: cvs_modetypes[type - 'a'] == -1) {
1.79 joris 107: cvs_log(LP_ERR,
1.1 jfb 108: "invalid mode type `%c'"
109: " (`u', `g' or `o' expected), ignoring", type);
110: continue;
111: }
112:
113: /* make type contain the actual mode index */
114: type = cvs_modetypes[type - 'a'];
115:
116: for (sp = ms; *sp != '\0'; sp++) {
1.78 deraadt 117: if (*sp <= 'a' || *sp >= 'z' ||
118: cvs_modes[(int)type][*sp - 'a'] == 0) {
1.89 joris 119: fatal("invalid permission bit `%c'", *sp);
1.15 deraadt 120: } else
1.5 jfb 121: m |= cvs_modes[(int)type][*sp - 'a'];
1.1 jfb 122: }
123: }
124:
125: *mode = m;
126: }
127:
128: /*
129: * cvs_modetostr()
130: *
1.30 jfb 131: * Generate a CVS-format string to represent the permissions mask on a file
132: * from the mode <mode> and store the result in <buf>, which can accept up to
133: * <len> bytes (including the terminating NUL byte). The result is guaranteed
134: * to be NUL-terminated.
1.1 jfb 135: */
1.65 joris 136: void
1.1 jfb 137: cvs_modetostr(mode_t mode, char *buf, size_t len)
138: {
139: char tmp[16], *bp;
140: mode_t um, gm, om;
141:
142: um = (mode & S_IRWXU) >> 6;
143: gm = (mode & S_IRWXG) >> 3;
144: om = mode & S_IRWXO;
145:
146: bp = buf;
147: *bp = '\0';
148:
149: if (um) {
1.68 xsa 150: if (strlcpy(tmp, "u=", sizeof(tmp)) >= sizeof(tmp) ||
151: strlcat(tmp, cvs_modestr[um], sizeof(tmp)) >= sizeof(tmp))
1.65 joris 152: fatal("cvs_modetostr: overflow for user mode");
153:
1.68 xsa 154: if (strlcat(buf, tmp, len) >= len)
1.65 joris 155: fatal("cvs_modetostr: string truncation");
1.1 jfb 156: }
1.65 joris 157:
1.1 jfb 158: if (gm) {
1.65 joris 159: if (um) {
1.68 xsa 160: if (strlcat(buf, ",", len) >= len)
1.65 joris 161: fatal("cvs_modetostr: string truncation");
162: }
163:
1.68 xsa 164: if (strlcpy(tmp, "g=", sizeof(tmp)) >= sizeof(tmp) ||
165: strlcat(tmp, cvs_modestr[gm], sizeof(tmp)) >= sizeof(tmp))
1.65 joris 166: fatal("cvs_modetostr: overflow for group mode");
167:
1.68 xsa 168: if (strlcat(buf, tmp, len) >= len)
1.65 joris 169: fatal("cvs_modetostr: string truncation");
1.1 jfb 170: }
1.65 joris 171:
1.1 jfb 172: if (om) {
1.65 joris 173: if (um || gm) {
1.68 xsa 174: if (strlcat(buf, ",", len) >= len)
1.65 joris 175: fatal("cvs_modetostr: string truncation");
176: }
177:
1.68 xsa 178: if (strlcpy(tmp, "o=", sizeof(tmp)) >= sizeof(tmp) ||
179: strlcat(tmp, cvs_modestr[gm], sizeof(tmp)) >= sizeof(tmp))
1.65 joris 180: fatal("cvs_modetostr: overflow for others mode");
181:
1.68 xsa 182: if (strlcat(buf, tmp, len) >= len)
1.65 joris 183: fatal("cvs_modetostr: string truncation");
1.1 jfb 184: }
185: }
186:
187: /*
188: * cvs_cksum()
189: *
190: * Calculate the MD5 checksum of the file whose path is <file> and generate
191: * a CVS-format 32 hex-digit string, which is stored in <dst>, whose size is
192: * given in <len> and must be at least 33.
193: * Returns 0 on success, or -1 on failure.
194: */
195: int
196: cvs_cksum(const char *file, char *dst, size_t len)
197: {
198: if (len < CVS_CKSUM_LEN) {
1.79 joris 199: cvs_log(LP_ERR, "buffer too small for checksum");
1.1 jfb 200: return (-1);
201: }
202: if (MD5File(file, dst) == NULL) {
1.79 joris 203: cvs_log(LP_ERR, "failed to generate checksum for %s", file);
1.1 jfb 204: return (-1);
205: }
206:
207: return (0);
208: }
209:
210: /*
211: * cvs_splitpath()
212: *
1.7 jfb 213: * Split a path <path> into the base portion and the filename portion.
214: * The path is copied in <base> and the last delimiter is replaced by a NUL
215: * byte. The <file> pointer is set to point to the first character after
216: * that delimiter.
1.1 jfb 217: * Returns 0 on success, or -1 on failure.
218: */
1.65 joris 219: void
1.7 jfb 220: cvs_splitpath(const char *path, char *base, size_t blen, char **file)
1.1 jfb 221: {
222: size_t rlen;
1.7 jfb 223: char *sp;
1.1 jfb 224:
1.7 jfb 225: if ((rlen = strlcpy(base, path, blen)) >= blen)
1.60 xsa 226: fatal("cvs_splitpath: path truncation");
1.6 jfb 227:
1.78 deraadt 228: while (rlen > 0 && base[rlen - 1] == '/')
1.7 jfb 229: base[--rlen] = '\0';
230:
231: sp = strrchr(base, '/');
1.1 jfb 232: if (sp == NULL) {
1.65 joris 233: rlen = strlcpy(base, "./", blen);
234: if (rlen >= blen)
235: fatal("cvs_splitpath: path truncation");
236:
237: rlen = strlcat(base, path, blen);
238: if (rlen >= blen)
239: fatal("cvs_splitpath: path truncation");
240:
1.7 jfb 241: sp = base + 1;
1.1 jfb 242: }
243:
1.7 jfb 244: *sp = '\0';
245: if (file != NULL)
246: *file = sp + 1;
1.1 jfb 247: }
248:
249: /*
250: * cvs_getargv()
251: *
252: * Parse a line contained in <line> and generate an argument vector by
253: * splitting the line on spaces and tabs. The resulting vector is stored in
254: * <argv>, which can accept up to <argvlen> entries.
1.20 david 255: * Returns the number of arguments in the vector, or -1 if an error occurred.
1.1 jfb 256: */
257: int
258: cvs_getargv(const char *line, char **argv, int argvlen)
259: {
1.65 joris 260: size_t l;
1.1 jfb 261: u_int i;
1.67 xsa 262: int argc, error;
1.1 jfb 263: char linebuf[256], qbuf[128], *lp, *cp, *arg;
264:
1.65 joris 265: l = strlcpy(linebuf, line, sizeof(linebuf));
266: if (l >= sizeof(linebuf))
267: fatal("cvs_getargv: string truncation");
268:
1.27 pat 269: memset(argv, 0, argvlen * sizeof(char *));
1.1 jfb 270: argc = 0;
271:
272: /* build the argument vector */
1.67 xsa 273: error = 0;
1.1 jfb 274: for (lp = linebuf; lp != NULL;) {
275: if (*lp == '"') {
276: /* double-quoted string */
277: lp++;
278: i = 0;
279: memset(qbuf, 0, sizeof(qbuf));
280: while (*lp != '"') {
1.16 jfb 281: if (*lp == '\\')
282: lp++;
1.1 jfb 283: if (*lp == '\0') {
284: cvs_log(LP_ERR, "no terminating quote");
1.67 xsa 285: error++;
1.1 jfb 286: break;
1.16 jfb 287: }
1.1 jfb 288:
1.9 jfb 289: qbuf[i++] = *lp++;
1.1 jfb 290: if (i == sizeof(qbuf)) {
1.67 xsa 291: error++;
1.1 jfb 292: break;
293: }
294: }
295:
296: arg = qbuf;
1.15 deraadt 297: } else {
1.1 jfb 298: cp = strsep(&lp, " \t");
299: if (cp == NULL)
300: break;
301: else if (*cp == '\0')
302: continue;
303:
304: arg = cp;
305: }
306:
1.16 jfb 307: if (argc == argvlen) {
1.67 xsa 308: error++;
1.16 jfb 309: break;
310: }
311:
1.59 joris 312: argv[argc] = xstrdup(arg);
1.1 jfb 313: argc++;
314: }
315:
1.67 xsa 316: if (error != 0) {
1.1 jfb 317: /* ditch the argument vector */
318: for (i = 0; i < (u_int)argc; i++)
1.59 joris 319: xfree(argv[i]);
1.1 jfb 320: argc = -1;
321: }
322:
323: return (argc);
1.17 jfb 324: }
325:
326: /*
327: * cvs_makeargv()
328: *
1.20 david 329: * Allocate an argument vector large enough to accommodate for all the
1.17 jfb 330: * arguments found in <line> and return it.
331: */
1.42 xsa 332: char **
1.17 jfb 333: cvs_makeargv(const char *line, int *argc)
334: {
335: int i, ret;
336: char *argv[1024], **copy;
337:
338: ret = cvs_getargv(line, argv, 1024);
339: if (ret == -1)
340: return (NULL);
341:
1.77 ray 342: copy = xcalloc(ret + 1, sizeof(char *));
1.17 jfb 343:
344: for (i = 0; i < ret; i++)
345: copy[i] = argv[i];
346: copy[ret] = NULL;
347:
348: *argc = ret;
349: return (copy);
1.1 jfb 350: }
351:
352: /*
353: * cvs_freeargv()
354: *
355: * Free an argument vector previously generated by cvs_getargv().
356: */
357: void
358: cvs_freeargv(char **argv, int argc)
359: {
360: int i;
361:
362: for (i = 0; i < argc; i++)
1.16 jfb 363: if (argv[i] != NULL)
1.59 joris 364: xfree(argv[i]);
1.2 jfb 365: }
366:
1.11 krapht 367: /*
368: * cvs_exec()
369: */
370: int
1.96 joris 371: cvs_exec(int argc, char **argv)
1.11 krapht 372: {
373: int ret;
374: pid_t pid;
375:
376: if ((pid = fork()) == -1) {
1.79 joris 377: cvs_log(LP_ERR, "failed to fork");
1.11 krapht 378: return (-1);
379: } else if (pid == 0) {
380: execvp(argv[0], argv);
1.79 joris 381: cvs_log(LP_ERR, "failed to exec %s", argv[0]);
1.13 jfb 382: exit(1);
1.11 krapht 383: }
384:
385: if (waitpid(pid, &ret, 0) == -1)
1.79 joris 386: cvs_log(LP_ERR, "failed to waitpid");
1.11 krapht 387:
388: return (ret);
1.38 xsa 389: }
390:
391: /*
392: * cvs_chdir()
393: *
1.63 xsa 394: * Change to directory <path>.
395: * If <rm> is equal to `1', <path> is removed if chdir() fails so we
396: * do not have temporary directories leftovers.
1.60 xsa 397: * Returns 0 on success.
1.50 xsa 398: */
1.38 xsa 399: int
1.63 xsa 400: cvs_chdir(const char *path, int rm)
1.38 xsa 401: {
1.63 xsa 402: if (chdir(path) == -1) {
403: if (rm == 1)
404: cvs_unlink(path);
1.60 xsa 405: fatal("cvs_chdir: `%s': %s", path, strerror(errno));
1.63 xsa 406: }
1.49 xsa 407:
408: return (0);
409: }
410:
411: /*
412: * cvs_rename()
413: * Change the name of a file.
414: * rename() wrapper with an error message.
1.60 xsa 415: * Returns 0 on success.
1.49 xsa 416: */
417: int
418: cvs_rename(const char *from, const char *to)
419: {
1.90 joris 420: if (cvs_server_active == 0)
421: cvs_log(LP_TRACE, "cvs_rename(%s,%s)", from, to);
1.49 xsa 422:
423: if (cvs_noexec == 1)
424: return (0);
425:
1.60 xsa 426: if (rename(from, to) == -1)
427: fatal("cvs_rename: `%s'->`%s': %s", from, to, strerror(errno));
1.40 xsa 428:
429: return (0);
430: }
431:
432: /*
433: * cvs_unlink()
434: *
435: * Removes the link named by <path>.
436: * unlink() wrapper with an error message.
437: * Returns 0 on success, or -1 on failure.
438: */
439: int
440: cvs_unlink(const char *path)
441: {
1.90 joris 442: if (cvs_server_active == 0)
443: cvs_log(LP_TRACE, "cvs_unlink(%s)", path);
1.40 xsa 444:
445: if (cvs_noexec == 1)
446: return (0);
447:
1.78 deraadt 448: if (unlink(path) == -1 && errno != ENOENT) {
1.94 xsa 449: cvs_log(LP_ERRNO, "%s", path);
1.38 xsa 450: return (-1);
451: }
452:
453: return (0);
1.1 jfb 454: }
1.24 joris 455:
456: /*
1.45 xsa 457: * cvs_rmdir()
1.30 jfb 458: *
459: * Remove a directory tree from disk.
460: * Returns 0 on success, or -1 on failure.
1.24 joris 461: */
462: int
1.45 xsa 463: cvs_rmdir(const char *path)
1.24 joris 464: {
1.99 todd 465: int type, ret = -1;
1.30 jfb 466: size_t len;
1.24 joris 467: DIR *dirp;
468: struct dirent *ent;
1.99 todd 469: struct stat st;
1.24 joris 470: char fpath[MAXPATHLEN];
1.46 xsa 471:
1.90 joris 472: if (cvs_server_active == 0)
473: cvs_log(LP_TRACE, "cvs_rmdir(%s)", path);
1.46 xsa 474:
475: if (cvs_noexec == 1)
476: return (0);
1.24 joris 477:
478: if ((dirp = opendir(path)) == NULL) {
1.79 joris 479: cvs_log(LP_ERR, "failed to open '%s'", path);
1.30 jfb 480: return (-1);
1.24 joris 481: }
482:
483: while ((ent = readdir(dirp)) != NULL) {
484: if (!strcmp(ent->d_name, ".") ||
485: !strcmp(ent->d_name, ".."))
486: continue;
487:
1.30 jfb 488: len = cvs_path_cat(path, ent->d_name, fpath, sizeof(fpath));
1.33 pat 489: if (len >= sizeof(fpath))
1.65 joris 490: fatal("cvs_rmdir: path truncation");
1.24 joris 491:
1.99 todd 492: if (ent->d_type == DT_UNKNOWN) {
493: if (stat(fpath, &st) == -1)
494: fatal("'%s': %s", fpath, strerror(errno));
495:
496: switch (st.st_mode & S_IFMT) {
497: case S_IFDIR:
498: type = CVS_DIR;
499: break;
500: case S_IFREG:
501: type = CVS_FILE;
502: break;
503: default:
504: fatal("'%s': Unknown file type in copy",
505: fpath);
506: }
507: } else {
508: switch (ent->d_type) {
509: case DT_DIR:
510: type = CVS_DIR;
511: break;
512: case DT_REG:
513: type = CVS_FILE;
514: break;
515: default:
516: fatal("'%s': Unknown file type in copy",
517: fpath);
518: }
519: }
520: switch (type) {
521: case CVS_DIR:
1.45 xsa 522: if (cvs_rmdir(fpath) == -1)
1.33 pat 523: goto done;
1.99 todd 524: break;
525: case CVS_FILE:
526: if (cvs_unlink(fpath) == -1 && errno != ENOENT)
527: goto done;
528: break;
529: default:
530: fatal("type %d unknown, shouldn't happen", type);
531: }
1.24 joris 532: }
533:
534:
1.78 deraadt 535: if (rmdir(path) == -1 && errno != ENOENT) {
1.93 xsa 536: cvs_log(LP_ERRNO, "%s", path);
1.33 pat 537: goto done;
1.30 jfb 538: }
1.24 joris 539:
1.33 pat 540: ret = 0;
541: done:
542: closedir(dirp);
1.34 joris 543: return (ret);
544: }
545:
546: /*
1.30 jfb 547: * cvs_path_cat()
548: *
549: * Concatenate the two paths <base> and <end> and store the generated path
550: * into the buffer <dst>, which can accept up to <dlen> bytes, including the
551: * NUL byte. The result is guaranteed to be NUL-terminated.
552: * Returns the number of bytes necessary to store the full resulting path,
553: * not including the NUL byte (a value equal to or larger than <dlen>
554: * indicates truncation).
555: */
1.29 jfb 556: size_t
557: cvs_path_cat(const char *base, const char *end, char *dst, size_t dlen)
558: {
559: size_t len;
560:
561: len = strlcpy(dst, base, dlen);
562: if (len >= dlen - 1) {
563: errno = ENAMETOOLONG;
1.79 joris 564: fatal("overflow in cvs_path_cat");
1.29 jfb 565: } else {
566: dst[len] = '/';
567: dst[len + 1] = '\0';
568: len = strlcat(dst, end, dlen);
569: if (len >= dlen) {
570: errno = ENAMETOOLONG;
1.79 joris 571: cvs_log(LP_ERR, "%s", dst);
1.29 jfb 572: }
573: }
574:
575: return (len);
1.35 xsa 576: }
577:
578: /*
1.79 joris 579: * a hack to mimic and thus match gnu cvs behaviour.
1.35 xsa 580: */
1.79 joris 581: time_t
582: cvs_hack_time(time_t oldtime, int togmt)
1.35 xsa 583: {
1.79 joris 584: int l;
585: struct tm *t;
586: char tbuf[32];
587:
588: if (togmt == 1) {
589: t = gmtime(&oldtime);
590: if (t == NULL)
1.88 joris 591: fatal("gmtime failed");
1.35 xsa 592:
1.79 joris 593: return (mktime(t));
594: }
1.35 xsa 595:
1.79 joris 596: t = localtime(&oldtime);
1.35 xsa 597:
1.79 joris 598: l = snprintf(tbuf, sizeof(tbuf), "%d/%d/%d GMT %d:%d:%d",
599: t->tm_mon + 1, t->tm_mday, t->tm_year + 1900, t->tm_hour,
600: t->tm_min, t->tm_sec);
601: if (l == -1 || l >= (int)sizeof(tbuf))
1.88 joris 602: fatal("cvs_hack_time: overflow");
1.79 joris 603:
604: return (cvs_date_parse(tbuf));
1.51 xsa 605: }
606:
607: void
1.81 joris 608: cvs_get_repository_path(const char *dir, char *dst, size_t len)
609: {
610: char buf[MAXPATHLEN];
611:
612: cvs_get_repository_name(dir, buf, sizeof(buf));
1.92 xsa 613: if (cvs_path_cat(current_cvsroot->cr_dir, buf, dst, len) >= len)
614: fatal("cvs_get_repository_path: truncation");
1.81 joris 615: }
616:
617: void
618: cvs_get_repository_name(const char *dir, char *dst, size_t len)
1.51 xsa 619: {
620: FILE *fp;
1.81 joris 621: char *s, fpath[MAXPATHLEN];
1.79 joris 622:
1.92 xsa 623: if (cvs_path_cat(dir, CVS_PATH_REPOSITORY,
624: fpath, sizeof(fpath)) >= sizeof(fpath))
625: fatal("cvs_get_repository_name: truncation");
1.79 joris 626:
627: if ((fp = fopen(fpath, "r")) != NULL) {
1.101 ! thib 628: if ((fgets(dst, len, fp)) == NULL)
! 629: fatal("cvs_get_repository_name: bad repository file");
1.51 xsa 630:
1.81 joris 631: if ((s = strchr(dst, '\n')) != NULL)
1.79 joris 632: *s = '\0';
1.51 xsa 633:
634: (void)fclose(fp);
1.81 joris 635: } else {
1.84 joris 636: dst[0] = '\0';
637:
638: if (cvs_cmdop == CVS_OP_IMPORT) {
639: if (strlcpy(dst, import_repository, len) >= len)
1.85 joris 640: fatal("cvs_get_repository_name: truncation");
1.84 joris 641: if (strlcat(dst, "/", len) >= len)
1.85 joris 642: fatal("cvs_get_repository_name: truncation");
643:
644: if (strcmp(dir, ".")) {
645: if (strlcat(dst, dir, len) >= len) {
646: fatal("cvs_get_repository_name: "
647: "truncation");
648: }
649: }
650: } else {
1.98 joris 651: if (cvs_cmdop != CVS_OP_CHECKOUT) {
652: if (strlcat(dst, dir, len) >= len)
653: fatal("cvs_get_repository_name: "
654: "truncation");
655: }
1.84 joris 656: }
1.51 xsa 657: }
658: }
659:
660: void
1.87 xsa 661: cvs_mkadmin(const char *path, const char *root, const char *repo,
662: char *tag, char *date, int nb)
1.51 xsa 663: {
664: FILE *fp;
665: size_t len;
1.79 joris 666: struct stat st;
667: char buf[MAXPATHLEN];
1.51 xsa 668:
1.90 joris 669: if (cvs_server_active == 0)
670: cvs_log(LP_TRACE, "cvs_mkadmin(%s, %s, %s, %s, %s, %d)",
671: path, root, repo, (tag != NULL) ? tag : "",
672: (date != NULL) ? date : "", nb);
1.51 xsa 673:
1.79 joris 674: len = cvs_path_cat(path, CVS_PATH_CVSDIR, buf, sizeof(buf));
675: if (len >= sizeof(buf))
676: fatal("cvs_mkadmin: truncation");
1.51 xsa 677:
1.79 joris 678: if (stat(buf, &st) != -1)
679: return;
1.51 xsa 680:
1.79 joris 681: if (mkdir(buf, 0755) == -1 && errno != EEXIST)
682: fatal("cvs_mkadmin: %s: %s", buf, strerror(errno));
683:
684: len = cvs_path_cat(path, CVS_PATH_ROOTSPEC, buf, sizeof(buf));
685: if (len >= sizeof(buf))
686: fatal("cvs_mkadmin: truncation");
687:
688: if ((fp = fopen(buf, "w")) == NULL)
689: fatal("cvs_mkadmin: %s: %s", buf, strerror(errno));
690:
691: fprintf(fp, "%s\n", root);
692: (void)fclose(fp);
1.51 xsa 693:
1.79 joris 694: len = cvs_path_cat(path, CVS_PATH_REPOSITORY, buf, sizeof(buf));
695: if (len >= sizeof(buf))
696: fatal("cvs_mkadmin: truncation");
1.51 xsa 697:
1.79 joris 698: if ((fp = fopen(buf, "w")) == NULL)
699: fatal("cvs_mkadmin: %s: %s", buf, strerror(errno));
1.51 xsa 700:
1.79 joris 701: fprintf(fp, "%s\n", repo);
702: (void)fclose(fp);
1.51 xsa 703:
1.79 joris 704: len = cvs_path_cat(path, CVS_PATH_ENTRIES, buf, sizeof(buf));
705: if (len >= sizeof(buf))
706: fatal("cvs_mkadmin: truncation");
1.51 xsa 707:
1.79 joris 708: if ((fp = fopen(buf, "w")) == NULL)
709: fatal("cvs_mkadmin: %s: %s", buf, strerror(errno));
1.51 xsa 710: (void)fclose(fp);
1.87 xsa 711:
712: cvs_write_tagfile(path, tag, date, nb);
1.54 joris 713: }
714:
1.79 joris 715: void
716: cvs_mkpath(const char *path)
1.72 niallo 717: {
1.79 joris 718: FILE *fp;
719: size_t len;
720: char *sp, *dp, *dir, rpath[MAXPATHLEN], repo[MAXPATHLEN];
721:
722: dir = xstrdup(path);
723:
724: STRIP_SLASH(dir);
1.90 joris 725:
726: if (cvs_server_active == 0)
727: cvs_log(LP_TRACE, "cvs_mkpath(%s)", dir);
1.72 niallo 728:
1.79 joris 729: repo[0] = '\0';
730: rpath[0] = '\0';
1.72 niallo 731:
1.79 joris 732: if (cvs_cmdop == CVS_OP_UPDATE) {
733: if ((fp = fopen(CVS_PATH_REPOSITORY, "r")) != NULL) {
1.91 thib 734: if ((fgets(repo, sizeof(repo), fp)) == NULL)
735: fatal("cvs_mkpath: bad repository file");
736: if ((len = strlen(repo)) && repo[len - 1] == '\n')
737: repo[len - 1] = '\0';
1.79 joris 738: (void)fclose(fp);
739: }
1.72 niallo 740: }
741:
1.79 joris 742: for (sp = dir; sp != NULL; sp = dp) {
743: dp = strchr(sp, '/');
744: if (dp != NULL)
745: *(dp++) = '\0';
746:
747: if (repo[0] != '\0') {
748: len = strlcat(repo, "/", sizeof(repo));
749: if (len >= (int)sizeof(repo))
750: fatal("cvs_mkpath: overflow");
751: }
752:
753: len = strlcat(repo, sp, sizeof(repo));
754: if (len >= (int)sizeof(repo))
755: fatal("cvs_mkpath: overflow");
756:
757: if (rpath[0] != '\0') {
758: len = strlcat(rpath, "/", sizeof(rpath));
759: if (len >= (int)sizeof(rpath))
760: fatal("cvs_mkpath: overflow");
761: }
762:
763: len = strlcat(rpath, sp, sizeof(rpath));
764: if (len >= (int)sizeof(rpath))
765: fatal("cvs_mkpath: overflow");
766:
767: if (mkdir(rpath, 0755) == -1 && errno != EEXIST)
768: fatal("cvs_mkpath: %s: %s", rpath, strerror(errno));
1.72 niallo 769:
1.98 joris 770: cvs_mkadmin(rpath, current_cvsroot->cr_str, repo,
1.87 xsa 771: NULL, NULL, 0);
1.79 joris 772: }
1.72 niallo 773:
1.79 joris 774: xfree(dir);
1.72 niallo 775: }
1.54 joris 776:
777: /*
778: * Split the contents of a file into a list of lines.
779: */
780: struct cvs_lines *
1.97 niallo 781: cvs_splitlines(const u_char *data, size_t len)
1.54 joris 782: {
1.97 niallo 783: u_char *p, *c;
784: size_t i, tlen;
1.54 joris 785: struct cvs_lines *lines;
786: struct cvs_line *lp;
787:
1.77 ray 788: lines = xmalloc(sizeof(*lines));
1.97 niallo 789: memset(lines, 0, sizeof(*lines));
1.54 joris 790: TAILQ_INIT(&(lines->l_lines));
791:
1.77 ray 792: lp = xmalloc(sizeof(*lp));
1.97 niallo 793: memset(lp, 0, sizeof(*lp));
1.54 joris 794: TAILQ_INSERT_TAIL(&(lines->l_lines), lp, l_list);
795:
1.97 niallo 796: p = c = data;
797: for (i = 0; i < len; i++) {
798: if (*p == '\n' || (i == len - 1)) {
799: tlen = p - c + 1;
800: lp = xmalloc(sizeof(*lp));
801: lp->l_line = c;
802: lp->l_len = tlen;
803: lp->l_lineno = ++(lines->l_nblines);
804: TAILQ_INSERT_TAIL(&(lines->l_lines), lp, l_list);
805: c = p + 1;
806: }
807: p++;
1.54 joris 808: }
809:
810: return (lines);
811: }
812:
813: void
814: cvs_freelines(struct cvs_lines *lines)
815: {
816: struct cvs_line *lp;
817:
818: while ((lp = TAILQ_FIRST(&(lines->l_lines))) != NULL) {
819: TAILQ_REMOVE(&(lines->l_lines), lp, l_list);
1.59 joris 820: xfree(lp);
1.54 joris 821: }
822:
1.59 joris 823: xfree(lines);
1.54 joris 824: }
825:
826: BUF *
1.97 niallo 827: cvs_patchfile(const u_char *data, size_t dlen, const u_char *patch, size_t plen,
1.54 joris 828: int (*p)(struct cvs_lines *, struct cvs_lines *))
829: {
830: struct cvs_lines *dlines, *plines;
831: struct cvs_line *lp;
832: BUF *res;
833:
1.97 niallo 834: if ((dlines = cvs_splitlines(data, dlen)) == NULL)
1.54 joris 835: return (NULL);
836:
1.97 niallo 837: if ((plines = cvs_splitlines(patch, plen)) == NULL)
1.54 joris 838: return (NULL);
839:
840: if (p(dlines, plines) < 0) {
841: cvs_freelines(dlines);
842: cvs_freelines(plines);
843: return (NULL);
844: }
845:
1.97 niallo 846: res = cvs_buf_alloc(1024, BUF_AUTOEXT);
1.54 joris 847: TAILQ_FOREACH(lp, &dlines->l_lines, l_list) {
1.97 niallo 848: if (lp->l_line == NULL)
849: continue;
850: cvs_buf_append(res, lp->l_line, lp->l_len);
1.54 joris 851: }
852:
853: cvs_freelines(dlines);
854: cvs_freelines(plines);
855: return (res);
1.70 niallo 856: }
857:
1.71 xsa 858: /*
859: * cvs_strsplit()
860: *
861: * Split a string <str> of <sep>-separated values and allocate
862: * an argument vector for the values found.
863: */
1.73 pat 864: struct cvs_argvector *
1.71 xsa 865: cvs_strsplit(char *str, const char *sep)
866: {
1.73 pat 867: struct cvs_argvector *av;
1.76 ray 868: size_t i = 0;
1.73 pat 869: char **nargv;
1.71 xsa 870: char *cp, *p;
871:
872: cp = xstrdup(str);
1.77 ray 873: av = xmalloc(sizeof(*av));
1.73 pat 874: av->str = cp;
1.77 ray 875: av->argv = xcalloc(i + 1, sizeof(*(av->argv)));
1.71 xsa 876:
877: while ((p = strsep(&cp, sep)) != NULL) {
1.73 pat 878: av->argv[i++] = p;
1.77 ray 879: nargv = xrealloc(av->argv,
880: i + 1, sizeof(*(av->argv)));
1.73 pat 881: av->argv = nargv;
1.71 xsa 882: }
1.73 pat 883: av->argv[i] = NULL;
884:
885: return (av);
886: }
1.71 xsa 887:
1.73 pat 888: /*
889: * cvs_argv_destroy()
890: *
891: * Free an argument vector previously allocated by cvs_strsplit().
892: */
893: void
894: cvs_argv_destroy(struct cvs_argvector *av)
895: {
896: xfree(av->str);
897: xfree(av->argv);
898: xfree(av);
1.82 joris 899: }
900:
901: u_int
902: cvs_revision_select(RCSFILE *file, char *range)
903: {
904: int i;
905: u_int nrev;
906: char *lstr, *rstr;
907: struct rcs_delta *rdp;
908: struct cvs_argvector *revargv, *revrange;
909: RCSNUM *lnum, *rnum;
910:
911: nrev = 0;
912: lnum = rnum = NULL;
913:
914: revargv = cvs_strsplit(range, ",");
915: for (i = 0; revargv->argv[i] != NULL; i++) {
916: revrange = cvs_strsplit(revargv->argv[i], ":");
917: if (revrange->argv[0] == NULL)
918: fatal("invalid revision range: %s", revargv->argv[i]);
919: else if (revrange->argv[1] == NULL)
920: lstr = rstr = revrange->argv[0];
921: else {
922: if (revrange->argv[2] != NULL)
923: fatal("invalid revision range: %s",
924: revargv->argv[i]);
925:
926: lstr = revrange->argv[0];
927: rstr = revrange->argv[1];
928:
929: if (strcmp(lstr, "") == 0)
930: lstr = NULL;
931: if (strcmp(rstr, "") == 0)
932: rstr = NULL;
933: }
934:
935: if (lstr == NULL)
936: lstr = RCS_HEAD_INIT;
937:
1.100 niallo 938: if ((lnum = rcs_translate_tag(lstr, file)) == NULL)
939: fatal("cvs_revision_select: could not translate tag `%s'", lstr);
1.82 joris 940:
941: if (rstr != NULL) {
1.100 niallo 942: if ((rnum = rcs_translate_tag(rstr, file)) == NULL)
943: fatal("cvs_revision_select: could not translate tag `%s'", rstr);
1.82 joris 944: } else {
945: rnum = rcsnum_alloc();
946: rcsnum_cpy(file->rf_head, rnum, 0);
947: }
948:
949: cvs_argv_destroy(revrange);
950:
951: TAILQ_FOREACH(rdp, &(file->rf_delta), rd_list) {
952: if (rcsnum_cmp(rdp->rd_num, lnum, 0) <= 0 &&
953: rcsnum_cmp(rdp->rd_num, rnum, 0) >= 0 &&
954: !(rdp->rd_flags & RCS_RD_SELECT)) {
955: rdp->rd_flags |= RCS_RD_SELECT;
956: nrev++;
957: }
958: }
959: }
960:
961: cvs_argv_destroy(revargv);
962:
963: if (lnum != NULL)
964: rcsnum_free(lnum);
965: if (rnum != NULL)
966: rcsnum_free(rnum);
967:
968: return (nrev);
1.95 xsa 969: }
970:
971: int
972: cvs_yesno(void)
973: {
974: int c, ret;
975:
976: ret = 0;
977:
978: fflush(stderr);
979: fflush(stdout);
980:
981: if ((c = getchar()) != 'y' && c != 'Y')
982: ret = -1;
983: else
984: while (c != EOF && c != '\n')
985: c = getchar();
986:
987: return (ret);
1.71 xsa 988: }
![[BACK]](/icons/back.gif){kind=icon}
Return to util.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / cvs