lib/block.c

   1 /*
   2 **  Copyright 1998-2003 University of Illinois Board of Trustees
   3 **  Copyright 1998-2003 Mark D. Roth
   4 **  All rights reserved.
   5 **
   6 **  block.c - libtar code to handle tar archive header blocks
   7 **
   8 **  Mark D. Roth <roth@uiuc.edu>
   9 **  Campus Information Technologies and Educational Services
  10 **  University of Illinois at Urbana-Champaign
  11 */
  12
  13 #include <internal.h>
  14
  15 #include <errno.h>
  16
  17 #ifdef STDC_HEADERS
  18 # include <string.h>
  19 # include <stdlib.h>
  20 #endif
  21
  22
  23 #define BIT_ISSET(bitmask, bit) ((bitmask) & (bit))
  24
  25
  26 /* read a header block */
  27 int
  28 th_read_internal(TAR *t)
  29 {
  30         int i;
  31         int num_zero_blocks = 0;
  32
  33 #ifdef DEBUG
  34         printf("==> th_read_internal(TAR=\"%s\")\n", t->pathname);
  35 #endif
  36
  37         while ((i = tar_block_read(t, &(t->th_buf))) == T_BLOCKSIZE)
  38         {
  39                 /* two all-zero blocks mark EOF */
  40                 if (t->th_buf.name[0] == '\0')
  41                 {
  42                         num_zero_blocks++;
  43                         if (!BIT_ISSET(t->options, TAR_IGNORE_EOT)
  44                             && num_zero_blocks >= 2)
  45                                 return 0;       /* EOF */
  46                         else
  47                                 continue;
  48                 }
  49
  50                 /* verify magic and version */
  51                 if (BIT_ISSET(t->options, TAR_CHECK_MAGIC)
  52                     && strncmp(t->th_buf.magic, TMAGIC, TMAGLEN - 1) != 0)
  53                 {
  54 #ifdef DEBUG
  55                         puts("!!! unknown magic value in tar header");
  56 #endif
  57                         return -2;
  58                 }
  59
  60                 if (BIT_ISSET(t->options, TAR_CHECK_VERSION)
  61                     && strncmp(t->th_buf.version, TVERSION, TVERSLEN) != 0)
  62                 {
  63 #ifdef DEBUG
  64                         puts("!!! unknown version value in tar header");
  65 #endif
  66                         return -2;
  67                 }
  68
  69                 /* check chksum */
  70                 if (!BIT_ISSET(t->options, TAR_IGNORE_CRC)
  71                     && !th_crc_ok(t))
  72                 {
  73 #ifdef DEBUG
  74                         puts("!!! tar header checksum error");
  75 #endif
  76                         return -2;
  77                 }
  78
  79                 break;
  80         }
  81
  82 #ifdef DEBUG
  83         printf("<== th_read_internal(): returning %d\n", i);
  84 #endif
  85         return i;
  86 }
  87
  88
  89 /* wrapper function for th_read_internal() to handle GNU extensions */
  90 int
  91 th_read(TAR *t)
  92 {
  93         int i, j;
  94         size_t sz;
  95         char *ptr;
  96
  97 #ifdef DEBUG
  98         printf("==> th_read(t=0x%lx)\n", t);
  99 #endif
 100
 101         if (t->th_buf.gnu_longname != NULL)
 102                 free(t->th_buf.gnu_longname);
 103         if (t->th_buf.gnu_longlink != NULL)
 104                 free(t->th_buf.gnu_longlink);
 105         memset(&(t->th_buf), 0, sizeof(struct tar_header));
 106
 107         i = th_read_internal(t);
 108         if (i == 0)
 109                 return 1;
 110         else if (i != T_BLOCKSIZE)
 111         {
 112                 if (i != -1)
 113                         errno = EINVAL;
 114                 return -1;
 115         }
 116
 117         /* check for GNU long link extention */
 118         if (TH_ISLONGLINK(t))
 119         {
 120                 sz = th_get_size(t);
 121                 j = (sz / T_BLOCKSIZE) + (sz % T_BLOCKSIZE ? 1 : 0);
 122 #ifdef DEBUG
 123                 printf("    th_read(): GNU long linkname detected "
 124                        "(%ld bytes, %d blocks)\n", sz, j);
 125 #endif
 126                 t->th_buf.gnu_longlink = (char *)malloc(j * T_BLOCKSIZE);
 127                 if (t->th_buf.gnu_longlink == NULL)
 128                         return -1;
 129
 130                 for (ptr = t->th_buf.gnu_longlink; j > 0;
 131                      j--, ptr += T_BLOCKSIZE)
 132                 {
 133 #ifdef DEBUG
 134                         printf("    th_read(): reading long linkname "
 135                                "(%d blocks left, ptr == %ld)\n", j, ptr);
 136 #endif
 137                         i = tar_block_read(t, ptr);
 138                         if (i != T_BLOCKSIZE)
 139                         {
 140                                 if (i != -1)
 141                                         errno = EINVAL;
 142                                 return -1;
 143                         }
 144 #ifdef DEBUG
 145                         printf("    th_read(): read block == \"%s\"\n", ptr);
 146 #endif
 147                 }
 148 #ifdef DEBUG
 149                 printf("    th_read(): t->th_buf.gnu_longlink == \"%s\"\n",
 150                        t->th_buf.gnu_longlink);
 151 #endif
 152
 153                 i = th_read_internal(t);
 154                 if (i != T_BLOCKSIZE)
 155                 {
 156                         if (i != -1)
 157                                 errno = EINVAL;
 158                         return -1;
 159                 }
 160         }
 161
 162         /* check for GNU long name extention */
 163         if (TH_ISLONGNAME(t))
 164         {
 165                 sz = th_get_size(t);
 166                 j = (sz / T_BLOCKSIZE) + (sz % T_BLOCKSIZE ? 1 : 0);
 167 #ifdef DEBUG
 168                 printf("    th_read(): GNU long filename detected "
 169                        "(%ld bytes, %d blocks)\n", sz, j);
 170 #endif
 171                 t->th_buf.gnu_longname = (char *)malloc(j * T_BLOCKSIZE);
 172                 if (t->th_buf.gnu_longname == NULL)
 173                         return -1;
 174
 175                 for (ptr = t->th_buf.gnu_longname; j > 0;
 176                      j--, ptr += T_BLOCKSIZE)
 177                 {
 178 #ifdef DEBUG
 179                         printf("    th_read(): reading long filename "
 180                                "(%d blocks left, ptr == %ld)\n", j, ptr);
 181 #endif
 182                         i = tar_block_read(t, ptr);
 183                         if (i != T_BLOCKSIZE)
 184                         {
 185                                 if (i != -1)
 186                                         errno = EINVAL;
 187                                 return -1;
 188                         }
 189 #ifdef DEBUG
 190                         printf("    th_read(): read block == \"%s\"\n", ptr);
 191 #endif
 192                 }
 193 #ifdef DEBUG
 194                 printf("    th_read(): t->th_buf.gnu_longname == \"%s\"\n",
 195                        t->th_buf.gnu_longname);
 196 #endif
 197
 198                 i = th_read_internal(t);
 199                 if (i != T_BLOCKSIZE)
 200                 {
 201                         if (i != -1)
 202                                 errno = EINVAL;
 203                         return -1;
 204                 }
 205         }
 206
 207 #if 0
 208         /*
 209         ** work-around for old archive files with broken typeflag fields
 210         ** NOTE: I fixed this in the TH_IS*() macros instead
 211         */
 212
 213         /*
 214         ** (directories are signified with a trailing '/')
 215         */
 216         if (t->th_buf.typeflag == AREGTYPE
 217             && t->th_buf.name[strlen(t->th_buf.name) - 1] == '/')
 218                 t->th_buf.typeflag = DIRTYPE;
 219
 220         /*
 221         ** fallback to using mode bits
 222         */
 223         if (t->th_buf.typeflag == AREGTYPE)
 224         {
 225                 mode = (mode_t)oct_to_int(t->th_buf.mode);
 226
 227                 if (S_ISREG(mode))
 228                         t->th_buf.typeflag = REGTYPE;
 229                 else if (S_ISDIR(mode))
 230                         t->th_buf.typeflag = DIRTYPE;
 231                 else if (S_ISFIFO(mode))
 232                         t->th_buf.typeflag = FIFOTYPE;
 233                 else if (S_ISCHR(mode))
 234                         t->th_buf.typeflag = CHRTYPE;
 235                 else if (S_ISBLK(mode))
 236                         t->th_buf.typeflag = BLKTYPE;
 237                 else if (S_ISLNK(mode))
 238                         t->th_buf.typeflag = SYMTYPE;
 239         }
 240 #endif
 241
 242         return 0;
 243 }
 244
 245
 246 /* write a header block */
 247 int
 248 th_write(TAR *t)
 249 {
 250         int i, j;
 251         char type2;
 252         size_t sz, sz2;
 253         char *ptr;
 254         char buf[T_BLOCKSIZE];
 255
 256 #ifdef DEBUG
 257         printf("==> th_write(TAR=\"%s\")\n", t->pathname);
 258         th_print(t);
 259 #endif
 260
 261         if ((t->options & TAR_GNU) && t->th_buf.gnu_longlink != NULL)
 262         {
 263 #ifdef DEBUG
 264                 printf("th_write(): using gnu_longlink (\"%s\")\n",
 265                        t->th_buf.gnu_longlink);
 266 #endif
 267                 /* save old size and type */
 268                 type2 = t->th_buf.typeflag;
 269                 sz2 = th_get_size(t);
 270
 271                 /* write out initial header block with fake size and type */
 272                 t->th_buf.typeflag = GNU_LONGLINK_TYPE;
 273                 sz = strlen(t->th_buf.gnu_longlink);
 274                 th_set_size(t, sz);
 275                 th_finish(t);
 276                 i = tar_block_write(t, &(t->th_buf));
 277                 if (i != T_BLOCKSIZE)
 278                 {
 279                         if (i != -1)
 280                                 errno = EINVAL;
 281                         return -1;
 282                 }
 283
 284                 /* write out extra blocks containing long name */
 285                 for (j = (sz / T_BLOCKSIZE) + (sz % T_BLOCKSIZE ? 1 : 0),
 286                      ptr = t->th_buf.gnu_longlink; j > 1;
 287                      j--, ptr += T_BLOCKSIZE)
 288                 {
 289                         i = tar_block_write(t, ptr);
 290                         if (i != T_BLOCKSIZE)
 291                         {
 292                                 if (i != -1)
 293                                         errno = EINVAL;
 294                                 return -1;
 295                         }
 296                 }
 297                 memset(buf, 0, T_BLOCKSIZE);
 298                 strncpy(buf, ptr, T_BLOCKSIZE);
 299                 i = tar_block_write(t, &buf);
 300                 if (i != T_BLOCKSIZE)
 301                 {
 302                         if (i != -1)
 303                                 errno = EINVAL;
 304                         return -1;
 305                 }
 306
 307                 /* reset type and size to original values */
 308                 t->th_buf.typeflag = type2;
 309                 th_set_size(t, sz2);
 310         }
 311
 312         if ((t->options & TAR_GNU) && t->th_buf.gnu_longname != NULL)
 313         {
 314 #ifdef DEBUG
 315                 printf("th_write(): using gnu_longname (\"%s\")\n",
 316                        t->th_buf.gnu_longname);
 317 #endif
 318                 /* save old size and type */
 319                 type2 = t->th_buf.typeflag;
 320                 sz2 = th_get_size(t);
 321
 322                 /* write out initial header block with fake size and type */
 323                 t->th_buf.typeflag = GNU_LONGNAME_TYPE;
 324                 sz = strlen(t->th_buf.gnu_longname);
 325                 th_set_size(t, sz);
 326                 th_finish(t);
 327                 i = tar_block_write(t, &(t->th_buf));
 328                 if (i != T_BLOCKSIZE)
 329                 {
 330                         if (i != -1)
 331                                 errno = EINVAL;
 332                         return -1;
 333                 }
 334
 335                 /* write out extra blocks containing long name */
 336                 for (j = (sz / T_BLOCKSIZE) + (sz % T_BLOCKSIZE ? 1 : 0),
 337                      ptr = t->th_buf.gnu_longname; j > 1;
 338                      j--, ptr += T_BLOCKSIZE)
 339                 {
 340                         i = tar_block_write(t, ptr);
 341                         if (i != T_BLOCKSIZE)
 342                         {
 343                                 if (i != -1)
 344                                         errno = EINVAL;
 345                                 return -1;
 346                         }
 347                 }
 348                 memset(buf, 0, T_BLOCKSIZE);
 349                 strncpy(buf, ptr, T_BLOCKSIZE);
 350                 i = tar_block_write(t, &buf);
 351                 if (i != T_BLOCKSIZE)
 352                 {
 353                         if (i != -1)
 354                                 errno = EINVAL;
 355                         return -1;
 356                 }
 357
 358                 /* reset type and size to original values */
 359                 t->th_buf.typeflag = type2;
 360                 th_set_size(t, sz2);
 361         }
 362
 363         th_finish(t);
 364
 365 #ifdef DEBUG
 366         /* print tar header */
 367         th_print(t);
 368 #endif
 369
 370         i = tar_block_write(t, &(t->th_buf));
 371         if (i != T_BLOCKSIZE)
 372         {
 373                 if (i != -1)
 374                         errno = EINVAL;
 375                 return -1;
 376         }
 377
 378 #ifdef DEBUG
 379         puts("th_write(): returning 0");
 380 #endif
 381         return 0;
 382 }
 383
 384