| 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 |
print_tar_number(char *s, int len, uint64 val) |
| 23 |
{ |
| 24 |
if (val < (((uint64) 1) << ((len - 1) * 3))) |
| 25 |
{ |
| 26 |
/* Use octal with trailing space */ |
| 27 |
s[--len] = ' '; |
| 28 |
while (len) |
| 29 |
{ |
| 30 |
s[--len] = (val & 7) + '0'; |
| 31 |
val >>= 3; |
| 32 |
} |
| 33 |
} |
| 34 |
else |
| 35 |
{ |
| 36 |
/* Use base-256 with leading \200 */ |
| 37 |
s[0] = '\200'; |
| 38 |
while (len > 1) |
| 39 |
{ |
| 40 |
s[--len] = (val & 255); |
| 41 |
val >>= 8; |
| 42 |
} |
| 43 |
} |
| 44 |
} |
| 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 |
read_tar_number(const char *s, int len) |
| 59 |
{ |
| 60 |
uint64 result = 0; |
| 61 |
|
| 62 |
if (*s == '\200') |
| 63 |
{ |
| 64 |
/* base-256 */ |
| 65 |
while (--len) |
| 66 |
{ |
| 67 |
result <<= 8; |
| 68 |
result |= (unsigned char) (*++s); |
| 69 |
} |
| 70 |
} |
| 71 |
else |
| 72 |
{ |
| 73 |
/* octal */ |
| 74 |
while (len-- && *s >= '0' && *s <= '7') |
| 75 |
{ |
| 76 |
result <<= 3; |
| 77 |
result |= (*s - '0'); |
| 78 |
s++; |
| 79 |
} |
| 80 |
} |
| 81 |
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 |
tarChecksum(const 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 TAR_OFFSET_CHECKSUM) as though it contained 8 spaces. |
| 99 |
*/ |
| 100 |
sum = 8 * ' '; /* presumed value for checksum field */ |
| 101 |
for (i = 0; i < TAR_BLOCK_SIZE; i++) |
| 102 |
if (i < TAR_OFFSET_CHECKSUM || i >= TAR_OFFSET_CHECKSUM + 8) |
| 103 |
sum += 0xFF & header[i]; |
| 104 |
return sum; |
| 105 |
} |
| 106 |
|
| 107 |
/* |
| 108 |
* Check validity of a tar header (assumed to be 512 bytes long). |
| 109 |
* We verify the checksum and the magic number / version. |
| 110 |
*/ |
| 111 |
bool |
| 112 |
isValidTarHeader(const char *header) |
| 113 |
{ |
| 114 |
int sum; |
| 115 |
int chk = tarChecksum(header); |
| 116 |
|
| 117 |
sum = read_tar_number(&header[TAR_OFFSET_CHECKSUM], 8); |
| 118 |
|
| 119 |
if (sum != chk) |
| 120 |
return false; |
| 121 |
|
| 122 |
/* POSIX tar format */ |
| 123 |
if (memcmp(&header[TAR_OFFSET_MAGIC], "ustar\0", 6) == 0 && |
| 124 |
memcmp(&header[TAR_OFFSET_VERSION], "00", 2) == 0) |
| 125 |
return true; |
| 126 |
/* GNU tar format */ |
| 127 |
if (memcmp(&header[TAR_OFFSET_MAGIC], "ustar \0", 8) == 0) |
| 128 |
return true; |
| 129 |
/* not-quite-POSIX format written by pre-9.3 pg_dump */ |
| 130 |
if (memcmp(&header[TAR_OFFSET_MAGIC], "ustar00\0", 8) == 0) |
| 131 |
return true; |
| 132 |
|
| 133 |
return false; |
| 134 |
} |
| 135 |
|
| 136 |
|
| 137 |
/* |
| 138 |
* Fill in the buffer pointed to by h with a tar format header. This buffer |
| 139 |
* must always have space for 512 characters, which is a requirement of |
| 140 |
* the tar format. |
| 141 |
*/ |
| 142 |
enum tarError |
| 143 |
tarCreateHeader(char *h, const char *filename, const char *linktarget, |
| 144 |
pgoff_t size, mode_t mode, uid_t uid, gid_t gid, time_t mtime) |
| 145 |
{ |
| 146 |
if (strlen(filename) > 99) |
| 147 |
return TAR_NAME_TOO_LONG; |
| 148 |
|
| 149 |
if (linktarget && strlen(linktarget) > 99) |
| 150 |
return TAR_SYMLINK_TOO_LONG; |
| 151 |
|
| 152 |
memset(h, 0, TAR_BLOCK_SIZE); |
| 153 |
|
| 154 |
/* Name 100 */ |
| 155 |
strlcpy(&h[TAR_OFFSET_NAME], filename, 100); |
| 156 |
if (linktarget != NULL || S_ISDIR(mode)) |
| 157 |
{ |
| 158 |
/* |
| 159 |
* We only support symbolic links to directories, and this is |
| 160 |
* indicated in the tar format by adding a slash at the end of the |
| 161 |
* name, the same as for regular directories. |
| 162 |
*/ |
| 163 |
int flen = strlen(filename); |
| 164 |
|
| 165 |
flen = Min(flen, 99); |
| 166 |
h[flen] = '/'; |
| 167 |
h[flen + 1] = '\0'; |
| 168 |
} |
| 169 |
|
| 170 |
/* Mode 8 - this doesn't include the file type bits (S_IFMT) */ |
| 171 |
print_tar_number(&h[TAR_OFFSET_MODE], 8, (mode & 07777)); |
| 172 |
|
| 173 |
/* User ID 8 */ |
| 174 |
print_tar_number(&h[TAR_OFFSET_UID], 8, uid); |
| 175 |
|
| 176 |
/* Group 8 */ |
| 177 |
print_tar_number(&h[TAR_OFFSET_GID], 8, gid); |
| 178 |
|
| 179 |
/* File size 12 */ |
| 180 |
if (linktarget != NULL || S_ISDIR(mode)) |
| 181 |
/* Symbolic link or directory has size zero */ |
| 182 |
print_tar_number(&h[TAR_OFFSET_SIZE], 12, 0); |
| 183 |
else |
| 184 |
print_tar_number(&h[TAR_OFFSET_SIZE], 12, size); |
| 185 |
|
| 186 |
/* Mod Time 12 */ |
| 187 |
print_tar_number(&h[TAR_OFFSET_MTIME], 12, mtime); |
| 188 |
|
| 189 |
/* Checksum 8 cannot be calculated until we've filled all other fields */ |
| 190 |
|
| 191 |
if (linktarget != NULL) |
| 192 |
{ |
| 193 |
/* Type - Symbolic link */ |
| 194 |
h[TAR_OFFSET_TYPEFLAG] = TAR_FILETYPE_SYMLINK; |
| 195 |
/* Link Name 100 */ |
| 196 |
strlcpy(&h[TAR_OFFSET_LINKNAME], linktarget, 100); |
| 197 |
} |
| 198 |
else if (S_ISDIR(mode)) |
| 199 |
{ |
| 200 |
/* Type - directory */ |
| 201 |
h[TAR_OFFSET_TYPEFLAG] = TAR_FILETYPE_DIRECTORY; |
| 202 |
} |
| 203 |
else |
| 204 |
{ |
| 205 |
/* Type - regular file */ |
| 206 |
h[TAR_OFFSET_TYPEFLAG] = TAR_FILETYPE_PLAIN; |
| 207 |
} |
| 208 |
|
| 209 |
/* Magic 6 */ |
| 210 |
strcpy(&h[TAR_OFFSET_MAGIC], "ustar"); |
| 211 |
|
| 212 |
/* Version 2 */ |
| 213 |
memcpy(&h[TAR_OFFSET_VERSION], "00", 2); |
| 214 |
|
| 215 |
/* User 32 */ |
| 216 |
/* XXX: Do we need to care about setting correct username? */ |
| 217 |
strlcpy(&h[TAR_OFFSET_UNAME], "postgres", 32); |
| 218 |
|
| 219 |
/* Group 32 */ |
| 220 |
/* XXX: Do we need to care about setting correct group name? */ |
| 221 |
strlcpy(&h[TAR_OFFSET_GNAME], "postgres", 32); |
| 222 |
|
| 223 |
/* Major Dev 8 */ |
| 224 |
print_tar_number(&h[TAR_OFFSET_DEVMAJOR], 8, 0); |
| 225 |
|
| 226 |
/* Minor Dev 8 */ |
| 227 |
print_tar_number(&h[TAR_OFFSET_DEVMINOR], 8, 0); |
| 228 |
|
| 229 |
/* Prefix 155 - not used, leave as nulls */ |
| 230 |
|
| 231 |
/* Finally, compute and insert the checksum */ |
| 232 |
print_tar_number(&h[TAR_OFFSET_CHECKSUM], 8, tarChecksum(h)); |
| 233 |
|
| 234 |
return TAR_OK; |
| 235 |
} |