blob: 438770c034460f6253a11ed1811bb4a86cee89da [file] [log] [blame]
Eric Andersencc8ed391999-10-05 16:24:54 +00001/*
Eric Andersenc4996011999-10-20 22:08:37 +00002 * Mini tar implementation for busybox based on code taken from sash.
3 *
Eric Andersencc8ed391999-10-05 16:24:54 +00004 * Copyright (c) 1999 by David I. Bell
5 * Permission is granted to use, distribute, or modify this source,
6 * provided that this copyright notice remains intact.
7 *
Eric Andersencc8ed391999-10-05 16:24:54 +00008 * Permission to distribute this code under the GPL has been granted.
Eric Andersenc4996011999-10-20 22:08:37 +00009 *
Eric Andersen3cf52d11999-10-12 22:26:06 +000010 * Modified for busybox by Erik Andersen <andersee@debian.org>
Eric Andersenc4996011999-10-20 22:08:37 +000011 * Adjusted to grok stdin/stdout options.
12 *
Eric Andersen96bcfd31999-11-12 01:30:18 +000013 * Modified to handle device special files by Matt Porter
14 * <porter@debian.org>
15 *
Eric Andersenc4996011999-10-20 22:08:37 +000016 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
20 *
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 * General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 *
Eric Andersencc8ed391999-10-05 16:24:54 +000030 */
31
32
33#include "internal.h"
Eric Andersencc8ed391999-10-05 16:24:54 +000034#include <stdio.h>
35#include <dirent.h>
36#include <errno.h>
37#include <fcntl.h>
38#include <signal.h>
39#include <time.h>
Eric Andersen96bcfd31999-11-12 01:30:18 +000040#include <sys/types.h>
Eric Andersen08b10341999-11-19 02:38:58 +000041#include <sys/sysmacros.h>
Eric Andersencc8ed391999-10-05 16:24:54 +000042
Eric Andersene77ae3a1999-10-19 20:03:34 +000043
44static const char tar_usage[] =
Eric Andersend73dc5b1999-11-10 23:13:02 +000045"tar -[cxtvOf] [tarFileName] [FILE] ...\n\n"
46"Create, extract, or list files from a tar file\n\n"
47"Options:\n"
48"\tc=create, x=extract, t=list contents, v=verbose,\n"
49"\tO=extract to stdout, f=tarfile or \"-\" for stdin\n";
Eric Andersene77ae3a1999-10-19 20:03:34 +000050
51
52
Eric Andersencc8ed391999-10-05 16:24:54 +000053/*
54 * Tar file constants.
55 */
56#define TAR_BLOCK_SIZE 512
57#define TAR_NAME_SIZE 100
58
59
60/*
61 * The POSIX (and basic GNU) tar header format.
62 * This structure is always embedded in a TAR_BLOCK_SIZE sized block
63 * with zero padding. We only process this information minimally.
64 */
Eric Andersen3cf52d11999-10-12 22:26:06 +000065typedef struct {
66 char name[TAR_NAME_SIZE];
67 char mode[8];
68 char uid[8];
69 char gid[8];
70 char size[12];
71 char mtime[12];
72 char checkSum[8];
73 char typeFlag;
74 char linkName[TAR_NAME_SIZE];
75 char magic[6];
76 char version[2];
77 char uname[32];
78 char gname[32];
79 char devMajor[8];
80 char devMinor[8];
81 char prefix[155];
Eric Andersencc8ed391999-10-05 16:24:54 +000082} TarHeader;
83
84#define TAR_MAGIC "ustar"
85#define TAR_VERSION "00"
86
87#define TAR_TYPE_REGULAR '0'
88#define TAR_TYPE_HARD_LINK '1'
89#define TAR_TYPE_SOFT_LINK '2'
90
91
92/*
93 * Static data.
94 */
Eric Andersend73dc5b1999-11-10 23:13:02 +000095static int listFlag;
96static int extractFlag;
97static int createFlag;
98static int verboseFlag;
99static int tostdoutFlag;
Eric Andersencc8ed391999-10-05 16:24:54 +0000100
Eric Andersen5556c181999-11-10 19:27:58 +0000101static int inHeader; // <- check me
Eric Andersend73dc5b1999-11-10 23:13:02 +0000102static int badHeader;
103static int errorFlag;
104static int skipFileFlag;
105static int warnedRoot;
106static int eofFlag;
Eric Andersen3cf52d11999-10-12 22:26:06 +0000107static long dataCc;
108static int outFd;
109static char outName[TAR_NAME_SIZE];
Eric Andersencc8ed391999-10-05 16:24:54 +0000110
111
112/*
113 * Static data associated with the tar file.
114 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000115static const char *tarName;
116static int tarFd;
117static dev_t tarDev;
118static ino_t tarInode;
Eric Andersencc8ed391999-10-05 16:24:54 +0000119
120
121/*
122 * Local procedures to restore files from a tar file.
123 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000124static void readTarFile (int fileCount, char **fileTable);
125static void readData (const char *cp, int count);
Eric Andersen3cf52d11999-10-12 22:26:06 +0000126static long getOctal (const char *cp, int len);
Eric Andersencc8ed391999-10-05 16:24:54 +0000127
Eric Andersen3cf52d11999-10-12 22:26:06 +0000128static void readHeader (const TarHeader * hp,
129 int fileCount, char **fileTable);
Eric Andersencc8ed391999-10-05 16:24:54 +0000130
131
132/*
133 * Local procedures to save files into a tar file.
134 */
Eric Andersend73dc5b1999-11-10 23:13:02 +0000135static void saveFile (const char *fileName, int seeLinks);
Eric Andersencc8ed391999-10-05 16:24:54 +0000136
Eric Andersen3cf52d11999-10-12 22:26:06 +0000137static void saveRegularFile (const char *fileName,
138 const struct stat *statbuf);
Eric Andersencc8ed391999-10-05 16:24:54 +0000139
Eric Andersen3cf52d11999-10-12 22:26:06 +0000140static void saveDirectory (const char *fileName,
141 const struct stat *statbuf);
Eric Andersencc8ed391999-10-05 16:24:54 +0000142
Eric Andersen3cf52d11999-10-12 22:26:06 +0000143static int wantFileName (const char *fileName,
Eric Andersend73dc5b1999-11-10 23:13:02 +0000144 int fileCount, char **fileTable);
Eric Andersencc8ed391999-10-05 16:24:54 +0000145
Eric Andersen3cf52d11999-10-12 22:26:06 +0000146static void writeHeader (const char *fileName, const struct stat *statbuf);
Eric Andersencc8ed391999-10-05 16:24:54 +0000147
Eric Andersen3cf52d11999-10-12 22:26:06 +0000148static void writeTarFile (int fileCount, char **fileTable);
149static void writeTarBlock (const char *buf, int len);
Eric Andersend73dc5b1999-11-10 23:13:02 +0000150static int putOctal (char *cp, int len, long value);
Eric Andersencc8ed391999-10-05 16:24:54 +0000151
152
Eric Andersen3cf52d11999-10-12 22:26:06 +0000153extern int tar_main (int argc, char **argv)
Eric Andersencc8ed391999-10-05 16:24:54 +0000154{
Eric Andersen3cf52d11999-10-12 22:26:06 +0000155 const char *options;
Eric Andersencc8ed391999-10-05 16:24:54 +0000156
Eric Andersen3cf52d11999-10-12 22:26:06 +0000157 argc--;
158 argv++;
Eric Andersencc8ed391999-10-05 16:24:54 +0000159
Eric Andersenbe971d61999-11-03 16:52:50 +0000160 if (argc < 1)
161 usage( tar_usage);
Eric Andersencc8ed391999-10-05 16:24:54 +0000162
163
Eric Andersen3cf52d11999-10-12 22:26:06 +0000164 errorFlag = FALSE;
165 extractFlag = FALSE;
166 createFlag = FALSE;
167 listFlag = FALSE;
168 verboseFlag = FALSE;
169 tostdoutFlag = FALSE;
170 tarName = NULL;
171 tarDev = 0;
172 tarInode = 0;
173 tarFd = -1;
Eric Andersencc8ed391999-10-05 16:24:54 +0000174
Eric Andersen3cf52d11999-10-12 22:26:06 +0000175 /*
176 * Parse the options.
177 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000178 if (**argv == '-') {
Eric Andersen50d63601999-11-09 01:47:36 +0000179 options = (*argv++) + 1;
180 argc--;
Eric Andersen3cf52d11999-10-12 22:26:06 +0000181 for (; *options; options++) {
182 switch (*options) {
183 case 'f':
184 if (tarName != NULL) {
185 fprintf (stderr, "Only one 'f' option allowed\n");
Eric Andersencc8ed391999-10-05 16:24:54 +0000186
Eric Andersen3cf52d11999-10-12 22:26:06 +0000187 exit (FALSE);
Eric Andersencc8ed391999-10-05 16:24:54 +0000188 }
Eric Andersen3cf52d11999-10-12 22:26:06 +0000189
190 tarName = *argv++;
191 argc--;
192
193 break;
194
195 case 't':
196 listFlag = TRUE;
197 break;
198
199 case 'x':
200 extractFlag = TRUE;
201 break;
202
203 case 'c':
204 createFlag = TRUE;
205 break;
206
207 case 'v':
208 verboseFlag = TRUE;
209 break;
210
211 case 'O':
212 tostdoutFlag = TRUE;
213 break;
214
215 case '-':
Eric Andersend73dc5b1999-11-10 23:13:02 +0000216 usage( tar_usage);
Eric Andersen3cf52d11999-10-12 22:26:06 +0000217 break;
218
219 default:
Eric Andersend73dc5b1999-11-10 23:13:02 +0000220 fprintf (stderr, "Unknown tar flag '%c'\n"
221 "Try `tar --help' for more information\n",
222 *options);
Eric Andersen3cf52d11999-10-12 22:26:06 +0000223
224 exit (FALSE);
225 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000226 }
Eric Andersen3cf52d11999-10-12 22:26:06 +0000227 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000228
Eric Andersen3cf52d11999-10-12 22:26:06 +0000229 /*
230 * Validate the options.
231 */
Eric Andersen5556c181999-11-10 19:27:58 +0000232 if (extractFlag + listFlag + createFlag != (TRUE+FALSE+FALSE)) {
Eric Andersen3cf52d11999-10-12 22:26:06 +0000233 fprintf (stderr,
234 "Exactly one of 'c', 'x' or 't' must be specified\n");
Eric Andersencc8ed391999-10-05 16:24:54 +0000235
Eric Andersen3cf52d11999-10-12 22:26:06 +0000236 exit (FALSE);
237 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000238
Eric Andersen3cf52d11999-10-12 22:26:06 +0000239 /*
240 * Do the correct type of action supplying the rest of the
241 * command line arguments as the list of files to process.
242 */
Eric Andersen5556c181999-11-10 19:27:58 +0000243 if (createFlag==TRUE)
Eric Andersen3cf52d11999-10-12 22:26:06 +0000244 writeTarFile (argc, argv);
245 else
246 readTarFile (argc, argv);
Eric Andersen5556c181999-11-10 19:27:58 +0000247 if (errorFlag==TRUE)
Eric Andersen3cf52d11999-10-12 22:26:06 +0000248 fprintf (stderr, "\n");
Eric Andersen5556c181999-11-10 19:27:58 +0000249 exit (!errorFlag);
Eric Andersencc8ed391999-10-05 16:24:54 +0000250}
251
252
253/*
254 * Read a tar file and extract or list the specified files within it.
255 * If the list is empty than all files are extracted or listed.
256 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000257static void readTarFile (int fileCount, char **fileTable)
Eric Andersencc8ed391999-10-05 16:24:54 +0000258{
Eric Andersen3cf52d11999-10-12 22:26:06 +0000259 const char *cp;
260 int cc;
261 int inCc;
262 int blockSize;
263 char buf[BUF_SIZE];
Eric Andersencc8ed391999-10-05 16:24:54 +0000264
Eric Andersen3cf52d11999-10-12 22:26:06 +0000265 skipFileFlag = FALSE;
266 badHeader = FALSE;
267 warnedRoot = FALSE;
268 eofFlag = FALSE;
269 inHeader = TRUE;
270 inCc = 0;
271 dataCc = 0;
272 outFd = -1;
273 blockSize = sizeof (buf);
274 cp = buf;
Eric Andersencc8ed391999-10-05 16:24:54 +0000275
Eric Andersen3cf52d11999-10-12 22:26:06 +0000276 /*
277 * Open the tar file for reading.
278 */
279 if ((tarName == NULL) || !strcmp (tarName, "-")) {
Eric Andersen08b10341999-11-19 02:38:58 +0000280 tarFd = fileno(stdin);
Eric Andersen3cf52d11999-10-12 22:26:06 +0000281 } else
282 tarFd = open (tarName, O_RDONLY);
283
284 if (tarFd < 0) {
285 perror (tarName);
286 errorFlag = TRUE;
287 return;
288 }
289
290 /*
291 * Read blocks from the file until an end of file header block
292 * has been seen. (A real end of file from a read is an error.)
293 */
Eric Andersen5556c181999-11-10 19:27:58 +0000294 while (eofFlag==FALSE) {
Eric Andersen3cf52d11999-10-12 22:26:06 +0000295 /*
296 * Read the next block of data if necessary.
297 * This will be a large block if possible, which we will
298 * then process in the small tar blocks.
Eric Andersencc8ed391999-10-05 16:24:54 +0000299 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000300 if (inCc <= 0) {
301 cp = buf;
302 inCc = fullRead (tarFd, buf, blockSize);
Eric Andersencc8ed391999-10-05 16:24:54 +0000303
Eric Andersen3cf52d11999-10-12 22:26:06 +0000304 if (inCc < 0) {
305 perror (tarName);
Eric Andersencc8ed391999-10-05 16:24:54 +0000306 errorFlag = TRUE;
Eric Andersen3cf52d11999-10-12 22:26:06 +0000307 goto done;
308 }
309
310 if (inCc == 0) {
311 fprintf (stderr,
312 "Unexpected end of file from \"%s\"", tarName);
313 errorFlag = TRUE;
314 goto done;
315 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000316 }
317
Eric Andersen3cf52d11999-10-12 22:26:06 +0000318 /*
319 * If we are expecting a header block then examine it.
Eric Andersencc8ed391999-10-05 16:24:54 +0000320 */
Eric Andersen5556c181999-11-10 19:27:58 +0000321 if (inHeader==TRUE) {
Eric Andersen3cf52d11999-10-12 22:26:06 +0000322 readHeader ((const TarHeader *) cp, fileCount, fileTable);
Eric Andersencc8ed391999-10-05 16:24:54 +0000323
Eric Andersen3cf52d11999-10-12 22:26:06 +0000324 cp += TAR_BLOCK_SIZE;
325 inCc -= TAR_BLOCK_SIZE;
Eric Andersencc8ed391999-10-05 16:24:54 +0000326
Eric Andersen3cf52d11999-10-12 22:26:06 +0000327 continue;
Eric Andersencc8ed391999-10-05 16:24:54 +0000328 }
329
Eric Andersen3cf52d11999-10-12 22:26:06 +0000330 /*
331 * We are currently handling the data for a file.
332 * Process the minimum of the amount of data we have available
333 * and the amount left to be processed for the file.
Eric Andersencc8ed391999-10-05 16:24:54 +0000334 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000335 cc = inCc;
Eric Andersencc8ed391999-10-05 16:24:54 +0000336
Eric Andersen3cf52d11999-10-12 22:26:06 +0000337 if (cc > dataCc)
338 cc = dataCc;
339
340 readData (cp, cc);
341
342 /*
343 * If the amount left isn't an exact multiple of the tar block
344 * size then round it up to the next block boundary since there
345 * is padding at the end of the file.
Eric Andersencc8ed391999-10-05 16:24:54 +0000346 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000347 if (cc % TAR_BLOCK_SIZE)
348 cc += TAR_BLOCK_SIZE - (cc % TAR_BLOCK_SIZE);
349
350 cp += cc;
351 inCc -= cc;
352 }
353
354 done:
355 /*
356 * Close the tar file if needed.
357 */
358 if ((tarFd >= 0) && (close (tarFd) < 0))
359 perror (tarName);
360
361 /*
362 * Close the output file if needed.
363 * This is only done here on a previous error and so no
364 * message is required on errors.
365 */
366 if (tostdoutFlag == FALSE) {
367 if (outFd >= 0)
368 (void) close (outFd);
369 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000370}
371
372
373/*
374 * Examine the header block that was just read.
375 * This can specify the information for another file, or it can mark
376 * the end of the tar file.
377 */
378static void
Eric Andersen3cf52d11999-10-12 22:26:06 +0000379readHeader (const TarHeader * hp, int fileCount, char **fileTable)
Eric Andersencc8ed391999-10-05 16:24:54 +0000380{
Eric Andersen3cf52d11999-10-12 22:26:06 +0000381 int mode;
382 int uid;
383 int gid;
384 int checkSum;
Eric Andersen03018f71999-11-29 04:29:13 +0000385 unsigned int major;
386 unsigned int minor;
Eric Andersen3cf52d11999-10-12 22:26:06 +0000387 long size;
388 time_t mtime;
389 const char *name;
390 int cc;
391 int hardLink;
392 int softLink;
Eric Andersen96bcfd31999-11-12 01:30:18 +0000393 int devFileFlag;
Eric Andersencc8ed391999-10-05 16:24:54 +0000394
Eric Andersen3cf52d11999-10-12 22:26:06 +0000395 /*
396 * If the block is completely empty, then this is the end of the
397 * archive file. If the name is null, then just skip this header.
398 */
399 name = hp->name;
Eric Andersencc8ed391999-10-05 16:24:54 +0000400
Eric Andersen3cf52d11999-10-12 22:26:06 +0000401 if (*name == '\0') {
402 for (cc = TAR_BLOCK_SIZE; cc > 0; cc--) {
403 if (*name++)
Eric Andersencc8ed391999-10-05 16:24:54 +0000404 return;
405 }
406
Eric Andersen3cf52d11999-10-12 22:26:06 +0000407 eofFlag = TRUE;
Eric Andersencc8ed391999-10-05 16:24:54 +0000408
Eric Andersen3cf52d11999-10-12 22:26:06 +0000409 return;
410 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000411
Eric Andersen3cf52d11999-10-12 22:26:06 +0000412 /*
413 * There is another file in the archive to examine.
414 * Extract the encoded information and check it.
415 */
416 mode = getOctal (hp->mode, sizeof (hp->mode));
417 uid = getOctal (hp->uid, sizeof (hp->uid));
418 gid = getOctal (hp->gid, sizeof (hp->gid));
419 size = getOctal (hp->size, sizeof (hp->size));
420 mtime = getOctal (hp->mtime, sizeof (hp->mtime));
421 checkSum = getOctal (hp->checkSum, sizeof (hp->checkSum));
Eric Andersen96bcfd31999-11-12 01:30:18 +0000422 major = getOctal (hp->devMajor, sizeof (hp->devMajor));
423 minor = getOctal (hp->devMinor, sizeof (hp->devMinor));
Eric Andersencc8ed391999-10-05 16:24:54 +0000424
Eric Andersen3cf52d11999-10-12 22:26:06 +0000425 if ((mode < 0) || (uid < 0) || (gid < 0) || (size < 0)) {
Eric Andersen5556c181999-11-10 19:27:58 +0000426 if (badHeader==FALSE)
Eric Andersen3cf52d11999-10-12 22:26:06 +0000427 fprintf (stderr, "Bad tar header, skipping\n");
Eric Andersencc8ed391999-10-05 16:24:54 +0000428
Eric Andersen3cf52d11999-10-12 22:26:06 +0000429 badHeader = TRUE;
Eric Andersencc8ed391999-10-05 16:24:54 +0000430
Eric Andersen3cf52d11999-10-12 22:26:06 +0000431 return;
432 }
433
434 badHeader = FALSE;
435 skipFileFlag = FALSE;
Eric Andersen96bcfd31999-11-12 01:30:18 +0000436 devFileFlag = FALSE;
Eric Andersen3cf52d11999-10-12 22:26:06 +0000437
438 /*
439 * Check for the file modes.
440 */
441 hardLink = ((hp->typeFlag == TAR_TYPE_HARD_LINK) ||
Eric Andersencc8ed391999-10-05 16:24:54 +0000442 (hp->typeFlag == TAR_TYPE_HARD_LINK - '0'));
443
Eric Andersen3cf52d11999-10-12 22:26:06 +0000444 softLink = ((hp->typeFlag == TAR_TYPE_SOFT_LINK) ||
Eric Andersencc8ed391999-10-05 16:24:54 +0000445 (hp->typeFlag == TAR_TYPE_SOFT_LINK - '0'));
446
Eric Andersen3cf52d11999-10-12 22:26:06 +0000447 /*
Eric Andersen96bcfd31999-11-12 01:30:18 +0000448 * Check for a directory.
Eric Andersen3cf52d11999-10-12 22:26:06 +0000449 */
450 if (name[strlen (name) - 1] == '/')
451 mode |= S_IFDIR;
Eric Andersencc8ed391999-10-05 16:24:54 +0000452
Eric Andersen3cf52d11999-10-12 22:26:06 +0000453 /*
454 * Check for absolute paths in the file.
455 * If we find any, then warn the user and make them relative.
456 */
457 if (*name == '/') {
458 while (*name == '/')
459 name++;
Eric Andersencc8ed391999-10-05 16:24:54 +0000460
Eric Andersen5556c181999-11-10 19:27:58 +0000461 if (warnedRoot==FALSE) {
Eric Andersen3cf52d11999-10-12 22:26:06 +0000462 fprintf (stderr,
463 "Absolute path detected, removing leading slashes\n");
Eric Andersencc8ed391999-10-05 16:24:54 +0000464 }
465
Eric Andersen3cf52d11999-10-12 22:26:06 +0000466 warnedRoot = TRUE;
467 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000468
Eric Andersen3cf52d11999-10-12 22:26:06 +0000469 /*
470 * See if we want this file to be restored.
471 * If not, then set up to skip it.
472 */
Eric Andersen5556c181999-11-10 19:27:58 +0000473 if (wantFileName (name, fileCount, fileTable) == FALSE) {
Eric Andersen96bcfd31999-11-12 01:30:18 +0000474 if ( !hardLink && !softLink && (S_ISREG (mode) || S_ISCHR (mode)
475 || S_ISBLK (mode) || S_ISSOCK(mode) || S_ISFIFO(mode) ) ) {
Eric Andersen5556c181999-11-10 19:27:58 +0000476 inHeader = (size == 0)? TRUE : FALSE;
Eric Andersen3cf52d11999-10-12 22:26:06 +0000477 dataCc = size;
Eric Andersencc8ed391999-10-05 16:24:54 +0000478 }
479
Eric Andersen3cf52d11999-10-12 22:26:06 +0000480 skipFileFlag = TRUE;
Eric Andersencc8ed391999-10-05 16:24:54 +0000481
Eric Andersen3cf52d11999-10-12 22:26:06 +0000482 return;
483 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000484
Eric Andersen3cf52d11999-10-12 22:26:06 +0000485 /*
486 * This file is to be handled.
487 * If we aren't extracting then just list information about the file.
488 */
Eric Andersen5556c181999-11-10 19:27:58 +0000489 if (extractFlag==FALSE) {
490 if (verboseFlag==TRUE) {
Eric Andersen03018f71999-11-29 04:29:13 +0000491 printf ("%s %3d/%-d ", modeString (mode), uid, gid);
492 if( S_ISCHR (mode) || S_ISBLK (mode) )
493 printf ("%4d,%4d %s ", major,minor, timeString (mtime));
494 else
495 printf ("%9ld %s ", size, timeString (mtime));
496 }
497 printf ("%s", name);
Eric Andersencc8ed391999-10-05 16:24:54 +0000498
499 if (hardLink)
Eric Andersen3cf52d11999-10-12 22:26:06 +0000500 printf (" (link to \"%s\")", hp->linkName);
501 else if (softLink)
502 printf (" (symlink to \"%s\")", hp->linkName);
Eric Andersen96bcfd31999-11-12 01:30:18 +0000503 else if (S_ISREG (mode) || S_ISCHR (mode) || S_ISBLK (mode) ||
504 S_ISSOCK(mode) || S_ISFIFO(mode) ) {
Eric Andersen5556c181999-11-10 19:27:58 +0000505 inHeader = (size == 0)? TRUE : FALSE;
Eric Andersen3cf52d11999-10-12 22:26:06 +0000506 dataCc = size;
Eric Andersencc8ed391999-10-05 16:24:54 +0000507 }
508
Eric Andersen3cf52d11999-10-12 22:26:06 +0000509 printf ("\n");
510
511 return;
512 }
513
514 /*
515 * We really want to extract the file.
516 */
Eric Andersen5556c181999-11-10 19:27:58 +0000517 if (verboseFlag==TRUE)
Eric Andersen3cf52d11999-10-12 22:26:06 +0000518 printf ("x %s\n", name);
519
520 if (hardLink) {
521 if (link (hp->linkName, name) < 0)
522 perror (name);
Eric Andersen03018f71999-11-29 04:29:13 +0000523 chmod(name, mode);
524 chown(name, uid, gid);
Eric Andersen3cf52d11999-10-12 22:26:06 +0000525 return;
526 }
527
528 if (softLink) {
Eric Andersencc8ed391999-10-05 16:24:54 +0000529#ifdef S_ISLNK
Eric Andersen3cf52d11999-10-12 22:26:06 +0000530 if (symlink (hp->linkName, name) < 0)
531 perror (name);
Eric Andersen03018f71999-11-29 04:29:13 +0000532 chmod(name, mode);
533 chown(name, uid, gid);
Eric Andersencc8ed391999-10-05 16:24:54 +0000534#else
Eric Andersen3cf52d11999-10-12 22:26:06 +0000535 fprintf (stderr, "Cannot create symbolic links\n");
Eric Andersencc8ed391999-10-05 16:24:54 +0000536#endif
Eric Andersen3cf52d11999-10-12 22:26:06 +0000537 return;
538 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000539
Eric Andersen03018f71999-11-29 04:29:13 +0000540 /* Set the umask for this process so it doesn't
541 * screw things up. */
542 umask(0);
543
Eric Andersen3cf52d11999-10-12 22:26:06 +0000544 /*
545 * If the file is a directory, then just create the path.
546 */
547 if (S_ISDIR (mode)) {
548 createPath (name, mode);
Eric Andersen03018f71999-11-29 04:29:13 +0000549 chmod(name, mode);
550 chown(name, uid, gid);
Eric Andersencc8ed391999-10-05 16:24:54 +0000551
Eric Andersen3cf52d11999-10-12 22:26:06 +0000552 return;
553 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000554
Eric Andersen3cf52d11999-10-12 22:26:06 +0000555 /*
556 * There is a file to write.
Eric Andersen03018f71999-11-29 04:29:13 +0000557 * First create the path to it if necessary with default permissions.
Eric Andersen3cf52d11999-10-12 22:26:06 +0000558 */
559 createPath (name, 0777);
Eric Andersencc8ed391999-10-05 16:24:54 +0000560
Eric Andersen5556c181999-11-10 19:27:58 +0000561 inHeader = (size == 0)? TRUE : FALSE;
Eric Andersen3cf52d11999-10-12 22:26:06 +0000562 dataCc = size;
Eric Andersencc8ed391999-10-05 16:24:54 +0000563
Eric Andersen3cf52d11999-10-12 22:26:06 +0000564 /*
565 * Start the output file.
566 */
567 if (tostdoutFlag == TRUE)
Eric Andersen08b10341999-11-19 02:38:58 +0000568 outFd = fileno(stdout);
Eric Andersen96bcfd31999-11-12 01:30:18 +0000569 else {
570 if ( S_ISCHR(mode) || S_ISBLK(mode) || S_ISSOCK(mode) ) {
571 devFileFlag = TRUE;
572 outFd = mknod (name, mode, makedev(major, minor) );
573 }
574 else if (S_ISFIFO(mode) ) {
Eric Andersenb6a44b81999-11-13 04:47:09 +0000575 devFileFlag = TRUE;
Eric Andersen96bcfd31999-11-12 01:30:18 +0000576 outFd = mkfifo(name, mode);
577 } else {
578 outFd = open (name, O_WRONLY | O_CREAT | O_TRUNC, mode);
579 }
580 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000581
Eric Andersen3cf52d11999-10-12 22:26:06 +0000582 if (outFd < 0) {
583 perror (name);
584 skipFileFlag = TRUE;
585 return;
586 }
Eric Andersen03018f71999-11-29 04:29:13 +0000587 if (tostdoutFlag == FALSE) {
588 fchmod(outFd, mode);
589 fchown(outFd, uid, gid);
590 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000591
Eric Andersen3cf52d11999-10-12 22:26:06 +0000592 /*
593 * If the file is empty, then that's all we need to do.
594 */
Eric Andersen96bcfd31999-11-12 01:30:18 +0000595 if (size == 0 && (tostdoutFlag == FALSE) && (devFileFlag == FALSE)) {
Eric Andersen3cf52d11999-10-12 22:26:06 +0000596 (void) close (outFd);
597 outFd = -1;
598 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000599}
600
601
602/*
603 * Handle a data block of some specified size that was read.
604 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000605static void readData (const char *cp, int count)
Eric Andersencc8ed391999-10-05 16:24:54 +0000606{
Eric Andersen3cf52d11999-10-12 22:26:06 +0000607 /*
608 * Reduce the amount of data left in this file.
609 * If there is no more data left, then we need to read
610 * the header again.
611 */
612 dataCc -= count;
Eric Andersencc8ed391999-10-05 16:24:54 +0000613
Eric Andersen3cf52d11999-10-12 22:26:06 +0000614 if (dataCc <= 0)
615 inHeader = TRUE;
Eric Andersencc8ed391999-10-05 16:24:54 +0000616
Eric Andersen3cf52d11999-10-12 22:26:06 +0000617 /*
618 * If we aren't extracting files or this file is being
619 * skipped then do nothing more.
620 */
Eric Andersen5556c181999-11-10 19:27:58 +0000621 if (extractFlag==FALSE || skipFileFlag==TRUE)
Eric Andersen3cf52d11999-10-12 22:26:06 +0000622 return;
Eric Andersencc8ed391999-10-05 16:24:54 +0000623
Eric Andersen3cf52d11999-10-12 22:26:06 +0000624 /*
625 * Write the data to the output file.
626 */
627 if (fullWrite (outFd, cp, count) < 0) {
628 perror (outName);
629 if (tostdoutFlag == FALSE) {
630 (void) close (outFd);
631 outFd = -1;
Eric Andersencc8ed391999-10-05 16:24:54 +0000632 }
Eric Andersen3cf52d11999-10-12 22:26:06 +0000633 skipFileFlag = TRUE;
634 return;
635 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000636
Eric Andersen3cf52d11999-10-12 22:26:06 +0000637 /*
638 * If the write failed, close the file and disable further
639 * writes to this file.
640 */
641 if (dataCc <= 0 && tostdoutFlag == FALSE) {
642 if (close (outFd))
643 perror (outName);
Eric Andersencc8ed391999-10-05 16:24:54 +0000644
Eric Andersen3cf52d11999-10-12 22:26:06 +0000645 outFd = -1;
646 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000647}
648
649
650/*
651 * Write a tar file containing the specified files.
652 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000653static void writeTarFile (int fileCount, char **fileTable)
Eric Andersencc8ed391999-10-05 16:24:54 +0000654{
Eric Andersen3cf52d11999-10-12 22:26:06 +0000655 struct stat statbuf;
Eric Andersencc8ed391999-10-05 16:24:54 +0000656
Eric Andersen3cf52d11999-10-12 22:26:06 +0000657 /*
658 * Make sure there is at least one file specified.
659 */
660 if (fileCount <= 0) {
661 fprintf (stderr, "No files specified to be saved\n");
662 errorFlag = TRUE;
663 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000664
Eric Andersen3cf52d11999-10-12 22:26:06 +0000665 /*
666 * Create the tar file for writing.
667 */
668 if ((tarName == NULL) || !strcmp (tarName, "-")) {
669 tostdoutFlag = TRUE;
Eric Andersen08b10341999-11-19 02:38:58 +0000670 tarFd = fileno(stdout);
Eric Andersen3cf52d11999-10-12 22:26:06 +0000671 } else
672 tarFd = open (tarName, O_WRONLY | O_CREAT | O_TRUNC, 0666);
Eric Andersencc8ed391999-10-05 16:24:54 +0000673
Eric Andersen3cf52d11999-10-12 22:26:06 +0000674 if (tarFd < 0) {
675 perror (tarName);
676 errorFlag = TRUE;
677 return;
678 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000679
Eric Andersen3cf52d11999-10-12 22:26:06 +0000680 /*
681 * Get the device and inode of the tar file for checking later.
682 */
683 if (fstat (tarFd, &statbuf) < 0) {
684 perror (tarName);
685 errorFlag = TRUE;
686 goto done;
687 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000688
Eric Andersen3cf52d11999-10-12 22:26:06 +0000689 tarDev = statbuf.st_dev;
690 tarInode = statbuf.st_ino;
Eric Andersen03018f71999-11-29 04:29:13 +0000691
Eric Andersen3cf52d11999-10-12 22:26:06 +0000692 /*
693 * Append each file name into the archive file.
694 * Follow symbolic links for these top level file names.
695 */
Eric Andersen5556c181999-11-10 19:27:58 +0000696 while (errorFlag==FALSE && (fileCount-- > 0)) {
Eric Andersen3cf52d11999-10-12 22:26:06 +0000697 saveFile (*fileTable++, FALSE);
698 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000699
Eric Andersen3cf52d11999-10-12 22:26:06 +0000700 /*
701 * Now write an empty block of zeroes to end the archive.
702 */
703 writeTarBlock ("", 1);
Eric Andersencc8ed391999-10-05 16:24:54 +0000704
705
Eric Andersen3cf52d11999-10-12 22:26:06 +0000706 done:
707 /*
708 * Close the tar file and check for errors if it was opened.
709 */
710 if ((tostdoutFlag == FALSE) && (tarFd >= 0) && (close (tarFd) < 0))
711 perror (tarName);
Eric Andersencc8ed391999-10-05 16:24:54 +0000712}
713
714
715/*
716 * Save one file into the tar file.
717 * If the file is a directory, then this will recursively save all of
718 * the files and directories within the directory. The seeLinks
719 * flag indicates whether or not we want to see symbolic links as
720 * they really are, instead of blindly following them.
721 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000722static void saveFile (const char *fileName, int seeLinks)
Eric Andersencc8ed391999-10-05 16:24:54 +0000723{
Eric Andersen3cf52d11999-10-12 22:26:06 +0000724 int status;
725 int mode;
726 struct stat statbuf;
Eric Andersencc8ed391999-10-05 16:24:54 +0000727
Eric Andersen5556c181999-11-10 19:27:58 +0000728 if (verboseFlag==TRUE)
Eric Andersen3cf52d11999-10-12 22:26:06 +0000729 printf ("a %s\n", fileName);
Eric Andersencc8ed391999-10-05 16:24:54 +0000730
Eric Andersen3cf52d11999-10-12 22:26:06 +0000731 /*
732 * Check that the file name will fit in the header.
733 */
734 if (strlen (fileName) >= TAR_NAME_SIZE) {
735 fprintf (stderr, "%s: File name is too long\n", fileName);
Eric Andersencc8ed391999-10-05 16:24:54 +0000736
Eric Andersen3cf52d11999-10-12 22:26:06 +0000737 return;
738 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000739
Eric Andersen3cf52d11999-10-12 22:26:06 +0000740 /*
741 * Find out about the file.
742 */
Eric Andersencc8ed391999-10-05 16:24:54 +0000743#ifdef S_ISLNK
Eric Andersen5556c181999-11-10 19:27:58 +0000744 if (seeLinks==TRUE)
Eric Andersen3cf52d11999-10-12 22:26:06 +0000745 status = lstat (fileName, &statbuf);
746 else
Eric Andersencc8ed391999-10-05 16:24:54 +0000747#endif
Eric Andersen3cf52d11999-10-12 22:26:06 +0000748 status = stat (fileName, &statbuf);
Eric Andersencc8ed391999-10-05 16:24:54 +0000749
Eric Andersen3cf52d11999-10-12 22:26:06 +0000750 if (status < 0) {
751 perror (fileName);
Eric Andersencc8ed391999-10-05 16:24:54 +0000752
Eric Andersen3cf52d11999-10-12 22:26:06 +0000753 return;
754 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000755
Eric Andersen3cf52d11999-10-12 22:26:06 +0000756 /*
757 * Make sure we aren't trying to save our file into itself.
758 */
759 if ((statbuf.st_dev == tarDev) && (statbuf.st_ino == tarInode)) {
760 fprintf (stderr, "Skipping saving of archive file itself\n");
Eric Andersencc8ed391999-10-05 16:24:54 +0000761
Eric Andersen3cf52d11999-10-12 22:26:06 +0000762 return;
763 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000764
Eric Andersen3cf52d11999-10-12 22:26:06 +0000765 /*
766 * Check the type of file.
767 */
768 mode = statbuf.st_mode;
Eric Andersencc8ed391999-10-05 16:24:54 +0000769
Eric Andersen3cf52d11999-10-12 22:26:06 +0000770 if (S_ISDIR (mode)) {
771 saveDirectory (fileName, &statbuf);
Eric Andersencc8ed391999-10-05 16:24:54 +0000772
Eric Andersen3cf52d11999-10-12 22:26:06 +0000773 return;
774 }
Eric Andersen3cf52d11999-10-12 22:26:06 +0000775 if (S_ISREG (mode)) {
776 saveRegularFile (fileName, &statbuf);
Eric Andersencc8ed391999-10-05 16:24:54 +0000777
Eric Andersen3cf52d11999-10-12 22:26:06 +0000778 return;
779 }
Eric Andersen96bcfd31999-11-12 01:30:18 +0000780
781 /* Some day add support for tarring these up... but not today. :) */
782// if (S_ISLNK(mode) || S_ISFIFO(mode) || S_ISBLK(mode) || S_ISCHR (mode) ) {
783// fprintf (stderr, "%s: This version of tar can't store this type of file\n", fileName);
784// }
Eric Andersencc8ed391999-10-05 16:24:54 +0000785
Eric Andersen3cf52d11999-10-12 22:26:06 +0000786 /*
787 * The file is a strange type of file, ignore it.
788 */
789 fprintf (stderr, "%s: not a directory or regular file\n", fileName);
Eric Andersencc8ed391999-10-05 16:24:54 +0000790}
791
792
793/*
794 * Save a regular file to the tar file.
795 */
796static void
Eric Andersen3cf52d11999-10-12 22:26:06 +0000797saveRegularFile (const char *fileName, const struct stat *statbuf)
Eric Andersencc8ed391999-10-05 16:24:54 +0000798{
Eric Andersen3cf52d11999-10-12 22:26:06 +0000799 int sawEof;
800 int fileFd;
801 int cc;
802 int dataCount;
803 long fullDataCount;
804 char data[TAR_BLOCK_SIZE * 16];
Eric Andersencc8ed391999-10-05 16:24:54 +0000805
Eric Andersen3cf52d11999-10-12 22:26:06 +0000806 /*
807 * Open the file for reading.
808 */
809 fileFd = open (fileName, O_RDONLY);
810
811 if (fileFd < 0) {
812 perror (fileName);
813
814 return;
815 }
816
817 /*
818 * Write out the header for the file.
819 */
820 writeHeader (fileName, statbuf);
821
822 /*
823 * Write the data blocks of the file.
824 * We must be careful to write the amount of data that the stat
825 * buffer indicated, even if the file has changed size. Otherwise
826 * the tar file will be incorrect.
827 */
828 fullDataCount = statbuf->st_size;
829 sawEof = FALSE;
830
831 while (fullDataCount > 0) {
832 /*
833 * Get the amount to write this iteration which is
834 * the minumum of the amount left to write and the
835 * buffer size.
Eric Andersencc8ed391999-10-05 16:24:54 +0000836 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000837 dataCount = sizeof (data);
Eric Andersencc8ed391999-10-05 16:24:54 +0000838
Eric Andersen3cf52d11999-10-12 22:26:06 +0000839 if (dataCount > fullDataCount)
840 dataCount = (int) fullDataCount;
841
842 /*
843 * Read the data from the file if we haven't seen the
844 * end of file yet.
845 */
846 cc = 0;
847
Eric Andersen5556c181999-11-10 19:27:58 +0000848 if (sawEof==FALSE) {
Eric Andersen3cf52d11999-10-12 22:26:06 +0000849 cc = fullRead (fileFd, data, dataCount);
850
851 if (cc < 0) {
852 perror (fileName);
853
854 (void) close (fileFd);
855 errorFlag = TRUE;
Eric Andersencc8ed391999-10-05 16:24:54 +0000856
857 return;
Eric Andersen3cf52d11999-10-12 22:26:06 +0000858 }
859
860 /*
861 * If the file ended too soon, complain and set
862 * a flag so we will zero fill the rest of it.
863 */
864 if (cc < dataCount) {
865 fprintf (stderr,
866 "%s: Short read - zero filling", fileName);
867
868 sawEof = TRUE;
869 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000870 }
871
Eric Andersen3cf52d11999-10-12 22:26:06 +0000872 /*
873 * Zero fill the rest of the data if necessary.
Eric Andersencc8ed391999-10-05 16:24:54 +0000874 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000875 if (cc < dataCount)
876 memset (data + cc, 0, dataCount - cc);
Eric Andersencc8ed391999-10-05 16:24:54 +0000877
Eric Andersen3cf52d11999-10-12 22:26:06 +0000878 /*
879 * Write the buffer to the TAR file.
Eric Andersencc8ed391999-10-05 16:24:54 +0000880 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000881 writeTarBlock (data, dataCount);
Eric Andersencc8ed391999-10-05 16:24:54 +0000882
Eric Andersen3cf52d11999-10-12 22:26:06 +0000883 fullDataCount -= dataCount;
884 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000885
Eric Andersen3cf52d11999-10-12 22:26:06 +0000886 /*
887 * Close the file.
888 */
889 if ((tostdoutFlag == FALSE) && close (fileFd) < 0)
890 fprintf (stderr, "%s: close: %s\n", fileName, strerror (errno));
Eric Andersencc8ed391999-10-05 16:24:54 +0000891}
892
893
894/*
895 * Save a directory and all of its files to the tar file.
896 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000897static void saveDirectory (const char *dirName, const struct stat *statbuf)
Eric Andersencc8ed391999-10-05 16:24:54 +0000898{
Eric Andersen3cf52d11999-10-12 22:26:06 +0000899 DIR *dir;
900 struct dirent *entry;
901 int needSlash;
Eric Andersen1b61f411999-10-13 18:56:42 +0000902 char fullName[NAME_MAX];
Eric Andersencc8ed391999-10-05 16:24:54 +0000903
Eric Andersen3cf52d11999-10-12 22:26:06 +0000904 /*
905 * Construct the directory name as used in the tar file by appending
906 * a slash character to it.
907 */
908 strcpy (fullName, dirName);
909 strcat (fullName, "/");
Eric Andersencc8ed391999-10-05 16:24:54 +0000910
Eric Andersen3cf52d11999-10-12 22:26:06 +0000911 /*
912 * Write out the header for the directory entry.
913 */
914 writeHeader (fullName, statbuf);
Eric Andersencc8ed391999-10-05 16:24:54 +0000915
Eric Andersen3cf52d11999-10-12 22:26:06 +0000916 /*
917 * Open the directory.
918 */
919 dir = opendir (dirName);
Eric Andersencc8ed391999-10-05 16:24:54 +0000920
Eric Andersen3cf52d11999-10-12 22:26:06 +0000921 if (dir == NULL) {
922 fprintf (stderr, "Cannot read directory \"%s\": %s\n",
923 dirName, strerror (errno));
Eric Andersencc8ed391999-10-05 16:24:54 +0000924
Eric Andersen3cf52d11999-10-12 22:26:06 +0000925 return;
926 }
927
928 /*
929 * See if a slash is needed.
930 */
931 needSlash = (*dirName && (dirName[strlen (dirName) - 1] != '/'));
932
933 /*
934 * Read all of the directory entries and check them,
935 * except for the current and parent directory entries.
936 */
Eric Andersen5556c181999-11-10 19:27:58 +0000937 while (errorFlag==FALSE && ((entry = readdir (dir)) != NULL)) {
Eric Andersen3cf52d11999-10-12 22:26:06 +0000938 if ((strcmp (entry->d_name, ".") == 0) ||
939 (strcmp (entry->d_name, "..") == 0)) {
940 continue;
Eric Andersencc8ed391999-10-05 16:24:54 +0000941 }
942
Eric Andersen3cf52d11999-10-12 22:26:06 +0000943 /*
944 * Build the full path name to the file.
Eric Andersencc8ed391999-10-05 16:24:54 +0000945 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000946 strcpy (fullName, dirName);
Eric Andersencc8ed391999-10-05 16:24:54 +0000947
Eric Andersen3cf52d11999-10-12 22:26:06 +0000948 if (needSlash)
949 strcat (fullName, "/");
950
951 strcat (fullName, entry->d_name);
952
953 /*
954 * Write this file to the tar file, noticing whether or not
955 * the file is a symbolic link.
Eric Andersencc8ed391999-10-05 16:24:54 +0000956 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000957 saveFile (fullName, TRUE);
958 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000959
Eric Andersen3cf52d11999-10-12 22:26:06 +0000960 /*
961 * All done, close the directory.
962 */
963 closedir (dir);
Eric Andersencc8ed391999-10-05 16:24:54 +0000964}
965
966
967/*
968 * Write a tar header for the specified file name and status.
969 * It is assumed that the file name fits.
970 */
Eric Andersen3cf52d11999-10-12 22:26:06 +0000971static void writeHeader (const char *fileName, const struct stat *statbuf)
Eric Andersencc8ed391999-10-05 16:24:54 +0000972{
Eric Andersen3cf52d11999-10-12 22:26:06 +0000973 long checkSum;
974 const unsigned char *cp;
975 int len;
976 TarHeader header;
Eric Andersencc8ed391999-10-05 16:24:54 +0000977
Eric Andersen3cf52d11999-10-12 22:26:06 +0000978 /*
979 * Zero the header block in preparation for filling it in.
980 */
981 memset ((char *) &header, 0, sizeof (header));
Eric Andersencc8ed391999-10-05 16:24:54 +0000982
Eric Andersen3cf52d11999-10-12 22:26:06 +0000983 /*
984 * Fill in the header.
985 */
986 strcpy (header.name, fileName);
Eric Andersencc8ed391999-10-05 16:24:54 +0000987
Eric Andersen3cf52d11999-10-12 22:26:06 +0000988 strncpy (header.magic, TAR_MAGIC, sizeof (header.magic));
989 strncpy (header.version, TAR_VERSION, sizeof (header.version));
Eric Andersencc8ed391999-10-05 16:24:54 +0000990
Eric Andersen3cf52d11999-10-12 22:26:06 +0000991 putOctal (header.mode, sizeof (header.mode), statbuf->st_mode & 0777);
992 putOctal (header.uid, sizeof (header.uid), statbuf->st_uid);
993 putOctal (header.gid, sizeof (header.gid), statbuf->st_gid);
994 putOctal (header.size, sizeof (header.size), statbuf->st_size);
995 putOctal (header.mtime, sizeof (header.mtime), statbuf->st_mtime);
Eric Andersencc8ed391999-10-05 16:24:54 +0000996
Eric Andersen3cf52d11999-10-12 22:26:06 +0000997 header.typeFlag = TAR_TYPE_REGULAR;
Eric Andersencc8ed391999-10-05 16:24:54 +0000998
Eric Andersen3cf52d11999-10-12 22:26:06 +0000999 /*
1000 * Calculate and store the checksum.
1001 * This is the sum of all of the bytes of the header,
1002 * with the checksum field itself treated as blanks.
1003 */
1004 memset (header.checkSum, ' ', sizeof (header.checkSum));
Eric Andersencc8ed391999-10-05 16:24:54 +00001005
Eric Andersen3cf52d11999-10-12 22:26:06 +00001006 cp = (const unsigned char *) &header;
1007 len = sizeof (header);
1008 checkSum = 0;
Eric Andersencc8ed391999-10-05 16:24:54 +00001009
Eric Andersen3cf52d11999-10-12 22:26:06 +00001010 while (len-- > 0)
1011 checkSum += *cp++;
Eric Andersencc8ed391999-10-05 16:24:54 +00001012
Eric Andersen3cf52d11999-10-12 22:26:06 +00001013 putOctal (header.checkSum, sizeof (header.checkSum), checkSum);
Eric Andersencc8ed391999-10-05 16:24:54 +00001014
Eric Andersen3cf52d11999-10-12 22:26:06 +00001015 /*
1016 * Write the tar header.
1017 */
1018 writeTarBlock ((const char *) &header, sizeof (header));
Eric Andersencc8ed391999-10-05 16:24:54 +00001019}
1020
1021
1022/*
1023 * Write data to one or more blocks of the tar file.
1024 * The data is always padded out to a multiple of TAR_BLOCK_SIZE.
1025 * The errorFlag static variable is set on an error.
1026 */
Eric Andersen3cf52d11999-10-12 22:26:06 +00001027static void writeTarBlock (const char *buf, int len)
Eric Andersencc8ed391999-10-05 16:24:54 +00001028{
Eric Andersen3cf52d11999-10-12 22:26:06 +00001029 int partialLength;
1030 int completeLength;
1031 char fullBlock[TAR_BLOCK_SIZE];
Eric Andersencc8ed391999-10-05 16:24:54 +00001032
Eric Andersen3cf52d11999-10-12 22:26:06 +00001033 /*
1034 * If we had a write error before, then do nothing more.
1035 */
Eric Andersen5556c181999-11-10 19:27:58 +00001036 if (errorFlag==TRUE)
Eric Andersen3cf52d11999-10-12 22:26:06 +00001037 return;
Eric Andersencc8ed391999-10-05 16:24:54 +00001038
Eric Andersen3cf52d11999-10-12 22:26:06 +00001039 /*
1040 * Get the amount of complete and partial blocks.
1041 */
1042 partialLength = len % TAR_BLOCK_SIZE;
1043 completeLength = len - partialLength;
Eric Andersencc8ed391999-10-05 16:24:54 +00001044
Eric Andersen3cf52d11999-10-12 22:26:06 +00001045 /*
1046 * Write all of the complete blocks.
1047 */
1048 if ((completeLength > 0) && !fullWrite (tarFd, buf, completeLength)) {
1049 perror (tarName);
Eric Andersencc8ed391999-10-05 16:24:54 +00001050
Eric Andersen3cf52d11999-10-12 22:26:06 +00001051 errorFlag = TRUE;
Eric Andersencc8ed391999-10-05 16:24:54 +00001052
Eric Andersen3cf52d11999-10-12 22:26:06 +00001053 return;
1054 }
Eric Andersencc8ed391999-10-05 16:24:54 +00001055
Eric Andersen3cf52d11999-10-12 22:26:06 +00001056 /*
1057 * If there are no partial blocks left, we are done.
1058 */
1059 if (partialLength == 0)
1060 return;
Eric Andersencc8ed391999-10-05 16:24:54 +00001061
Eric Andersen3cf52d11999-10-12 22:26:06 +00001062 /*
1063 * Copy the partial data into a complete block, and pad the rest
1064 * of it with zeroes.
1065 */
1066 memcpy (fullBlock, buf + completeLength, partialLength);
1067 memset (fullBlock + partialLength, 0, TAR_BLOCK_SIZE - partialLength);
Eric Andersencc8ed391999-10-05 16:24:54 +00001068
Eric Andersen3cf52d11999-10-12 22:26:06 +00001069 /*
1070 * Write the last complete block.
1071 */
1072 if (!fullWrite (tarFd, fullBlock, TAR_BLOCK_SIZE)) {
1073 perror (tarName);
Eric Andersencc8ed391999-10-05 16:24:54 +00001074
Eric Andersen3cf52d11999-10-12 22:26:06 +00001075 errorFlag = TRUE;
1076 }
Eric Andersencc8ed391999-10-05 16:24:54 +00001077}
1078
1079
1080/*
Eric Andersencc8ed391999-10-05 16:24:54 +00001081 * Read an octal value in a field of the specified width, with optional
1082 * spaces on both sides of the number and with an optional null character
1083 * at the end. Returns -1 on an illegal format.
1084 */
Eric Andersen3cf52d11999-10-12 22:26:06 +00001085static long getOctal (const char *cp, int len)
Eric Andersencc8ed391999-10-05 16:24:54 +00001086{
Eric Andersen3cf52d11999-10-12 22:26:06 +00001087 long val;
Eric Andersencc8ed391999-10-05 16:24:54 +00001088
Eric Andersen3cf52d11999-10-12 22:26:06 +00001089 while ((len > 0) && (*cp == ' ')) {
1090 cp++;
1091 len--;
1092 }
Eric Andersencc8ed391999-10-05 16:24:54 +00001093
Eric Andersen3cf52d11999-10-12 22:26:06 +00001094 if ((len == 0) || !isOctal (*cp))
1095 return -1;
Eric Andersencc8ed391999-10-05 16:24:54 +00001096
Eric Andersen3cf52d11999-10-12 22:26:06 +00001097 val = 0;
Eric Andersencc8ed391999-10-05 16:24:54 +00001098
Eric Andersen3cf52d11999-10-12 22:26:06 +00001099 while ((len > 0) && isOctal (*cp)) {
1100 val = val * 8 + *cp++ - '0';
1101 len--;
1102 }
Eric Andersencc8ed391999-10-05 16:24:54 +00001103
Eric Andersen3cf52d11999-10-12 22:26:06 +00001104 while ((len > 0) && (*cp == ' ')) {
1105 cp++;
1106 len--;
1107 }
Eric Andersencc8ed391999-10-05 16:24:54 +00001108
Eric Andersen3cf52d11999-10-12 22:26:06 +00001109 if ((len > 0) && *cp)
1110 return -1;
Eric Andersencc8ed391999-10-05 16:24:54 +00001111
Eric Andersen3cf52d11999-10-12 22:26:06 +00001112 return val;
Eric Andersencc8ed391999-10-05 16:24:54 +00001113}
1114
1115
1116/*
1117 * Put an octal string into the specified buffer.
1118 * The number is zero and space padded and possibly null padded.
1119 * Returns TRUE if successful.
1120 */
Eric Andersen3cf52d11999-10-12 22:26:06 +00001121static int putOctal (char *cp, int len, long value)
Eric Andersencc8ed391999-10-05 16:24:54 +00001122{
Eric Andersen3cf52d11999-10-12 22:26:06 +00001123 int tempLength;
1124 char *tempString;
1125 char tempBuffer[32];
Eric Andersencc8ed391999-10-05 16:24:54 +00001126
Eric Andersen3cf52d11999-10-12 22:26:06 +00001127 /*
1128 * Create a string of the specified length with an initial space,
1129 * leading zeroes and the octal number, and a trailing null.
1130 */
1131 tempString = tempBuffer;
Eric Andersencc8ed391999-10-05 16:24:54 +00001132
Eric Andersen3cf52d11999-10-12 22:26:06 +00001133 sprintf (tempString, " %0*lo", len - 2, value);
Eric Andersencc8ed391999-10-05 16:24:54 +00001134
Eric Andersen3cf52d11999-10-12 22:26:06 +00001135 tempLength = strlen (tempString) + 1;
Eric Andersencc8ed391999-10-05 16:24:54 +00001136
Eric Andersen3cf52d11999-10-12 22:26:06 +00001137 /*
1138 * If the string is too large, suppress the leading space.
1139 */
1140 if (tempLength > len) {
1141 tempLength--;
1142 tempString++;
1143 }
Eric Andersencc8ed391999-10-05 16:24:54 +00001144
Eric Andersen3cf52d11999-10-12 22:26:06 +00001145 /*
1146 * If the string is still too large, suppress the trailing null.
1147 */
1148 if (tempLength > len)
1149 tempLength--;
Eric Andersencc8ed391999-10-05 16:24:54 +00001150
Eric Andersen3cf52d11999-10-12 22:26:06 +00001151 /*
1152 * If the string is still too large, fail.
1153 */
1154 if (tempLength > len)
1155 return FALSE;
Eric Andersencc8ed391999-10-05 16:24:54 +00001156
Eric Andersen3cf52d11999-10-12 22:26:06 +00001157 /*
1158 * Copy the string to the field.
1159 */
1160 memcpy (cp, tempString, len);
Eric Andersencc8ed391999-10-05 16:24:54 +00001161
Eric Andersen3cf52d11999-10-12 22:26:06 +00001162 return TRUE;
Eric Andersencc8ed391999-10-05 16:24:54 +00001163}
1164
1165
1166/*
1167 * See if the specified file name belongs to one of the specified list
1168 * of path prefixes. An empty list implies that all files are wanted.
1169 * Returns TRUE if the file is selected.
1170 */
Eric Andersenf811e071999-10-09 00:25:00 +00001171static int
Eric Andersen3cf52d11999-10-12 22:26:06 +00001172wantFileName (const char *fileName, int fileCount, char **fileTable)
Eric Andersencc8ed391999-10-05 16:24:54 +00001173{
Eric Andersen3cf52d11999-10-12 22:26:06 +00001174 const char *pathName;
1175 int fileLength;
1176 int pathLength;
Eric Andersencc8ed391999-10-05 16:24:54 +00001177
Eric Andersen3cf52d11999-10-12 22:26:06 +00001178 /*
1179 * If there are no files in the list, then the file is wanted.
1180 */
1181 if (fileCount == 0)
1182 return TRUE;
Eric Andersencc8ed391999-10-05 16:24:54 +00001183
Eric Andersen3cf52d11999-10-12 22:26:06 +00001184 fileLength = strlen (fileName);
Eric Andersencc8ed391999-10-05 16:24:54 +00001185
Eric Andersen3cf52d11999-10-12 22:26:06 +00001186 /*
1187 * Check each of the test paths.
1188 */
1189 while (fileCount-- > 0) {
1190 pathName = *fileTable++;
Eric Andersencc8ed391999-10-05 16:24:54 +00001191
Eric Andersen3cf52d11999-10-12 22:26:06 +00001192 pathLength = strlen (pathName);
Eric Andersencc8ed391999-10-05 16:24:54 +00001193
Eric Andersen3cf52d11999-10-12 22:26:06 +00001194 if (fileLength < pathLength)
1195 continue;
Eric Andersencc8ed391999-10-05 16:24:54 +00001196
Eric Andersen3cf52d11999-10-12 22:26:06 +00001197 if (memcmp (fileName, pathName, pathLength) != 0)
1198 continue;
Eric Andersencc8ed391999-10-05 16:24:54 +00001199
Eric Andersen3cf52d11999-10-12 22:26:06 +00001200 if ((fileLength == pathLength) || (fileName[pathLength] == '/')) {
1201 return TRUE;
Eric Andersencc8ed391999-10-05 16:24:54 +00001202 }
Eric Andersen3cf52d11999-10-12 22:26:06 +00001203 }
Eric Andersencc8ed391999-10-05 16:24:54 +00001204
Eric Andersen3cf52d11999-10-12 22:26:06 +00001205 return FALSE;
Eric Andersencc8ed391999-10-05 16:24:54 +00001206}
1207
1208
1209
Eric Andersencc8ed391999-10-05 16:24:54 +00001210/* END CODE */