Debian Codegraph @

src/port/tar.c

raw
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 }