1caf54c4fSMartin Matuska /*- 2caf54c4fSMartin Matuska * Copyright (c) 2003-2007 Tim Kientzle 3caf54c4fSMartin Matuska * All rights reserved. 4caf54c4fSMartin Matuska * 5caf54c4fSMartin Matuska * Redistribution and use in source and binary forms, with or without 6caf54c4fSMartin Matuska * modification, are permitted provided that the following conditions 7caf54c4fSMartin Matuska * are met: 8caf54c4fSMartin Matuska * 1. Redistributions of source code must retain the above copyright 9caf54c4fSMartin Matuska * notice, this list of conditions and the following disclaimer. 10caf54c4fSMartin Matuska * 2. Redistributions in binary form must reproduce the above copyright 11caf54c4fSMartin Matuska * notice, this list of conditions and the following disclaimer in the 12caf54c4fSMartin Matuska * documentation and/or other materials provided with the distribution. 13caf54c4fSMartin Matuska * 14caf54c4fSMartin Matuska * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 15caf54c4fSMartin Matuska * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 16caf54c4fSMartin Matuska * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17caf54c4fSMartin Matuska * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 18caf54c4fSMartin Matuska * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 19caf54c4fSMartin Matuska * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 20caf54c4fSMartin Matuska * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 21caf54c4fSMartin Matuska * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22caf54c4fSMartin Matuska * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 23caf54c4fSMartin Matuska * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24caf54c4fSMartin Matuska */ 25caf54c4fSMartin Matuska 26caf54c4fSMartin Matuska #include "bsdtar_platform.h" 276c22d9efSMartin Matuska __FBSDID("$FreeBSD$"); 28caf54c4fSMartin Matuska 29caf54c4fSMartin Matuska #ifdef HAVE_SYS_STAT_H 30caf54c4fSMartin Matuska #include <sys/stat.h> 31caf54c4fSMartin Matuska #endif 32caf54c4fSMartin Matuska #ifdef HAVE_SYS_TYPES_H 33caf54c4fSMartin Matuska #include <sys/types.h> /* Linux doesn't define mode_t, etc. in sys/stat.h. */ 34caf54c4fSMartin Matuska #endif 35caf54c4fSMartin Matuska #include <ctype.h> 36caf54c4fSMartin Matuska #ifdef HAVE_ERRNO_H 37caf54c4fSMartin Matuska #include <errno.h> 38caf54c4fSMartin Matuska #endif 39caf54c4fSMartin Matuska #ifdef HAVE_IO_H 40caf54c4fSMartin Matuska #include <io.h> 41caf54c4fSMartin Matuska #endif 42caf54c4fSMartin Matuska #ifdef HAVE_STDARG_H 43caf54c4fSMartin Matuska #include <stdarg.h> 44caf54c4fSMartin Matuska #endif 45caf54c4fSMartin Matuska #ifdef HAVE_STDINT_H 46caf54c4fSMartin Matuska #include <stdint.h> 47caf54c4fSMartin Matuska #endif 48caf54c4fSMartin Matuska #include <stdio.h> 49caf54c4fSMartin Matuska #ifdef HAVE_STDLIB_H 50caf54c4fSMartin Matuska #include <stdlib.h> 51caf54c4fSMartin Matuska #endif 52caf54c4fSMartin Matuska #ifdef HAVE_STRING_H 53caf54c4fSMartin Matuska #include <string.h> 54caf54c4fSMartin Matuska #endif 55caf54c4fSMartin Matuska #ifdef HAVE_WCTYPE_H 56caf54c4fSMartin Matuska #include <wctype.h> 57caf54c4fSMartin Matuska #else 58caf54c4fSMartin Matuska /* If we don't have wctype, we need to hack up some version of iswprint(). */ 59caf54c4fSMartin Matuska #define iswprint isprint 60caf54c4fSMartin Matuska #endif 61caf54c4fSMartin Matuska 62caf54c4fSMartin Matuska #include "bsdtar.h" 63caf54c4fSMartin Matuska #include "err.h" 64caf54c4fSMartin Matuska 65caf54c4fSMartin Matuska static size_t bsdtar_expand_char(char *, size_t, char); 66caf54c4fSMartin Matuska static const char *strip_components(const char *path, int elements); 67caf54c4fSMartin Matuska 68caf54c4fSMartin Matuska #if defined(_WIN32) && !defined(__CYGWIN__) 69caf54c4fSMartin Matuska #define read _read 70caf54c4fSMartin Matuska #endif 71caf54c4fSMartin Matuska 72caf54c4fSMartin Matuska /* TODO: Hack up a version of mbtowc for platforms with no wide 73caf54c4fSMartin Matuska * character support at all. I think the following might suffice, 74caf54c4fSMartin Matuska * but it needs careful testing. 75caf54c4fSMartin Matuska * #if !HAVE_MBTOWC 76caf54c4fSMartin Matuska * #define mbtowc(wcp, p, n) ((*wcp = *p), 1) 77caf54c4fSMartin Matuska * #endif 78caf54c4fSMartin Matuska */ 79caf54c4fSMartin Matuska 80caf54c4fSMartin Matuska /* 81caf54c4fSMartin Matuska * Print a string, taking care with any non-printable characters. 82caf54c4fSMartin Matuska * 83caf54c4fSMartin Matuska * Note that we use a stack-allocated buffer to receive the formatted 84caf54c4fSMartin Matuska * string if we can. This is partly performance (avoiding a call to 85caf54c4fSMartin Matuska * malloc()), partly out of expedience (we have to call vsnprintf() 86caf54c4fSMartin Matuska * before malloc() anyway to find out how big a buffer we need; we may 87caf54c4fSMartin Matuska * as well point that first call at a small local buffer in case it 88caf54c4fSMartin Matuska * works), but mostly for safety (so we can use this to print messages 89caf54c4fSMartin Matuska * about out-of-memory conditions). 90caf54c4fSMartin Matuska */ 91caf54c4fSMartin Matuska 92caf54c4fSMartin Matuska void 93caf54c4fSMartin Matuska safe_fprintf(FILE *f, const char *fmt, ...) 94caf54c4fSMartin Matuska { 95caf54c4fSMartin Matuska char fmtbuff_stack[256]; /* Place to format the printf() string. */ 96caf54c4fSMartin Matuska char outbuff[256]; /* Buffer for outgoing characters. */ 97caf54c4fSMartin Matuska char *fmtbuff_heap; /* If fmtbuff_stack is too small, we use malloc */ 98caf54c4fSMartin Matuska char *fmtbuff; /* Pointer to fmtbuff_stack or fmtbuff_heap. */ 99caf54c4fSMartin Matuska int fmtbuff_length; 100caf54c4fSMartin Matuska int length, n; 101caf54c4fSMartin Matuska va_list ap; 102caf54c4fSMartin Matuska const char *p; 103caf54c4fSMartin Matuska unsigned i; 104caf54c4fSMartin Matuska wchar_t wc; 105caf54c4fSMartin Matuska char try_wc; 106caf54c4fSMartin Matuska 107caf54c4fSMartin Matuska /* Use a stack-allocated buffer if we can, for speed and safety. */ 108caf54c4fSMartin Matuska fmtbuff_heap = NULL; 109caf54c4fSMartin Matuska fmtbuff_length = sizeof(fmtbuff_stack); 110caf54c4fSMartin Matuska fmtbuff = fmtbuff_stack; 111caf54c4fSMartin Matuska 112caf54c4fSMartin Matuska /* Try formatting into the stack buffer. */ 113caf54c4fSMartin Matuska va_start(ap, fmt); 114caf54c4fSMartin Matuska length = vsnprintf(fmtbuff, fmtbuff_length, fmt, ap); 115caf54c4fSMartin Matuska va_end(ap); 116caf54c4fSMartin Matuska 117caf54c4fSMartin Matuska /* If the result was too large, allocate a buffer on the heap. */ 118*6c95142eSMartin Matuska while (length < 0 || length >= fmtbuff_length) { 119*6c95142eSMartin Matuska if (length >= fmtbuff_length) 120caf54c4fSMartin Matuska fmtbuff_length = length+1; 121*6c95142eSMartin Matuska else if (fmtbuff_length < 8192) 122*6c95142eSMartin Matuska fmtbuff_length *= 2; 123*6c95142eSMartin Matuska else { 124*6c95142eSMartin Matuska int old_length = fmtbuff_length; 125*6c95142eSMartin Matuska fmtbuff_length += fmtbuff_length / 4; 126*6c95142eSMartin Matuska if (old_length > fmtbuff_length) { 127*6c95142eSMartin Matuska length = old_length; 128*6c95142eSMartin Matuska fmtbuff_heap[length-1] = '\0'; 129*6c95142eSMartin Matuska break; 130*6c95142eSMartin Matuska } 131*6c95142eSMartin Matuska } 132*6c95142eSMartin Matuska free(fmtbuff_heap); 133caf54c4fSMartin Matuska fmtbuff_heap = malloc(fmtbuff_length); 134caf54c4fSMartin Matuska 135caf54c4fSMartin Matuska /* Reformat the result into the heap buffer if we can. */ 136caf54c4fSMartin Matuska if (fmtbuff_heap != NULL) { 137caf54c4fSMartin Matuska fmtbuff = fmtbuff_heap; 138caf54c4fSMartin Matuska va_start(ap, fmt); 139caf54c4fSMartin Matuska length = vsnprintf(fmtbuff, fmtbuff_length, fmt, ap); 140caf54c4fSMartin Matuska va_end(ap); 141caf54c4fSMartin Matuska } else { 142caf54c4fSMartin Matuska /* Leave fmtbuff pointing to the truncated 143caf54c4fSMartin Matuska * string in fmtbuff_stack. */ 144caf54c4fSMartin Matuska length = sizeof(fmtbuff_stack) - 1; 145*6c95142eSMartin Matuska break; 146caf54c4fSMartin Matuska } 147caf54c4fSMartin Matuska } 148caf54c4fSMartin Matuska 149caf54c4fSMartin Matuska /* Note: mbrtowc() has a cleaner API, but mbtowc() seems a bit 150caf54c4fSMartin Matuska * more portable, so we use that here instead. */ 151caf54c4fSMartin Matuska n = mbtowc(NULL, NULL, 1); /* Reset the shift state. */ 152caf54c4fSMartin Matuska 153caf54c4fSMartin Matuska /* Write data, expanding unprintable characters. */ 154caf54c4fSMartin Matuska p = fmtbuff; 155caf54c4fSMartin Matuska i = 0; 156caf54c4fSMartin Matuska try_wc = 1; 157caf54c4fSMartin Matuska while (*p != '\0') { 158caf54c4fSMartin Matuska 159caf54c4fSMartin Matuska /* Convert to wide char, test if the wide 160caf54c4fSMartin Matuska * char is printable in the current locale. */ 161caf54c4fSMartin Matuska if (try_wc && (n = mbtowc(&wc, p, length)) != -1) { 162caf54c4fSMartin Matuska length -= n; 163caf54c4fSMartin Matuska if (iswprint(wc) && wc != L'\\') { 164caf54c4fSMartin Matuska /* Printable, copy the bytes through. */ 165caf54c4fSMartin Matuska while (n-- > 0) 166caf54c4fSMartin Matuska outbuff[i++] = *p++; 167caf54c4fSMartin Matuska } else { 168caf54c4fSMartin Matuska /* Not printable, format the bytes. */ 169caf54c4fSMartin Matuska while (n-- > 0) 170caf54c4fSMartin Matuska i += (unsigned)bsdtar_expand_char( 171caf54c4fSMartin Matuska outbuff, i, *p++); 172caf54c4fSMartin Matuska } 173caf54c4fSMartin Matuska } else { 174caf54c4fSMartin Matuska /* After any conversion failure, don't bother 175caf54c4fSMartin Matuska * trying to convert the rest. */ 176caf54c4fSMartin Matuska i += (unsigned)bsdtar_expand_char(outbuff, i, *p++); 177caf54c4fSMartin Matuska try_wc = 0; 178caf54c4fSMartin Matuska } 179caf54c4fSMartin Matuska 180caf54c4fSMartin Matuska /* If our output buffer is full, dump it and keep going. */ 181caf54c4fSMartin Matuska if (i > (sizeof(outbuff) - 20)) { 182caf54c4fSMartin Matuska outbuff[i] = '\0'; 183caf54c4fSMartin Matuska fprintf(f, "%s", outbuff); 184caf54c4fSMartin Matuska i = 0; 185caf54c4fSMartin Matuska } 186caf54c4fSMartin Matuska } 187caf54c4fSMartin Matuska outbuff[i] = '\0'; 188caf54c4fSMartin Matuska fprintf(f, "%s", outbuff); 189caf54c4fSMartin Matuska 190caf54c4fSMartin Matuska /* If we allocated a heap-based formatting buffer, free it now. */ 191caf54c4fSMartin Matuska if (fmtbuff_heap != NULL) 192caf54c4fSMartin Matuska free(fmtbuff_heap); 193caf54c4fSMartin Matuska } 194caf54c4fSMartin Matuska 195caf54c4fSMartin Matuska /* 196caf54c4fSMartin Matuska * Render an arbitrary sequence of bytes into printable ASCII characters. 197caf54c4fSMartin Matuska */ 198caf54c4fSMartin Matuska static size_t 199caf54c4fSMartin Matuska bsdtar_expand_char(char *buff, size_t offset, char c) 200caf54c4fSMartin Matuska { 201caf54c4fSMartin Matuska size_t i = offset; 202caf54c4fSMartin Matuska 203caf54c4fSMartin Matuska if (isprint((unsigned char)c) && c != '\\') 204caf54c4fSMartin Matuska buff[i++] = c; 205caf54c4fSMartin Matuska else { 206caf54c4fSMartin Matuska buff[i++] = '\\'; 207caf54c4fSMartin Matuska switch (c) { 208caf54c4fSMartin Matuska case '\a': buff[i++] = 'a'; break; 209caf54c4fSMartin Matuska case '\b': buff[i++] = 'b'; break; 210caf54c4fSMartin Matuska case '\f': buff[i++] = 'f'; break; 211caf54c4fSMartin Matuska case '\n': buff[i++] = 'n'; break; 212caf54c4fSMartin Matuska #if '\r' != '\n' 213caf54c4fSMartin Matuska /* On some platforms, \n and \r are the same. */ 214caf54c4fSMartin Matuska case '\r': buff[i++] = 'r'; break; 215caf54c4fSMartin Matuska #endif 216caf54c4fSMartin Matuska case '\t': buff[i++] = 't'; break; 217caf54c4fSMartin Matuska case '\v': buff[i++] = 'v'; break; 218caf54c4fSMartin Matuska case '\\': buff[i++] = '\\'; break; 219caf54c4fSMartin Matuska default: 220caf54c4fSMartin Matuska sprintf(buff + i, "%03o", 0xFF & (int)c); 221caf54c4fSMartin Matuska i += 3; 222caf54c4fSMartin Matuska } 223caf54c4fSMartin Matuska } 224caf54c4fSMartin Matuska 225caf54c4fSMartin Matuska return (i - offset); 226caf54c4fSMartin Matuska } 227caf54c4fSMartin Matuska 228caf54c4fSMartin Matuska int 229caf54c4fSMartin Matuska yes(const char *fmt, ...) 230caf54c4fSMartin Matuska { 231caf54c4fSMartin Matuska char buff[32]; 232caf54c4fSMartin Matuska char *p; 233caf54c4fSMartin Matuska ssize_t l; 234caf54c4fSMartin Matuska 235caf54c4fSMartin Matuska va_list ap; 236caf54c4fSMartin Matuska va_start(ap, fmt); 237caf54c4fSMartin Matuska vfprintf(stderr, fmt, ap); 238caf54c4fSMartin Matuska va_end(ap); 239caf54c4fSMartin Matuska fprintf(stderr, " (y/N)? "); 240caf54c4fSMartin Matuska fflush(stderr); 241caf54c4fSMartin Matuska 242caf54c4fSMartin Matuska l = read(2, buff, sizeof(buff) - 1); 243c5d360f8SMartin Matuska if (l < 0) { 244c5d360f8SMartin Matuska fprintf(stderr, "Keyboard read failed\n"); 245c5d360f8SMartin Matuska exit(1); 246c5d360f8SMartin Matuska } 247c5d360f8SMartin Matuska if (l == 0) 248caf54c4fSMartin Matuska return (0); 249caf54c4fSMartin Matuska buff[l] = 0; 250caf54c4fSMartin Matuska 251caf54c4fSMartin Matuska for (p = buff; *p != '\0'; p++) { 252caf54c4fSMartin Matuska if (isspace((unsigned char)*p)) 253caf54c4fSMartin Matuska continue; 254caf54c4fSMartin Matuska switch(*p) { 255caf54c4fSMartin Matuska case 'y': case 'Y': 256caf54c4fSMartin Matuska return (1); 257caf54c4fSMartin Matuska case 'n': case 'N': 258caf54c4fSMartin Matuska return (0); 259caf54c4fSMartin Matuska default: 260caf54c4fSMartin Matuska return (0); 261caf54c4fSMartin Matuska } 262caf54c4fSMartin Matuska } 263caf54c4fSMartin Matuska 264caf54c4fSMartin Matuska return (0); 265caf54c4fSMartin Matuska } 266caf54c4fSMartin Matuska 267caf54c4fSMartin Matuska /*- 268caf54c4fSMartin Matuska * The logic here for -C <dir> attempts to avoid 269caf54c4fSMartin Matuska * chdir() as long as possible. For example: 270caf54c4fSMartin Matuska * "-C /foo -C /bar file" needs chdir("/bar") but not chdir("/foo") 271caf54c4fSMartin Matuska * "-C /foo -C bar file" needs chdir("/foo/bar") 272caf54c4fSMartin Matuska * "-C /foo -C bar /file1" does not need chdir() 273caf54c4fSMartin Matuska * "-C /foo -C bar /file1 file2" needs chdir("/foo/bar") before file2 274caf54c4fSMartin Matuska * 275caf54c4fSMartin Matuska * The only correct way to handle this is to record a "pending" chdir 276caf54c4fSMartin Matuska * request and combine multiple requests intelligently until we 277caf54c4fSMartin Matuska * need to process a non-absolute file. set_chdir() adds the new dir 278caf54c4fSMartin Matuska * to the pending list; do_chdir() actually executes any pending chdir. 279caf54c4fSMartin Matuska * 280caf54c4fSMartin Matuska * This way, programs that build tar command lines don't have to worry 281caf54c4fSMartin Matuska * about -C with non-existent directories; such requests will only 282caf54c4fSMartin Matuska * fail if the directory must be accessed. 283caf54c4fSMartin Matuska * 284caf54c4fSMartin Matuska */ 285caf54c4fSMartin Matuska void 286caf54c4fSMartin Matuska set_chdir(struct bsdtar *bsdtar, const char *newdir) 287caf54c4fSMartin Matuska { 288*6c95142eSMartin Matuska #if defined(_WIN32) && !defined(__CYGWIN__) 289*6c95142eSMartin Matuska if (newdir[0] == '/' || newdir[0] == '\\' || 290*6c95142eSMartin Matuska /* Detect this type, for example, "C:\" or "C:/" */ 291*6c95142eSMartin Matuska (((newdir[0] >= 'a' && newdir[0] <= 'z') || 292*6c95142eSMartin Matuska (newdir[0] >= 'A' && newdir[0] <= 'Z')) && 293*6c95142eSMartin Matuska newdir[1] == ':' && (newdir[2] == '/' || newdir[2] == '\\'))) { 294*6c95142eSMartin Matuska #else 295caf54c4fSMartin Matuska if (newdir[0] == '/') { 296*6c95142eSMartin Matuska #endif 297caf54c4fSMartin Matuska /* The -C /foo -C /bar case; dump first one. */ 298caf54c4fSMartin Matuska free(bsdtar->pending_chdir); 299caf54c4fSMartin Matuska bsdtar->pending_chdir = NULL; 300caf54c4fSMartin Matuska } 301caf54c4fSMartin Matuska if (bsdtar->pending_chdir == NULL) 302caf54c4fSMartin Matuska /* Easy case: no previously-saved dir. */ 303caf54c4fSMartin Matuska bsdtar->pending_chdir = strdup(newdir); 304caf54c4fSMartin Matuska else { 305caf54c4fSMartin Matuska /* The -C /foo -C bar case; concatenate */ 306caf54c4fSMartin Matuska char *old_pending = bsdtar->pending_chdir; 307caf54c4fSMartin Matuska size_t old_len = strlen(old_pending); 308caf54c4fSMartin Matuska bsdtar->pending_chdir = malloc(old_len + strlen(newdir) + 2); 309caf54c4fSMartin Matuska if (old_pending[old_len - 1] == '/') 310caf54c4fSMartin Matuska old_pending[old_len - 1] = '\0'; 311caf54c4fSMartin Matuska if (bsdtar->pending_chdir != NULL) 312caf54c4fSMartin Matuska sprintf(bsdtar->pending_chdir, "%s/%s", 313caf54c4fSMartin Matuska old_pending, newdir); 314caf54c4fSMartin Matuska free(old_pending); 315caf54c4fSMartin Matuska } 316caf54c4fSMartin Matuska if (bsdtar->pending_chdir == NULL) 317caf54c4fSMartin Matuska lafe_errc(1, errno, "No memory"); 318caf54c4fSMartin Matuska } 319caf54c4fSMartin Matuska 320caf54c4fSMartin Matuska void 321caf54c4fSMartin Matuska do_chdir(struct bsdtar *bsdtar) 322caf54c4fSMartin Matuska { 323caf54c4fSMartin Matuska if (bsdtar->pending_chdir == NULL) 324caf54c4fSMartin Matuska return; 325caf54c4fSMartin Matuska 326caf54c4fSMartin Matuska if (chdir(bsdtar->pending_chdir) != 0) { 327caf54c4fSMartin Matuska lafe_errc(1, 0, "could not chdir to '%s'\n", 328caf54c4fSMartin Matuska bsdtar->pending_chdir); 329caf54c4fSMartin Matuska } 330caf54c4fSMartin Matuska free(bsdtar->pending_chdir); 331caf54c4fSMartin Matuska bsdtar->pending_chdir = NULL; 332caf54c4fSMartin Matuska } 333caf54c4fSMartin Matuska 334caf54c4fSMartin Matuska static const char * 335caf54c4fSMartin Matuska strip_components(const char *p, int elements) 336caf54c4fSMartin Matuska { 337caf54c4fSMartin Matuska /* Skip as many elements as necessary. */ 338caf54c4fSMartin Matuska while (elements > 0) { 339caf54c4fSMartin Matuska switch (*p++) { 340caf54c4fSMartin Matuska case '/': 341caf54c4fSMartin Matuska #if defined(_WIN32) && !defined(__CYGWIN__) 342caf54c4fSMartin Matuska case '\\': /* Support \ path sep on Windows ONLY. */ 343caf54c4fSMartin Matuska #endif 344caf54c4fSMartin Matuska elements--; 345caf54c4fSMartin Matuska break; 346caf54c4fSMartin Matuska case '\0': 347caf54c4fSMartin Matuska /* Path is too short, skip it. */ 348caf54c4fSMartin Matuska return (NULL); 349caf54c4fSMartin Matuska } 350caf54c4fSMartin Matuska } 351caf54c4fSMartin Matuska 352caf54c4fSMartin Matuska /* Skip any / characters. This handles short paths that have 353caf54c4fSMartin Matuska * additional / termination. This also handles the case where 354caf54c4fSMartin Matuska * the logic above stops in the middle of a duplicate // 355caf54c4fSMartin Matuska * sequence (which would otherwise get converted to an 356caf54c4fSMartin Matuska * absolute path). */ 357caf54c4fSMartin Matuska for (;;) { 358caf54c4fSMartin Matuska switch (*p) { 359caf54c4fSMartin Matuska case '/': 360caf54c4fSMartin Matuska #if defined(_WIN32) && !defined(__CYGWIN__) 361caf54c4fSMartin Matuska case '\\': /* Support \ path sep on Windows ONLY. */ 362caf54c4fSMartin Matuska #endif 363caf54c4fSMartin Matuska ++p; 364caf54c4fSMartin Matuska break; 365caf54c4fSMartin Matuska case '\0': 366caf54c4fSMartin Matuska return (NULL); 367caf54c4fSMartin Matuska default: 368caf54c4fSMartin Matuska return (p); 369caf54c4fSMartin Matuska } 370caf54c4fSMartin Matuska } 371caf54c4fSMartin Matuska } 372caf54c4fSMartin Matuska 373caf54c4fSMartin Matuska /* 374caf54c4fSMartin Matuska * Handle --strip-components and any future path-rewriting options. 375caf54c4fSMartin Matuska * Returns non-zero if the pathname should not be extracted. 376caf54c4fSMartin Matuska * 377caf54c4fSMartin Matuska * TODO: Support pax-style regex path rewrites. 378caf54c4fSMartin Matuska */ 379caf54c4fSMartin Matuska int 380caf54c4fSMartin Matuska edit_pathname(struct bsdtar *bsdtar, struct archive_entry *entry) 381caf54c4fSMartin Matuska { 382caf54c4fSMartin Matuska const char *name = archive_entry_pathname(entry); 383caf54c4fSMartin Matuska #if HAVE_REGEX_H 384caf54c4fSMartin Matuska char *subst_name; 385caf54c4fSMartin Matuska int r; 386caf54c4fSMartin Matuska 387*6c95142eSMartin Matuska r = apply_substitution(bsdtar, name, &subst_name, 0, 0); 388caf54c4fSMartin Matuska if (r == -1) { 389caf54c4fSMartin Matuska lafe_warnc(0, "Invalid substitution, skipping entry"); 390caf54c4fSMartin Matuska return 1; 391caf54c4fSMartin Matuska } 392caf54c4fSMartin Matuska if (r == 1) { 393caf54c4fSMartin Matuska archive_entry_copy_pathname(entry, subst_name); 394caf54c4fSMartin Matuska if (*subst_name == '\0') { 395caf54c4fSMartin Matuska free(subst_name); 396caf54c4fSMartin Matuska return -1; 397caf54c4fSMartin Matuska } else 398caf54c4fSMartin Matuska free(subst_name); 399caf54c4fSMartin Matuska name = archive_entry_pathname(entry); 400caf54c4fSMartin Matuska } 401caf54c4fSMartin Matuska 402caf54c4fSMartin Matuska if (archive_entry_hardlink(entry)) { 403*6c95142eSMartin Matuska r = apply_substitution(bsdtar, archive_entry_hardlink(entry), &subst_name, 0, 1); 404caf54c4fSMartin Matuska if (r == -1) { 405caf54c4fSMartin Matuska lafe_warnc(0, "Invalid substitution, skipping entry"); 406caf54c4fSMartin Matuska return 1; 407caf54c4fSMartin Matuska } 408caf54c4fSMartin Matuska if (r == 1) { 409caf54c4fSMartin Matuska archive_entry_copy_hardlink(entry, subst_name); 410caf54c4fSMartin Matuska free(subst_name); 411caf54c4fSMartin Matuska } 412caf54c4fSMartin Matuska } 413caf54c4fSMartin Matuska if (archive_entry_symlink(entry) != NULL) { 414*6c95142eSMartin Matuska r = apply_substitution(bsdtar, archive_entry_symlink(entry), &subst_name, 1, 0); 415caf54c4fSMartin Matuska if (r == -1) { 416caf54c4fSMartin Matuska lafe_warnc(0, "Invalid substitution, skipping entry"); 417caf54c4fSMartin Matuska return 1; 418caf54c4fSMartin Matuska } 419caf54c4fSMartin Matuska if (r == 1) { 420caf54c4fSMartin Matuska archive_entry_copy_symlink(entry, subst_name); 421caf54c4fSMartin Matuska free(subst_name); 422caf54c4fSMartin Matuska } 423caf54c4fSMartin Matuska } 424caf54c4fSMartin Matuska #endif 425caf54c4fSMartin Matuska 426caf54c4fSMartin Matuska /* Strip leading dir names as per --strip-components option. */ 427caf54c4fSMartin Matuska if (bsdtar->strip_components > 0) { 428caf54c4fSMartin Matuska const char *linkname = archive_entry_hardlink(entry); 429caf54c4fSMartin Matuska 430caf54c4fSMartin Matuska name = strip_components(name, bsdtar->strip_components); 431caf54c4fSMartin Matuska if (name == NULL) 432caf54c4fSMartin Matuska return (1); 433caf54c4fSMartin Matuska 434caf54c4fSMartin Matuska if (linkname != NULL) { 435caf54c4fSMartin Matuska linkname = strip_components(linkname, 436caf54c4fSMartin Matuska bsdtar->strip_components); 437caf54c4fSMartin Matuska if (linkname == NULL) 438caf54c4fSMartin Matuska return (1); 439caf54c4fSMartin Matuska archive_entry_copy_hardlink(entry, linkname); 440caf54c4fSMartin Matuska } 441caf54c4fSMartin Matuska } 442caf54c4fSMartin Matuska 443caf54c4fSMartin Matuska /* By default, don't write or restore absolute pathnames. */ 444caf54c4fSMartin Matuska if (!bsdtar->option_absolute_paths) { 445caf54c4fSMartin Matuska const char *rp, *p = name; 446caf54c4fSMartin Matuska int slashonly = 1; 447caf54c4fSMartin Matuska 448caf54c4fSMartin Matuska /* Remove leading "//./" or "//?/" or "//?/UNC/" 449caf54c4fSMartin Matuska * (absolute path prefixes used by Windows API) */ 450caf54c4fSMartin Matuska if ((p[0] == '/' || p[0] == '\\') && 451caf54c4fSMartin Matuska (p[1] == '/' || p[1] == '\\') && 452caf54c4fSMartin Matuska (p[2] == '.' || p[2] == '?') && 453caf54c4fSMartin Matuska (p[3] == '/' || p[3] == '\\')) 454caf54c4fSMartin Matuska { 455caf54c4fSMartin Matuska if (p[2] == '?' && 456caf54c4fSMartin Matuska (p[4] == 'U' || p[4] == 'u') && 457caf54c4fSMartin Matuska (p[5] == 'N' || p[5] == 'n') && 458caf54c4fSMartin Matuska (p[6] == 'C' || p[6] == 'c') && 459caf54c4fSMartin Matuska (p[7] == '/' || p[7] == '\\')) 460caf54c4fSMartin Matuska p += 8; 461caf54c4fSMartin Matuska else 462caf54c4fSMartin Matuska p += 4; 463caf54c4fSMartin Matuska slashonly = 0; 464caf54c4fSMartin Matuska } 465caf54c4fSMartin Matuska do { 466caf54c4fSMartin Matuska rp = p; 467caf54c4fSMartin Matuska /* Remove leading drive letter from archives created 468caf54c4fSMartin Matuska * on Windows. */ 469caf54c4fSMartin Matuska if (((p[0] >= 'a' && p[0] <= 'z') || 470caf54c4fSMartin Matuska (p[0] >= 'A' && p[0] <= 'Z')) && 471caf54c4fSMartin Matuska p[1] == ':') { 472caf54c4fSMartin Matuska p += 2; 473caf54c4fSMartin Matuska slashonly = 0; 474caf54c4fSMartin Matuska } 475caf54c4fSMartin Matuska /* Remove leading "/../", "//", etc. */ 476caf54c4fSMartin Matuska while (p[0] == '/' || p[0] == '\\') { 477caf54c4fSMartin Matuska if (p[1] == '.' && p[2] == '.' && 478caf54c4fSMartin Matuska (p[3] == '/' || p[3] == '\\')) { 479caf54c4fSMartin Matuska p += 3; /* Remove "/..", leave "/" 480caf54c4fSMartin Matuska * for next pass. */ 481caf54c4fSMartin Matuska slashonly = 0; 482caf54c4fSMartin Matuska } else 483caf54c4fSMartin Matuska p += 1; /* Remove "/". */ 484caf54c4fSMartin Matuska } 485caf54c4fSMartin Matuska } while (rp != p); 486caf54c4fSMartin Matuska 487caf54c4fSMartin Matuska if (p != name && !bsdtar->warned_lead_slash) { 488caf54c4fSMartin Matuska /* Generate a warning the first time this happens. */ 489caf54c4fSMartin Matuska if (slashonly) 490caf54c4fSMartin Matuska lafe_warnc(0, 491caf54c4fSMartin Matuska "Removing leading '%c' from member names", 492caf54c4fSMartin Matuska name[0]); 493caf54c4fSMartin Matuska else 494caf54c4fSMartin Matuska lafe_warnc(0, 495caf54c4fSMartin Matuska "Removing leading drive letter from " 496caf54c4fSMartin Matuska "member names"); 497caf54c4fSMartin Matuska bsdtar->warned_lead_slash = 1; 498caf54c4fSMartin Matuska } 499caf54c4fSMartin Matuska 500caf54c4fSMartin Matuska /* Special case: Stripping everything yields ".". */ 501caf54c4fSMartin Matuska if (*p == '\0') 502caf54c4fSMartin Matuska name = "."; 503caf54c4fSMartin Matuska else 504caf54c4fSMartin Matuska name = p; 505caf54c4fSMartin Matuska } else { 506caf54c4fSMartin Matuska /* Strip redundant leading '/' characters. */ 507caf54c4fSMartin Matuska while (name[0] == '/' && name[1] == '/') 508caf54c4fSMartin Matuska name++; 509caf54c4fSMartin Matuska } 510caf54c4fSMartin Matuska 511caf54c4fSMartin Matuska /* Safely replace name in archive_entry. */ 512caf54c4fSMartin Matuska if (name != archive_entry_pathname(entry)) { 513caf54c4fSMartin Matuska char *q = strdup(name); 514caf54c4fSMartin Matuska archive_entry_copy_pathname(entry, q); 515caf54c4fSMartin Matuska free(q); 516caf54c4fSMartin Matuska } 517caf54c4fSMartin Matuska return (0); 518caf54c4fSMartin Matuska } 519caf54c4fSMartin Matuska 520caf54c4fSMartin Matuska /* 521caf54c4fSMartin Matuska * It would be nice to just use printf() for formatting large numbers, 522caf54c4fSMartin Matuska * but the compatibility problems are quite a headache. Hence the 523caf54c4fSMartin Matuska * following simple utility function. 524caf54c4fSMartin Matuska */ 525caf54c4fSMartin Matuska const char * 526caf54c4fSMartin Matuska tar_i64toa(int64_t n0) 527caf54c4fSMartin Matuska { 528caf54c4fSMartin Matuska static char buff[24]; 529*6c95142eSMartin Matuska uint64_t n = n0 < 0 ? -n0 : n0; 530caf54c4fSMartin Matuska char *p = buff + sizeof(buff); 531caf54c4fSMartin Matuska 532caf54c4fSMartin Matuska *--p = '\0'; 533caf54c4fSMartin Matuska do { 534caf54c4fSMartin Matuska *--p = '0' + (int)(n % 10); 535*6c95142eSMartin Matuska } while (n /= 10); 536caf54c4fSMartin Matuska if (n0 < 0) 537caf54c4fSMartin Matuska *--p = '-'; 538caf54c4fSMartin Matuska return p; 539caf54c4fSMartin Matuska } 540caf54c4fSMartin Matuska 541caf54c4fSMartin Matuska /* 542caf54c4fSMartin Matuska * Like strcmp(), but try to be a little more aware of the fact that 543caf54c4fSMartin Matuska * we're comparing two paths. Right now, it just handles leading 544caf54c4fSMartin Matuska * "./" and trailing '/' specially, so that "a/b/" == "./a/b" 545caf54c4fSMartin Matuska * 546caf54c4fSMartin Matuska * TODO: Make this better, so that "./a//b/./c/" == "a/b/c" 547caf54c4fSMartin Matuska * TODO: After this works, push it down into libarchive. 548caf54c4fSMartin Matuska * TODO: Publish the path normalization routines in libarchive so 549caf54c4fSMartin Matuska * that bsdtar can normalize paths and use fast strcmp() instead 550caf54c4fSMartin Matuska * of this. 551caf54c4fSMartin Matuska * 552caf54c4fSMartin Matuska * Note: This is currently only used within write.c, so should 553caf54c4fSMartin Matuska * not handle \ path separators. 554caf54c4fSMartin Matuska */ 555caf54c4fSMartin Matuska 556caf54c4fSMartin Matuska int 557caf54c4fSMartin Matuska pathcmp(const char *a, const char *b) 558caf54c4fSMartin Matuska { 559caf54c4fSMartin Matuska /* Skip leading './' */ 560caf54c4fSMartin Matuska if (a[0] == '.' && a[1] == '/' && a[2] != '\0') 561caf54c4fSMartin Matuska a += 2; 562caf54c4fSMartin Matuska if (b[0] == '.' && b[1] == '/' && b[2] != '\0') 563caf54c4fSMartin Matuska b += 2; 564caf54c4fSMartin Matuska /* Find the first difference, or return (0) if none. */ 565caf54c4fSMartin Matuska while (*a == *b) { 566caf54c4fSMartin Matuska if (*a == '\0') 567caf54c4fSMartin Matuska return (0); 568caf54c4fSMartin Matuska a++; 569caf54c4fSMartin Matuska b++; 570caf54c4fSMartin Matuska } 571caf54c4fSMartin Matuska /* 572caf54c4fSMartin Matuska * If one ends in '/' and the other one doesn't, 573caf54c4fSMartin Matuska * they're the same. 574caf54c4fSMartin Matuska */ 575caf54c4fSMartin Matuska if (a[0] == '/' && a[1] == '\0' && b[0] == '\0') 576caf54c4fSMartin Matuska return (0); 577caf54c4fSMartin Matuska if (a[0] == '\0' && b[0] == '/' && b[1] == '\0') 578caf54c4fSMartin Matuska return (0); 579caf54c4fSMartin Matuska /* They're really different, return the correct sign. */ 580caf54c4fSMartin Matuska return (*(const unsigned char *)a - *(const unsigned char *)b); 581caf54c4fSMartin Matuska } 582