LCOV - code coverage report
Current view: top level - src/port - tar.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 53 61 86.9 %
Date: 2019-11-13 22:07:24 Functions: 4 4 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : #include "c.h"
       2             : 
       3             : #include <sys/stat.h>
       4             : 
       5             : #include "pgtar.h"
       6             : 
       7             : /*
       8             :  * Print a numeric field in a tar header.  The field starts at *s and is of
       9             :  * length len; val is the value to be written.
      10             :  *
      11             :  * Per POSIX, the way to write a number is in octal with leading zeroes and
      12             :  * one trailing space (or NUL, but we use space) at the end of the specified
      13             :  * field width.
      14             :  *
      15             :  * However, the given value may not fit in the available space in octal form.
      16             :  * If that's true, we use the GNU extension of writing \200 followed by the
      17             :  * number in base-256 form (ie, stored in binary MSB-first).  (Note: here we
      18             :  * support only non-negative numbers, so we don't worry about the GNU rules
      19             :  * for handling negative numbers.)
      20             :  */
      21             : void
      22      723184 : print_tar_number(char *s, int len, uint64 val)
      23             : {
      24      723184 :     if (val < (((uint64) 1) << ((len - 1) * 3)))
      25             :     {
      26             :         /* Use octal with trailing space */
      27      723184 :         s[--len] = ' ';
      28     7231856 :         while (len)
      29             :         {
      30     5785488 :             s[--len] = (val & 7) + '0';
      31     5785488 :             val >>= 3;
      32             :         }
      33             :     }
      34             :     else
      35             :     {
      36             :         /* Use base-256 with leading \200 */
      37           0 :         s[0] = '\200';
      38           0 :         while (len > 1)
      39             :         {
      40           0 :             s[--len] = (val & 255);
      41           0 :             val >>= 8;
      42             :         }
      43             :     }
      44      723184 : }
      45             : 
      46             : 
      47             : /*
      48             :  * Read a numeric field in a tar header.  The field starts at *s and is of
      49             :  * length len.
      50             :  *
      51             :  * The POSIX-approved format for a number is octal, ending with a space or
      52             :  * NUL.  However, for values that don't fit, we recognize the GNU extension
      53             :  * of \200 followed by the number in base-256 form (ie, stored in binary
      54             :  * MSB-first).  (Note: here we support only non-negative numbers, so we don't
      55             :  * worry about the GNU rules for handling negative numbers.)
      56             :  */
      57             : uint64
      58      164954 : read_tar_number(const char *s, int len)
      59             : {
      60      164954 :     uint64      result = 0;
      61             : 
      62      164954 :     if (*s == '\200')
      63             :     {
      64             :         /* base-256 */
      65           0 :         while (--len)
      66             :         {
      67           0 :             result <<= 8;
      68           0 :             result |= (unsigned char) (*++s);
      69             :         }
      70             :     }
      71             :     else
      72             :     {
      73             :         /* octal */
      74     1814490 :         while (len-- && *s >= '0' && *s <= '7')
      75             :         {
      76     1484582 :             result <<= 3;
      77     1484582 :             result |= (*s - '0');
      78     1484582 :             s++;
      79             :         }
      80             :     }
      81      164954 :     return result;
      82             : }
      83             : 
      84             : 
      85             : /*
      86             :  * Calculate the tar checksum for a header. The header is assumed to always
      87             :  * be 512 bytes, per the tar standard.
      88             :  */
      89             : int
      90       90446 : tarChecksum(char *header)
      91             : {
      92             :     int         i,
      93             :                 sum;
      94             : 
      95             :     /*
      96             :      * Per POSIX, the checksum is the simple sum of all bytes in the header,
      97             :      * treating the bytes as unsigned, and treating the checksum field (at
      98             :      * offset 148) as though it contained 8 spaces.
      99             :      */
     100       90446 :     sum = 8 * ' ';              /* presumed value for checksum field */
     101    46398798 :     for (i = 0; i < 512; i++)
     102    46308352 :         if (i < 148 || i >= 156)
     103    45584784 :             sum += 0xFF & header[i];
     104       90446 :     return sum;
     105             : }
     106             : 
     107             : 
     108             : /*
     109             :  * Fill in the buffer pointed to by h with a tar format header. This buffer
     110             :  * must always have space for 512 characters, which is a requirement of
     111             :  * the tar format.
     112             :  */
     113             : enum tarError
     114       90398 : tarCreateHeader(char *h, const char *filename, const char *linktarget,
     115             :                 pgoff_t size, mode_t mode, uid_t uid, gid_t gid, time_t mtime)
     116             : {
     117       90398 :     if (strlen(filename) > 99)
     118           2 :         return TAR_NAME_TOO_LONG;
     119             : 
     120       90396 :     if (linktarget && strlen(linktarget) > 99)
     121           0 :         return TAR_SYMLINK_TOO_LONG;
     122             : 
     123       90396 :     memset(h, 0, 512);          /* assume tar header size */
     124             : 
     125             :     /* Name 100 */
     126       90396 :     strlcpy(&h[0], filename, 100);
     127       90396 :     if (linktarget != NULL || S_ISDIR(mode))
     128             :     {
     129             :         /*
     130             :          * We only support symbolic links to directories, and this is
     131             :          * indicated in the tar format by adding a slash at the end of the
     132             :          * name, the same as for regular directories.
     133             :          */
     134        2400 :         int         flen = strlen(filename);
     135             : 
     136        2400 :         flen = Min(flen, 99);
     137        2400 :         h[flen] = '/';
     138        2400 :         h[flen + 1] = '\0';
     139             :     }
     140             : 
     141             :     /* Mode 8 - this doesn't include the file type bits (S_IFMT)  */
     142       90396 :     print_tar_number(&h[100], 8, (mode & 07777));
     143             : 
     144             :     /* User ID 8 */
     145       90396 :     print_tar_number(&h[108], 8, uid);
     146             : 
     147             :     /* Group 8 */
     148       90396 :     print_tar_number(&h[116], 8, gid);
     149             : 
     150             :     /* File size 12 */
     151       90396 :     if (linktarget != NULL || S_ISDIR(mode))
     152             :         /* Symbolic link or directory has size zero */
     153        2400 :         print_tar_number(&h[124], 12, 0);
     154             :     else
     155       87996 :         print_tar_number(&h[124], 12, size);
     156             : 
     157             :     /* Mod Time 12 */
     158       90396 :     print_tar_number(&h[136], 12, mtime);
     159             : 
     160             :     /* Checksum 8 cannot be calculated until we've filled all other fields */
     161             : 
     162       90396 :     if (linktarget != NULL)
     163             :     {
     164             :         /* Type - Symbolic link */
     165           4 :         h[156] = '2';
     166             :         /* Link Name 100 */
     167           4 :         strlcpy(&h[157], linktarget, 100);
     168             :     }
     169       90392 :     else if (S_ISDIR(mode))
     170             :     {
     171             :         /* Type - directory */
     172        2396 :         h[156] = '5';
     173             :     }
     174             :     else
     175             :     {
     176             :         /* Type - regular file */
     177       87996 :         h[156] = '0';
     178             :     }
     179             : 
     180             :     /* Magic 6 */
     181       90396 :     strcpy(&h[257], "ustar");
     182             : 
     183             :     /* Version 2 */
     184       90396 :     memcpy(&h[263], "00", 2);
     185             : 
     186             :     /* User 32 */
     187             :     /* XXX: Do we need to care about setting correct username? */
     188       90396 :     strlcpy(&h[265], "postgres", 32);
     189             : 
     190             :     /* Group 32 */
     191             :     /* XXX: Do we need to care about setting correct group name? */
     192       90396 :     strlcpy(&h[297], "postgres", 32);
     193             : 
     194             :     /* Major Dev 8 */
     195       90396 :     print_tar_number(&h[329], 8, 0);
     196             : 
     197             :     /* Minor Dev 8 */
     198       90396 :     print_tar_number(&h[337], 8, 0);
     199             : 
     200             :     /* Prefix 155 - not used, leave as nulls */
     201             : 
     202             :     /* Finally, compute and insert the checksum */
     203       90396 :     print_tar_number(&h[148], 8, tarChecksum(h));
     204             : 
     205       90396 :     return TAR_OK;
     206             : }

Generated by: LCOV version 1.13