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 2498372 : print_tar_number(char *s, int len, uint64 val)
23 : {
24 2498372 : if (val < (((uint64) 1) << ((len - 1) * 3)))
25 : {
26 : /* Use octal with trailing space */
27 2498372 : s[--len] = ' ';
28 22485400 : while (len)
29 : {
30 19987028 : s[--len] = (val & 7) + '0';
31 19987028 : 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 2498372 : }
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 1200398 : read_tar_number(const char *s, int len)
59 : {
60 1200398 : uint64 result = 0;
61 :
62 1200398 : 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 10803736 : while (len-- && *s >= '0' && *s <= '7')
75 : {
76 9603338 : result <<= 3;
77 9603338 : result |= (*s - '0');
78 9603338 : s++;
79 : }
80 : }
81 1200398 : 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 312396 : 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 312396 : sum = 8 * ' '; /* presumed value for checksum field */
101 160259148 : for (i = 0; i < 512; i++)
102 159946752 : if (i < 148 || i >= 156)
103 157447584 : sum += 0xFF & header[i];
104 312396 : 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 312292 : 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 312292 : if (strlen(filename) > 99)
118 2 : return TAR_NAME_TOO_LONG;
119 :
120 312290 : if (linktarget && strlen(linktarget) > 99)
121 0 : return TAR_SYMLINK_TOO_LONG;
122 :
123 312290 : memset(h, 0, TAR_BLOCK_SIZE);
124 :
125 : /* Name 100 */
126 312290 : strlcpy(&h[TAR_OFFSET_NAME], filename, 100);
127 312290 : 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 8248 : int flen = strlen(filename);
135 :
136 8248 : flen = Min(flen, 99);
137 8248 : h[flen] = '/';
138 8248 : h[flen + 1] = '\0';
139 : }
140 :
141 : /* Mode 8 - this doesn't include the file type bits (S_IFMT) */
142 312290 : print_tar_number(&h[TAR_OFFSET_MODE], 8, (mode & 07777));
143 :
144 : /* User ID 8 */
145 312290 : print_tar_number(&h[TAR_OFFSET_UID], 8, uid);
146 :
147 : /* Group 8 */
148 312290 : print_tar_number(&h[TAR_OFFSET_GID], 8, gid);
149 :
150 : /* File size 12 */
151 312290 : if (linktarget != NULL || S_ISDIR(mode))
152 : /* Symbolic link or directory has size zero */
153 8248 : print_tar_number(&h[TAR_OFFSET_SIZE], 12, 0);
154 : else
155 304042 : print_tar_number(&h[TAR_OFFSET_SIZE], 12, size);
156 :
157 : /* Mod Time 12 */
158 312290 : print_tar_number(&h[TAR_OFFSET_MTIME], 12, mtime);
159 :
160 : /* Checksum 8 cannot be calculated until we've filled all other fields */
161 :
162 312290 : if (linktarget != NULL)
163 : {
164 : /* Type - Symbolic link */
165 32 : h[TAR_OFFSET_TYPEFLAG] = TAR_FILETYPE_SYMLINK;
166 : /* Link Name 100 */
167 32 : strlcpy(&h[TAR_OFFSET_LINKNAME], linktarget, 100);
168 : }
169 312258 : else if (S_ISDIR(mode))
170 : {
171 : /* Type - directory */
172 8216 : h[TAR_OFFSET_TYPEFLAG] = TAR_FILETYPE_DIRECTORY;
173 : }
174 : else
175 : {
176 : /* Type - regular file */
177 304042 : h[TAR_OFFSET_TYPEFLAG] = TAR_FILETYPE_PLAIN;
178 : }
179 :
180 : /* Magic 6 */
181 312290 : strcpy(&h[TAR_OFFSET_MAGIC], "ustar");
182 :
183 : /* Version 2 */
184 312290 : memcpy(&h[TAR_OFFSET_VERSION], "00", 2);
185 :
186 : /* User 32 */
187 : /* XXX: Do we need to care about setting correct username? */
188 312290 : strlcpy(&h[TAR_OFFSET_UNAME], "postgres", 32);
189 :
190 : /* Group 32 */
191 : /* XXX: Do we need to care about setting correct group name? */
192 312290 : strlcpy(&h[TAR_OFFSET_GNAME], "postgres", 32);
193 :
194 : /* Major Dev 8 */
195 312290 : print_tar_number(&h[TAR_OFFSET_DEVMAJOR], 8, 0);
196 :
197 : /* Minor Dev 8 */
198 312290 : print_tar_number(&h[TAR_OFFSET_DEVMINOR], 8, 0);
199 :
200 : /* Prefix 155 - not used, leave as nulls */
201 :
202 : /* Finally, compute and insert the checksum */
203 312290 : print_tar_number(&h[TAR_OFFSET_CHECKSUM], 8, tarChecksum(h));
204 :
205 312290 : return TAR_OK;
206 : }
|
