1 /*
2  * Copyright (C) 2009 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #define LOG_TAG "file_backup_helper"
18 
19 #include <androidfw/BackupHelpers.h>
20 
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <sys/stat.h>
26 #include <sys/types.h>
27 #include <sys/time.h>  // for utimes
28 #include <sys/uio.h>
29 #include <unistd.h>
30 #include <utime.h>
31 #include <zlib.h>
32 
33 #include <log/log.h>
34 #include <utils/ByteOrder.h>
35 #include <utils/KeyedVector.h>
36 #include <utils/String8.h>
37 
38 namespace android {
39 
40 #define MAGIC0 0x70616e53 // Snap
41 #define MAGIC1 0x656c6946 // File
42 
43 /*
44  * File entity data format (v1):
45  *
46  *   - 4-byte version number of the metadata, little endian (0x00000001 for v1)
47  *   - 12 bytes of metadata
48  *   - the file data itself
49  *
50  * i.e. a 16-byte metadata header followed by the raw file data.  If the
51  * restore code does not recognize the metadata version, it can still
52  * interpret the file data itself correctly.
53  *
54  * file_metadata_v1:
55  *
56  *   - 4 byte version number === 0x00000001 (little endian)
57  *   - 4-byte access mode (little-endian)
58  *   - undefined (8 bytes)
59  */
60 
61 struct file_metadata_v1 {
62     int version;
63     int mode;
64     int undefined_1;
65     int undefined_2;
66 };
67 
68 const static int CURRENT_METADATA_VERSION = 1;
69 
70 static const bool kIsDebug = false;
71 #if TEST_BACKUP_HELPERS
72 #define LOGP(f, x...) if (kIsDebug) printf(f "\n", x)
73 #else
74 #define LOGP(x...) if (kIsDebug) ALOGD(x)
75 #endif
76 
77 const static int ROUND_UP[4] = { 0, 3, 2, 1 };
78 
79 static inline int
round_up(int n)80 round_up(int n)
81 {
82     return n + ROUND_UP[n % 4];
83 }
84 
85 static int
read_snapshot_file(int fd,KeyedVector<String8,FileState> * snapshot)86 read_snapshot_file(int fd, KeyedVector<String8,FileState>* snapshot)
87 {
88     int bytesRead = 0;
89     int amt;
90     SnapshotHeader header;
91 
92     amt = read(fd, &header, sizeof(header));
93     if (amt != sizeof(header)) {
94         return errno;
95     }
96     bytesRead += amt;
97 
98     if (header.magic0 != MAGIC0 || header.magic1 != MAGIC1) {
99         ALOGW("read_snapshot_file header.magic0=0x%08x magic1=0x%08x", header.magic0, header.magic1);
100         return 1;
101     }
102 
103     for (int i=0; i<header.fileCount; i++) {
104         FileState file;
105         char filenameBuf[128];
106 
107         amt = read(fd, &file, sizeof(FileState));
108         if (amt != sizeof(FileState)) {
109             ALOGW("read_snapshot_file FileState truncated/error with read at %d bytes\n", bytesRead);
110             return 1;
111         }
112         bytesRead += amt;
113 
114         // filename is not NULL terminated, but it is padded
115         int nameBufSize = round_up(file.nameLen);
116         char* filename = nameBufSize <= (int)sizeof(filenameBuf)
117                 ? filenameBuf
118                 : (char*)malloc(nameBufSize);
119         amt = read(fd, filename, nameBufSize);
120         if (amt == nameBufSize) {
121             snapshot->add(String8(filename, file.nameLen), file);
122         }
123         bytesRead += amt;
124         if (filename != filenameBuf) {
125             free(filename);
126         }
127         if (amt != nameBufSize) {
128             ALOGW("read_snapshot_file filename truncated/error with read at %d bytes\n", bytesRead);
129             return 1;
130         }
131     }
132 
133     if (header.totalSize != bytesRead) {
134         ALOGW("read_snapshot_file length mismatch: header.totalSize=%d bytesRead=%d\n",
135                 header.totalSize, bytesRead);
136         return 1;
137     }
138 
139     return 0;
140 }
141 
142 static int
write_snapshot_file(int fd,const KeyedVector<String8,FileRec> & snapshot)143 write_snapshot_file(int fd, const KeyedVector<String8,FileRec>& snapshot)
144 {
145     int fileCount = 0;
146     int bytesWritten = sizeof(SnapshotHeader);
147     // preflight size
148     const int N = snapshot.size();
149     for (int i=0; i<N; i++) {
150         const FileRec& g = snapshot.valueAt(i);
151         if (!g.deleted) {
152             const String8& name = snapshot.keyAt(i);
153             bytesWritten += sizeof(FileState) + round_up(name.length());
154             fileCount++;
155         }
156     }
157 
158     LOGP("write_snapshot_file fd=%d\n", fd);
159 
160     int amt;
161     SnapshotHeader header = { MAGIC0, fileCount, MAGIC1, bytesWritten };
162 
163     amt = write(fd, &header, sizeof(header));
164     if (amt != sizeof(header)) {
165         ALOGW("write_snapshot_file error writing header %s", strerror(errno));
166         return errno;
167     }
168 
169     for (int i=0; i<N; i++) {
170         FileRec r = snapshot.valueAt(i);
171         if (!r.deleted) {
172             const String8& name = snapshot.keyAt(i);
173             int nameLen = r.s.nameLen = name.length();
174 
175             amt = write(fd, &r.s, sizeof(FileState));
176             if (amt != sizeof(FileState)) {
177                 ALOGW("write_snapshot_file error writing header %s", strerror(errno));
178                 return 1;
179             }
180 
181             // filename is not NULL terminated, but it is padded
182             amt = write(fd, name.string(), nameLen);
183             if (amt != nameLen) {
184                 ALOGW("write_snapshot_file error writing filename %s", strerror(errno));
185                 return 1;
186             }
187             int paddingLen = ROUND_UP[nameLen % 4];
188             if (paddingLen != 0) {
189                 int padding = 0xabababab;
190                 amt = write(fd, &padding, paddingLen);
191                 if (amt != paddingLen) {
192                     ALOGW("write_snapshot_file error writing %d bytes of filename padding %s",
193                             paddingLen, strerror(errno));
194                     return 1;
195                 }
196             }
197         }
198     }
199 
200     return 0;
201 }
202 
203 static int
write_delete_file(BackupDataWriter * dataStream,const String8 & key)204 write_delete_file(BackupDataWriter* dataStream, const String8& key)
205 {
206     LOGP("write_delete_file %s\n", key.string());
207     return dataStream->WriteEntityHeader(key, -1);
208 }
209 
210 static int
write_update_file(BackupDataWriter * dataStream,int fd,int mode,const String8 & key,char const * realFilename)211 write_update_file(BackupDataWriter* dataStream, int fd, int mode, const String8& key,
212         char const* realFilename)
213 {
214     LOGP("write_update_file %s (%s) : mode 0%o\n", realFilename, key.string(), mode);
215 
216     const int bufsize = 4*1024;
217     int err;
218     int amt;
219     int fileSize;
220     int bytesLeft;
221     file_metadata_v1 metadata;
222 
223     char* buf = (char*)malloc(bufsize);
224 
225     fileSize = lseek(fd, 0, SEEK_END);
226     lseek(fd, 0, SEEK_SET);
227 
228     if (sizeof(metadata) != 16) {
229         ALOGE("ERROR: metadata block is the wrong size!");
230     }
231 
232     bytesLeft = fileSize + sizeof(metadata);
233     err = dataStream->WriteEntityHeader(key, bytesLeft);
234     if (err != 0) {
235         free(buf);
236         return err;
237     }
238 
239     // store the file metadata first
240     metadata.version = tolel(CURRENT_METADATA_VERSION);
241     metadata.mode = tolel(mode);
242     metadata.undefined_1 = metadata.undefined_2 = 0;
243     err = dataStream->WriteEntityData(&metadata, sizeof(metadata));
244     if (err != 0) {
245         free(buf);
246         return err;
247     }
248     bytesLeft -= sizeof(metadata); // bytesLeft should == fileSize now
249 
250     // now store the file content
251     while ((amt = read(fd, buf, bufsize)) != 0 && bytesLeft > 0) {
252         bytesLeft -= amt;
253         if (bytesLeft < 0) {
254             amt += bytesLeft; // Plus a negative is minus.  Don't write more than we promised.
255         }
256         err = dataStream->WriteEntityData(buf, amt);
257         if (err != 0) {
258             free(buf);
259             return err;
260         }
261     }
262     if (bytesLeft != 0) {
263         if (bytesLeft > 0) {
264             // Pad out the space we promised in the buffer.  We can't corrupt the buffer,
265             // even though the data we're sending is probably bad.
266             memset(buf, 0, bufsize);
267             while (bytesLeft > 0) {
268                 amt = bytesLeft < bufsize ? bytesLeft : bufsize;
269                 bytesLeft -= amt;
270                 err = dataStream->WriteEntityData(buf, amt);
271                 if (err != 0) {
272                     free(buf);
273                     return err;
274                 }
275             }
276         }
277         ALOGE("write_update_file size mismatch for %s. expected=%d actual=%d."
278                 " You aren't doing proper locking!", realFilename, fileSize, fileSize-bytesLeft);
279     }
280 
281     free(buf);
282     return NO_ERROR;
283 }
284 
285 static int
write_update_file(BackupDataWriter * dataStream,const String8 & key,char const * realFilename)286 write_update_file(BackupDataWriter* dataStream, const String8& key, char const* realFilename)
287 {
288     int err;
289     struct stat st;
290 
291     err = stat(realFilename, &st);
292     if (err < 0) {
293         return errno;
294     }
295 
296     int fd = open(realFilename, O_RDONLY);
297     if (fd == -1) {
298         return errno;
299     }
300 
301     err = write_update_file(dataStream, fd, st.st_mode, key, realFilename);
302     close(fd);
303     return err;
304 }
305 
306 static int
compute_crc32(const char * file,FileRec * out)307 compute_crc32(const char* file, FileRec* out) {
308     int fd = open(file, O_RDONLY);
309     if (fd < 0) {
310         return -1;
311     }
312 
313     const int bufsize = 4*1024;
314     int amt;
315 
316     char* buf = (char*)malloc(bufsize);
317     int crc = crc32(0L, Z_NULL, 0);
318 
319     lseek(fd, 0, SEEK_SET);
320 
321     while ((amt = read(fd, buf, bufsize)) != 0) {
322         crc = crc32(crc, (Bytef*)buf, amt);
323     }
324 
325     close(fd);
326     free(buf);
327 
328     out->s.crc32 = crc;
329     return NO_ERROR;
330 }
331 
332 int
back_up_files(int oldSnapshotFD,BackupDataWriter * dataStream,int newSnapshotFD,char const * const * files,char const * const * keys,int fileCount)333 back_up_files(int oldSnapshotFD, BackupDataWriter* dataStream, int newSnapshotFD,
334         char const* const* files, char const* const* keys, int fileCount)
335 {
336     int err;
337     KeyedVector<String8,FileState> oldSnapshot;
338     KeyedVector<String8,FileRec> newSnapshot;
339 
340     if (oldSnapshotFD != -1) {
341         err = read_snapshot_file(oldSnapshotFD, &oldSnapshot);
342         if (err != 0) {
343             // On an error, treat this as a full backup.
344             oldSnapshot.clear();
345         }
346     }
347 
348     for (int i=0; i<fileCount; i++) {
349         String8 key(keys[i]);
350         FileRec r;
351         char const* file = files[i];
352         r.file = file;
353         struct stat st;
354 
355         err = stat(file, &st);
356         if (err != 0) {
357             // not found => treat as deleted
358             continue;
359         } else {
360             r.deleted = false;
361             r.s.modTime_sec = st.st_mtime;
362             r.s.modTime_nsec = 0; // workaround sim breakage
363             //r.s.modTime_nsec = st.st_mtime_nsec;
364             r.s.mode = st.st_mode;
365             r.s.size = st.st_size;
366 
367             if (newSnapshot.indexOfKey(key) >= 0) {
368                 LOGP("back_up_files key already in use '%s'", key.string());
369                 return -1;
370             }
371 
372             // compute the CRC
373             if (compute_crc32(file, &r) != NO_ERROR) {
374                 ALOGW("Unable to open file %s", file);
375                 continue;
376             }
377         }
378         newSnapshot.add(key, r);
379     }
380 
381     int n = 0;
382     int N = oldSnapshot.size();
383     int m = 0;
384     int M = newSnapshot.size();
385 
386     while (n<N && m<M) {
387         const String8& p = oldSnapshot.keyAt(n);
388         const String8& q = newSnapshot.keyAt(m);
389         FileRec& g = newSnapshot.editValueAt(m);
390         int cmp = p.compare(q);
391         if (cmp < 0) {
392             // file present in oldSnapshot, but not present in newSnapshot
393             LOGP("file removed: %s", p.string());
394             write_delete_file(dataStream, p);
395             n++;
396         } else if (cmp > 0) {
397             // file added
398             LOGP("file added: %s crc=0x%08x", g.file.string(), g.s.crc32);
399             write_update_file(dataStream, q, g.file.string());
400             m++;
401         } else {
402             // same file exists in both old and new; check whether to update
403             const FileState& f = oldSnapshot.valueAt(n);
404 
405             LOGP("%s", q.string());
406             LOGP("  old: modTime=%d,%d mode=%04o size=%-3d crc32=0x%08x",
407                     f.modTime_sec, f.modTime_nsec, f.mode, f.size, f.crc32);
408             LOGP("  new: modTime=%d,%d mode=%04o size=%-3d crc32=0x%08x",
409                     g.s.modTime_sec, g.s.modTime_nsec, g.s.mode, g.s.size, g.s.crc32);
410             if (f.modTime_sec != g.s.modTime_sec || f.modTime_nsec != g.s.modTime_nsec
411                     || f.mode != g.s.mode || f.size != g.s.size || f.crc32 != g.s.crc32) {
412                 int fd = open(g.file.string(), O_RDONLY);
413                 if (fd < 0) {
414                     ALOGE("Unable to read file for backup: %s", g.file.string());
415                 } else {
416                     write_update_file(dataStream, fd, g.s.mode, p, g.file.string());
417                     close(fd);
418                 }
419             }
420             n++;
421             m++;
422         }
423     }
424 
425     // these were deleted
426     while (n<N) {
427         write_delete_file(dataStream, oldSnapshot.keyAt(n));
428         n++;
429     }
430 
431     // these were added
432     while (m<M) {
433         const String8& q = newSnapshot.keyAt(m);
434         FileRec& g = newSnapshot.editValueAt(m);
435         write_update_file(dataStream, q, g.file.string());
436         m++;
437     }
438 
439     err = write_snapshot_file(newSnapshotFD, newSnapshot);
440 
441     return 0;
442 }
443 
calc_tar_checksum(char * buf,size_t buf_size)444 static void calc_tar_checksum(char* buf, size_t buf_size) {
445     // [ 148 :   8 ] checksum -- to be calculated with this field as space chars
446     memset(buf + 148, ' ', 8);
447 
448     uint16_t sum = 0;
449     for (uint8_t* p = (uint8_t*) buf; p < ((uint8_t*)buf) + 512; p++) {
450         sum += *p;
451     }
452 
453     // Now write the real checksum value:
454     // [ 148 :   8 ]  checksum: 6 octal digits [leading zeroes], NUL, SPC
455     snprintf(buf + 148, buf_size - 148, "%06o", sum); // the trailing space is
456                                                       // already in place
457 }
458 
459 // Returns number of bytes written
write_pax_header_entry(char * buf,size_t buf_size,const char * key,const char * value)460 static int write_pax_header_entry(char* buf, size_t buf_size,
461                                   const char* key, const char* value) {
462     // start with the size of "1 key=value\n"
463     int len = strlen(key) + strlen(value) + 4;
464     if (len > 9) len++;
465     if (len > 99) len++;
466     if (len > 999) len++;
467     // since PATH_MAX is 4096 we don't expect to have to generate any single
468     // header entry longer than 9999 characters
469 
470     return snprintf(buf, buf_size, "%d %s=%s\n", len, key, value);
471 }
472 
473 // Wire format to the backup manager service is chunked:  each chunk is prefixed by
474 // a 4-byte count of its size.  A chunk size of zero (four zero bytes) indicates EOD.
send_tarfile_chunk(BackupDataWriter * writer,const char * buffer,size_t size)475 void send_tarfile_chunk(BackupDataWriter* writer, const char* buffer, size_t size) {
476     uint32_t chunk_size_no = htonl(size);
477     writer->WriteEntityData(&chunk_size_no, 4);
478     if (size != 0) writer->WriteEntityData(buffer, size);
479 }
480 
write_tarfile(const String8 & packageName,const String8 & domain,const String8 & rootpath,const String8 & filepath,off_t * outSize,BackupDataWriter * writer)481 int write_tarfile(const String8& packageName, const String8& domain,
482         const String8& rootpath, const String8& filepath, off_t* outSize,
483         BackupDataWriter* writer)
484 {
485     // In the output stream everything is stored relative to the root
486     const char* relstart = filepath.string() + rootpath.length();
487     if (*relstart == '/') relstart++;     // won't be true when path == rootpath
488     String8 relpath(relstart);
489 
490     // If relpath is empty, it means this is the top of one of the standard named
491     // domain directories, so we should just skip it
492     if (relpath.length() == 0) {
493         *outSize = 0;
494         return 0;
495     }
496 
497     // Too long a name for the ustar format?
498     //    "apps/" + packagename + '/' + domainpath < 155 chars
499     //    relpath < 100 chars
500     bool needExtended = false;
501     if ((5 + packageName.length() + 1 + domain.length() >= 155) || (relpath.length() >= 100)) {
502         needExtended = true;
503     }
504 
505     // Non-7bit-clean path also means needing pax extended format
506     if (!needExtended) {
507         for (size_t i = 0; i < filepath.length(); i++) {
508             if ((filepath[i] & 0x80) != 0) {
509                 needExtended = true;
510                 break;
511             }
512         }
513     }
514 
515     int err = 0;
516     struct stat64 s;
517     if (lstat64(filepath.string(), &s) != 0) {
518         err = errno;
519         ALOGE("Error %d (%s) from lstat64(%s)", err, strerror(err), filepath.string());
520         return err;
521     }
522 
523     // very large files need a pax extended size header
524     if (s.st_size > 077777777777LL) {
525         needExtended = true;
526     }
527 
528     String8 fullname;   // for pax later on
529     String8 prefix;
530 
531     const int isdir = S_ISDIR(s.st_mode);
532     if (isdir) s.st_size = 0;   // directories get no actual data in the tar stream
533 
534     // Report the size, including a rough tar overhead estimation: 512 bytes for the
535     // overall tar file-block header, plus 2 blocks if using the pax extended format,
536     // plus the raw content size rounded up to a multiple of 512.
537     *outSize = 512 + (needExtended ? 1024 : 0) + 512*((s.st_size + 511)/512);
538 
539     // Measure case: we've returned the size; now return without moving data
540     if (!writer) return 0;
541 
542     // !!! TODO: use mmap when possible to avoid churning the buffer cache
543     // !!! TODO: this will break with symlinks; need to use readlink(2)
544     int fd = open(filepath.string(), O_RDONLY);
545     if (fd < 0) {
546         err = errno;
547         ALOGE("Error %d (%s) from open(%s)", err, strerror(err), filepath.string());
548         return err;
549     }
550 
551     // read/write up to this much at a time.
552     const size_t BUFSIZE = 32 * 1024;
553     char* buf = (char *)calloc(1,BUFSIZE);
554     const size_t PAXHEADER_OFFSET = 512;
555     const size_t PAXHEADER_SIZE = 512;
556     const size_t PAXDATA_SIZE = BUFSIZE - (PAXHEADER_SIZE + PAXHEADER_OFFSET);
557     char* const paxHeader = buf + PAXHEADER_OFFSET; // use a different chunk of
558                                                     // it as separate scratch
559     char* const paxData = paxHeader + PAXHEADER_SIZE;
560 
561     if (buf == NULL) {
562         ALOGE("Out of mem allocating transfer buffer");
563         err = ENOMEM;
564         goto done;
565     }
566 
567     // Magic fields for the ustar file format
568     strcat(buf + 257, "ustar");
569     strcat(buf + 263, "00");
570 
571     // [ 265 : 32 ] user name, ignored on restore
572     // [ 297 : 32 ] group name, ignored on restore
573 
574     // [ 100 :   8 ] file mode
575     snprintf(buf + 100, 8, "%06o ", s.st_mode & ~S_IFMT);
576 
577     // [ 108 :   8 ] uid -- ignored in Android format; uids are remapped at restore time
578     // [ 116 :   8 ] gid -- ignored in Android format
579     snprintf(buf + 108, 8, "0%lo", (unsigned long)s.st_uid);
580     snprintf(buf + 116, 8, "0%lo", (unsigned long)s.st_gid);
581 
582     // [ 124 :  12 ] file size in bytes
583     snprintf(buf + 124, 12, "%011llo", (isdir) ? 0LL : s.st_size);
584 
585     // [ 136 :  12 ] last mod time as a UTC time_t
586     snprintf(buf + 136, 12, "%0lo", (unsigned long)s.st_mtime);
587 
588     // [ 156 :   1 ] link/file type
589     uint8_t type;
590     if (isdir) {
591         type = '5';     // tar magic: '5' == directory
592     } else if (S_ISREG(s.st_mode)) {
593         type = '0';     // tar magic: '0' == normal file
594     } else {
595         ALOGW("Error: unknown file mode 0%o [%s]", s.st_mode, filepath.string());
596         goto cleanup;
597     }
598     buf[156] = type;
599 
600     // [ 157 : 100 ] name of linked file [not implemented]
601 
602     {
603         // Prefix and main relative path.  Path lengths have been preflighted.
604         if (packageName.length() > 0) {
605             prefix = "apps/";
606             prefix += packageName;
607         }
608         if (domain.length() > 0) {
609             prefix.appendPath(domain);
610         }
611 
612         // pax extended means we don't put in a prefix field, and put a different
613         // string in the basic name field.  We can also construct the full path name
614         // out of the substrings we've now built.
615         fullname = prefix;
616         fullname.appendPath(relpath);
617 
618         // ustar:
619         //    [   0 : 100 ]; file name/path
620         //    [ 345 : 155 ] filename path prefix
621         // We only use the prefix area if fullname won't fit in the path
622         if (fullname.length() > 100) {
623             strncpy(buf, relpath.string(), 100);
624             strncpy(buf + 345, prefix.string(), 155);
625         } else {
626             strncpy(buf, fullname.string(), 100);
627         }
628     }
629 
630     // [ 329 : 8 ] and [ 337 : 8 ] devmajor/devminor, not used
631 
632     ALOGI("   Name: %s", fullname.string());
633 
634     // If we're using a pax extended header, build & write that here; lengths are
635     // already preflighted
636     if (needExtended) {
637         char sizeStr[32];   // big enough for a 64-bit unsigned value in decimal
638 
639         // construct the pax extended header data block
640         memset(paxData, 0, PAXDATA_SIZE);
641 
642         // size header -- calc len in digits by actually rendering the number
643         // to a string - brute force but simple
644         int paxLen = 0;
645         snprintf(sizeStr, sizeof(sizeStr), "%lld", (long long)s.st_size);
646         paxLen += write_pax_header_entry(paxData, PAXDATA_SIZE, "size", sizeStr);
647 
648         // fullname was generated above with the ustar paths
649         paxLen += write_pax_header_entry(paxData + paxLen, PAXDATA_SIZE - paxLen,
650                 "path", fullname.string());
651 
652         // Now we know how big the pax data is
653 
654         // Now build the pax *header* templated on the ustar header
655         memcpy(paxHeader, buf, 512);
656 
657         String8 leaf = fullname.getPathLeaf();
658         memset(paxHeader, 0, 100);                  // rewrite the name area
659         snprintf(paxHeader, 100, "PaxHeader/%s", leaf.string());
660         memset(paxHeader + 345, 0, 155);            // rewrite the prefix area
661         strncpy(paxHeader + 345, prefix.string(), 155);
662 
663         paxHeader[156] = 'x';                       // mark it as a pax extended header
664 
665         // [ 124 :  12 ] size of pax extended header data
666         memset(paxHeader + 124, 0, 12);
667         snprintf(paxHeader + 124, 12, "%011o", (unsigned int)paxLen);
668 
669         // Checksum and write the pax block header
670         calc_tar_checksum(paxHeader, PAXHEADER_SIZE);
671         send_tarfile_chunk(writer, paxHeader, 512);
672 
673         // Now write the pax data itself
674         int paxblocks = (paxLen + 511) / 512;
675         send_tarfile_chunk(writer, paxData, 512 * paxblocks);
676     }
677 
678     // Checksum and write the 512-byte ustar file header block to the output
679     calc_tar_checksum(buf, BUFSIZE);
680     send_tarfile_chunk(writer, buf, 512);
681 
682     // Now write the file data itself, for real files.  We honor tar's convention that
683     // only full 512-byte blocks are sent to write().
684     if (!isdir) {
685         off64_t toWrite = s.st_size;
686         while (toWrite > 0) {
687             size_t toRead = toWrite;
688             if (toRead > BUFSIZE) {
689                 toRead = BUFSIZE;
690             }
691             ssize_t nRead = read(fd, buf, toRead);
692             if (nRead < 0) {
693                 err = errno;
694                 ALOGE("Unable to read file [%s], err=%d (%s)", filepath.string(),
695                         err, strerror(err));
696                 break;
697             } else if (nRead == 0) {
698                 ALOGE("EOF but expect %lld more bytes in [%s]", (long long) toWrite,
699                         filepath.string());
700                 err = EIO;
701                 break;
702             }
703 
704             // At EOF we might have a short block; NUL-pad that to a 512-byte multiple.  This
705             // depends on the OS guarantee that for ordinary files, read() will never return
706             // less than the number of bytes requested.
707             ssize_t partial = (nRead+512) % 512;
708             if (partial > 0) {
709                 ssize_t remainder = 512 - partial;
710                 memset(buf + nRead, 0, remainder);
711                 nRead += remainder;
712             }
713             send_tarfile_chunk(writer, buf, nRead);
714             toWrite -= nRead;
715         }
716     }
717 
718 cleanup:
719     free(buf);
720 done:
721     close(fd);
722     return err;
723 }
724 // end tarfile
725 
726 
727 
728 #define RESTORE_BUF_SIZE (8*1024)
729 
RestoreHelperBase()730 RestoreHelperBase::RestoreHelperBase()
731 {
732     m_buf = malloc(RESTORE_BUF_SIZE);
733     m_loggedUnknownMetadata = false;
734 }
735 
~RestoreHelperBase()736 RestoreHelperBase::~RestoreHelperBase()
737 {
738     free(m_buf);
739 }
740 
741 status_t
WriteFile(const String8 & filename,BackupDataReader * in)742 RestoreHelperBase::WriteFile(const String8& filename, BackupDataReader* in)
743 {
744     ssize_t err;
745     size_t dataSize;
746     String8 key;
747     int fd;
748     void* buf = m_buf;
749     ssize_t amt;
750     int mode;
751     int crc;
752     struct stat st;
753     FileRec r;
754 
755     err = in->ReadEntityHeader(&key, &dataSize);
756     if (err != NO_ERROR) {
757         return err;
758     }
759 
760     // Get the metadata block off the head of the file entity and use that to
761     // set up the output file
762     file_metadata_v1 metadata;
763     amt = in->ReadEntityData(&metadata, sizeof(metadata));
764     if (amt != sizeof(metadata)) {
765         ALOGW("Could not read metadata for %s -- %ld / %s", filename.string(),
766                 (long)amt, strerror(errno));
767         return EIO;
768     }
769     metadata.version = fromlel(metadata.version);
770     metadata.mode = fromlel(metadata.mode);
771     if (metadata.version > CURRENT_METADATA_VERSION) {
772         if (!m_loggedUnknownMetadata) {
773             m_loggedUnknownMetadata = true;
774             ALOGW("Restoring file with unsupported metadata version %d (currently %d)",
775                     metadata.version, CURRENT_METADATA_VERSION);
776         }
777     }
778     mode = metadata.mode;
779 
780     // Write the file and compute the crc
781     crc = crc32(0L, Z_NULL, 0);
782     fd = open(filename.string(), O_CREAT|O_RDWR|O_TRUNC, mode);
783     if (fd == -1) {
784         ALOGW("Could not open file %s -- %s", filename.string(), strerror(errno));
785         return errno;
786     }
787 
788     while ((amt = in->ReadEntityData(buf, RESTORE_BUF_SIZE)) > 0) {
789         err = write(fd, buf, amt);
790         if (err != amt) {
791             close(fd);
792             ALOGW("Error '%s' writing '%s'", strerror(errno), filename.string());
793             return errno;
794         }
795         crc = crc32(crc, (Bytef*)buf, amt);
796     }
797 
798     close(fd);
799 
800     // Record for the snapshot
801     err = stat(filename.string(), &st);
802     if (err != 0) {
803         ALOGW("Error stating file that we just created %s", filename.string());
804         return errno;
805     }
806 
807     r.file = filename;
808     r.deleted = false;
809     r.s.modTime_sec = st.st_mtime;
810     r.s.modTime_nsec = 0; // workaround sim breakage
811     //r.s.modTime_nsec = st.st_mtime_nsec;
812     r.s.mode = st.st_mode;
813     r.s.size = st.st_size;
814     r.s.crc32 = crc;
815 
816     m_files.add(key, r);
817 
818     return NO_ERROR;
819 }
820 
821 status_t
WriteSnapshot(int fd)822 RestoreHelperBase::WriteSnapshot(int fd)
823 {
824     return write_snapshot_file(fd, m_files);;
825 }
826 
827 #if TEST_BACKUP_HELPERS
828 
829 #define SCRATCH_DIR "/data/backup_helper_test/"
830 
831 static int
write_text_file(const char * path,const char * data)832 write_text_file(const char* path, const char* data)
833 {
834     int amt;
835     int fd;
836     int len;
837 
838     fd = creat(path, 0666);
839     if (fd == -1) {
840         fprintf(stderr, "creat %s failed\n", path);
841         return errno;
842     }
843 
844     len = strlen(data);
845     amt = write(fd, data, len);
846     if (amt != len) {
847         fprintf(stderr, "error (%s) writing to file %s\n", strerror(errno), path);
848         return errno;
849     }
850 
851     close(fd);
852 
853     return 0;
854 }
855 
856 static int
compare_file(const char * path,const unsigned char * data,int len)857 compare_file(const char* path, const unsigned char* data, int len)
858 {
859     int fd;
860     int amt;
861 
862     fd = open(path, O_RDONLY);
863     if (fd == -1) {
864         fprintf(stderr, "compare_file error (%s) opening %s\n", strerror(errno), path);
865         return errno;
866     }
867 
868     unsigned char* contents = (unsigned char*)malloc(len);
869     if (contents == NULL) {
870         fprintf(stderr, "malloc(%d) failed\n", len);
871         return ENOMEM;
872     }
873 
874     bool sizesMatch = true;
875     amt = lseek(fd, 0, SEEK_END);
876     if (amt != len) {
877         fprintf(stderr, "compare_file file length should be %d, was %d\n", len, amt);
878         sizesMatch = false;
879     }
880     lseek(fd, 0, SEEK_SET);
881 
882     int readLen = amt < len ? amt : len;
883     amt = read(fd, contents, readLen);
884     if (amt != readLen) {
885         fprintf(stderr, "compare_file read expected %d bytes but got %d\n", len, amt);
886     }
887 
888     bool contentsMatch = true;
889     for (int i=0; i<readLen; i++) {
890         if (data[i] != contents[i]) {
891             if (contentsMatch) {
892                 fprintf(stderr, "compare_file contents are different: (index, expected, actual)\n");
893                 contentsMatch = false;
894             }
895             fprintf(stderr, "  [%-2d] %02x %02x\n", i, data[i], contents[i]);
896         }
897     }
898 
899     free(contents);
900     return contentsMatch && sizesMatch ? 0 : 1;
901 }
902 
903 int
backup_helper_test_empty()904 backup_helper_test_empty()
905 {
906     int err;
907     int fd;
908     KeyedVector<String8,FileRec> snapshot;
909     const char* filename = SCRATCH_DIR "backup_helper_test_empty.snap";
910 
911     system("rm -r " SCRATCH_DIR);
912     mkdir(SCRATCH_DIR, 0777);
913 
914     // write
915     fd = creat(filename, 0666);
916     if (fd == -1) {
917         fprintf(stderr, "error creating %s\n", filename);
918         return 1;
919     }
920 
921     err = write_snapshot_file(fd, snapshot);
922 
923     close(fd);
924 
925     if (err != 0) {
926         fprintf(stderr, "write_snapshot_file reported error %d (%s)\n", err, strerror(err));
927         return err;
928     }
929 
930     static const unsigned char correct_data[] = {
931         0x53, 0x6e, 0x61, 0x70,  0x00, 0x00, 0x00, 0x00,
932         0x46, 0x69, 0x6c, 0x65,  0x10, 0x00, 0x00, 0x00
933     };
934 
935     err = compare_file(filename, correct_data, sizeof(correct_data));
936     if (err != 0) {
937         return err;
938     }
939 
940     // read
941     fd = open(filename, O_RDONLY);
942     if (fd == -1) {
943         fprintf(stderr, "error opening for read %s\n", filename);
944         return 1;
945     }
946 
947     KeyedVector<String8,FileState> readSnapshot;
948     err = read_snapshot_file(fd, &readSnapshot);
949     if (err != 0) {
950         fprintf(stderr, "read_snapshot_file failed %d\n", err);
951         return err;
952     }
953 
954     if (readSnapshot.size() != 0) {
955         fprintf(stderr, "readSnapshot should be length 0\n");
956         return 1;
957     }
958 
959     return 0;
960 }
961 
962 int
backup_helper_test_four()963 backup_helper_test_four()
964 {
965     int err;
966     int fd;
967     KeyedVector<String8,FileRec> snapshot;
968     const char* filename = SCRATCH_DIR "backup_helper_test_four.snap";
969 
970     system("rm -r " SCRATCH_DIR);
971     mkdir(SCRATCH_DIR, 0777);
972 
973     // write
974     fd = creat(filename, 0666);
975     if (fd == -1) {
976         fprintf(stderr, "error opening %s\n", filename);
977         return 1;
978     }
979 
980     String8 filenames[4];
981     FileState states[4];
982     FileRec r;
983     r.deleted = false;
984 
985     states[0].modTime_sec = 0xfedcba98;
986     states[0].modTime_nsec = 0xdeadbeef;
987     states[0].mode = 0777; // decimal 511, hex 0x000001ff
988     states[0].size = 0xababbcbc;
989     states[0].crc32 = 0x12345678;
990     states[0].nameLen = -12;
991     r.s = states[0];
992     filenames[0] = String8("bytes_of_padding");
993     snapshot.add(filenames[0], r);
994 
995     states[1].modTime_sec = 0x93400031;
996     states[1].modTime_nsec = 0xdeadbeef;
997     states[1].mode = 0666; // decimal 438, hex 0x000001b6
998     states[1].size = 0x88557766;
999     states[1].crc32 = 0x22334422;
1000     states[1].nameLen = -1;
1001     r.s = states[1];
1002     filenames[1] = String8("bytes_of_padding3");
1003     snapshot.add(filenames[1], r);
1004 
1005     states[2].modTime_sec = 0x33221144;
1006     states[2].modTime_nsec = 0xdeadbeef;
1007     states[2].mode = 0744; // decimal 484, hex 0x000001e4
1008     states[2].size = 0x11223344;
1009     states[2].crc32 = 0x01122334;
1010     states[2].nameLen = 0;
1011     r.s = states[2];
1012     filenames[2] = String8("bytes_of_padding_2");
1013     snapshot.add(filenames[2], r);
1014 
1015     states[3].modTime_sec = 0x33221144;
1016     states[3].modTime_nsec = 0xdeadbeef;
1017     states[3].mode = 0755; // decimal 493, hex 0x000001ed
1018     states[3].size = 0x11223344;
1019     states[3].crc32 = 0x01122334;
1020     states[3].nameLen = 0;
1021     r.s = states[3];
1022     filenames[3] = String8("bytes_of_padding__1");
1023     snapshot.add(filenames[3], r);
1024 
1025     err = write_snapshot_file(fd, snapshot);
1026 
1027     close(fd);
1028 
1029     if (err != 0) {
1030         fprintf(stderr, "write_snapshot_file reported error %d (%s)\n", err, strerror(err));
1031         return err;
1032     }
1033 
1034     static const unsigned char correct_data[] = {
1035         // header
1036         0x53, 0x6e, 0x61, 0x70,  0x04, 0x00, 0x00, 0x00,
1037         0x46, 0x69, 0x6c, 0x65,  0xbc, 0x00, 0x00, 0x00,
1038 
1039         // bytes_of_padding
1040         0x98, 0xba, 0xdc, 0xfe,  0xef, 0xbe, 0xad, 0xde,
1041         0xff, 0x01, 0x00, 0x00,  0xbc, 0xbc, 0xab, 0xab,
1042         0x78, 0x56, 0x34, 0x12,  0x10, 0x00, 0x00, 0x00,
1043         0x62, 0x79, 0x74, 0x65,  0x73, 0x5f, 0x6f, 0x66,
1044         0x5f, 0x70, 0x61, 0x64,  0x64, 0x69, 0x6e, 0x67,
1045 
1046         // bytes_of_padding3
1047         0x31, 0x00, 0x40, 0x93,  0xef, 0xbe, 0xad, 0xde,
1048         0xb6, 0x01, 0x00, 0x00,  0x66, 0x77, 0x55, 0x88,
1049         0x22, 0x44, 0x33, 0x22,  0x11, 0x00, 0x00, 0x00,
1050         0x62, 0x79, 0x74, 0x65,  0x73, 0x5f, 0x6f, 0x66,
1051         0x5f, 0x70, 0x61, 0x64,  0x64, 0x69, 0x6e, 0x67,
1052         0x33, 0xab, 0xab, 0xab,
1053 
1054         // bytes of padding2
1055         0x44, 0x11, 0x22, 0x33,  0xef, 0xbe, 0xad, 0xde,
1056         0xe4, 0x01, 0x00, 0x00,  0x44, 0x33, 0x22, 0x11,
1057         0x34, 0x23, 0x12, 0x01,  0x12, 0x00, 0x00, 0x00,
1058         0x62, 0x79, 0x74, 0x65,  0x73, 0x5f, 0x6f, 0x66,
1059         0x5f, 0x70, 0x61, 0x64,  0x64, 0x69, 0x6e, 0x67,
1060         0x5f, 0x32, 0xab, 0xab,
1061 
1062         // bytes of padding3
1063         0x44, 0x11, 0x22, 0x33,  0xef, 0xbe, 0xad, 0xde,
1064         0xed, 0x01, 0x00, 0x00,  0x44, 0x33, 0x22, 0x11,
1065         0x34, 0x23, 0x12, 0x01,  0x13, 0x00, 0x00, 0x00,
1066         0x62, 0x79, 0x74, 0x65,  0x73, 0x5f, 0x6f, 0x66,
1067         0x5f, 0x70, 0x61, 0x64,  0x64, 0x69, 0x6e, 0x67,
1068         0x5f, 0x5f, 0x31, 0xab
1069     };
1070 
1071     err = compare_file(filename, correct_data, sizeof(correct_data));
1072     if (err != 0) {
1073         return err;
1074     }
1075 
1076     // read
1077     fd = open(filename, O_RDONLY);
1078     if (fd == -1) {
1079         fprintf(stderr, "error opening for read %s\n", filename);
1080         return 1;
1081     }
1082 
1083 
1084     KeyedVector<String8,FileState> readSnapshot;
1085     err = read_snapshot_file(fd, &readSnapshot);
1086     if (err != 0) {
1087         fprintf(stderr, "read_snapshot_file failed %d\n", err);
1088         return err;
1089     }
1090 
1091     if (readSnapshot.size() != 4) {
1092         fprintf(stderr, "readSnapshot should be length 4 is %zu\n", readSnapshot.size());
1093         return 1;
1094     }
1095 
1096     bool matched = true;
1097     for (size_t i=0; i<readSnapshot.size(); i++) {
1098         const String8& name = readSnapshot.keyAt(i);
1099         const FileState state = readSnapshot.valueAt(i);
1100 
1101         if (name != filenames[i] || states[i].modTime_sec != state.modTime_sec
1102                 || states[i].modTime_nsec != state.modTime_nsec || states[i].mode != state.mode
1103                 || states[i].size != state.size || states[i].crc32 != states[i].crc32) {
1104             fprintf(stderr, "state %zu expected={%d/%d, %04o, 0x%08x, 0x%08x, %3zu} '%s'\n"
1105                             "          actual={%d/%d, %04o, 0x%08x, 0x%08x, %3d} '%s'\n", i,
1106                     states[i].modTime_sec, states[i].modTime_nsec, states[i].mode, states[i].size,
1107                     states[i].crc32, name.length(), filenames[i].string(),
1108                     state.modTime_sec, state.modTime_nsec, state.mode, state.size, state.crc32,
1109                     state.nameLen, name.string());
1110             matched = false;
1111         }
1112     }
1113 
1114     return matched ? 0 : 1;
1115 }
1116 
1117 // hexdump -v -e '"    " 8/1 " 0x%02x," "\n"' data_writer.data
1118 const unsigned char DATA_GOLDEN_FILE[] = {
1119      0x44, 0x61, 0x74, 0x61, 0x0b, 0x00, 0x00, 0x00,
1120      0x0c, 0x00, 0x00, 0x00, 0x6e, 0x6f, 0x5f, 0x70,
1121      0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x00,
1122      0x6e, 0x6f, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69,
1123      0x6e, 0x67, 0x5f, 0x00, 0x44, 0x61, 0x74, 0x61,
1124      0x0c, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
1125      0x70, 0x61, 0x64, 0x64, 0x65, 0x64, 0x5f, 0x74,
1126      0x6f, 0x5f, 0x5f, 0x33, 0x00, 0xbc, 0xbc, 0xbc,
1127      0x70, 0x61, 0x64, 0x64, 0x65, 0x64, 0x5f, 0x74,
1128      0x6f, 0x5f, 0x5f, 0x33, 0x00, 0xbc, 0xbc, 0xbc,
1129      0x44, 0x61, 0x74, 0x61, 0x0d, 0x00, 0x00, 0x00,
1130      0x0e, 0x00, 0x00, 0x00, 0x70, 0x61, 0x64, 0x64,
1131      0x65, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x32, 0x5f,
1132      0x5f, 0x00, 0xbc, 0xbc, 0x70, 0x61, 0x64, 0x64,
1133      0x65, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x32, 0x5f,
1134      0x5f, 0x00, 0xbc, 0xbc, 0x44, 0x61, 0x74, 0x61,
1135      0x0a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
1136      0x70, 0x61, 0x64, 0x64, 0x65, 0x64, 0x5f, 0x74,
1137      0x6f, 0x31, 0x00, 0xbc, 0x70, 0x61, 0x64, 0x64,
1138      0x65, 0x64, 0x5f, 0x74, 0x6f, 0x31, 0x00
1139 
1140 };
1141 const int DATA_GOLDEN_FILE_SIZE = sizeof(DATA_GOLDEN_FILE);
1142 
1143 static int
test_write_header_and_entity(BackupDataWriter & writer,const char * str)1144 test_write_header_and_entity(BackupDataWriter& writer, const char* str)
1145 {
1146     int err;
1147     String8 text(str);
1148 
1149     err = writer.WriteEntityHeader(text, text.length()+1);
1150     if (err != 0) {
1151         fprintf(stderr, "WriteEntityHeader failed with %s\n", strerror(err));
1152         return err;
1153     }
1154 
1155     err = writer.WriteEntityData(text.string(), text.length()+1);
1156     if (err != 0) {
1157         fprintf(stderr, "write failed for data '%s'\n", text.string());
1158         return errno;
1159     }
1160 
1161     return err;
1162 }
1163 
1164 int
backup_helper_test_data_writer()1165 backup_helper_test_data_writer()
1166 {
1167     int err;
1168     int fd;
1169     const char* filename = SCRATCH_DIR "data_writer.data";
1170 
1171     system("rm -r " SCRATCH_DIR);
1172     mkdir(SCRATCH_DIR, 0777);
1173     mkdir(SCRATCH_DIR "data", 0777);
1174 
1175     fd = creat(filename, 0666);
1176     if (fd == -1) {
1177         fprintf(stderr, "error creating: %s\n", strerror(errno));
1178         return errno;
1179     }
1180 
1181     BackupDataWriter writer(fd);
1182 
1183     err = 0;
1184     err |= test_write_header_and_entity(writer, "no_padding_");
1185     err |= test_write_header_and_entity(writer, "padded_to__3");
1186     err |= test_write_header_and_entity(writer, "padded_to_2__");
1187     err |= test_write_header_and_entity(writer, "padded_to1");
1188 
1189     close(fd);
1190 
1191     err = compare_file(filename, DATA_GOLDEN_FILE, DATA_GOLDEN_FILE_SIZE);
1192     if (err != 0) {
1193         return err;
1194     }
1195 
1196     return err;
1197 }
1198 
1199 int
test_read_header_and_entity(BackupDataReader & reader,const char * str)1200 test_read_header_and_entity(BackupDataReader& reader, const char* str)
1201 {
1202     int err;
1203     size_t bufSize = strlen(str)+1;
1204     char* buf = (char*)malloc(bufSize);
1205     String8 string;
1206     size_t actualSize;
1207     bool done;
1208     int type;
1209     ssize_t nRead;
1210 
1211     // printf("\n\n---------- test_read_header_and_entity -- %s\n\n", str);
1212 
1213     err = reader.ReadNextHeader(&done, &type);
1214     if (done) {
1215         fprintf(stderr, "should not be done yet\n");
1216         goto finished;
1217     }
1218     if (err != 0) {
1219         fprintf(stderr, "ReadNextHeader (for app header) failed with %s\n", strerror(err));
1220         goto finished;
1221     }
1222     if (type != BACKUP_HEADER_ENTITY_V1) {
1223         err = EINVAL;
1224         fprintf(stderr, "type=0x%08x expected 0x%08x\n", type, BACKUP_HEADER_ENTITY_V1);
1225     }
1226 
1227     err = reader.ReadEntityHeader(&string, &actualSize);
1228     if (err != 0) {
1229         fprintf(stderr, "ReadEntityHeader failed with %s\n", strerror(err));
1230         goto finished;
1231     }
1232     if (string != str) {
1233         fprintf(stderr, "ReadEntityHeader expected key '%s' got '%s'\n", str, string.string());
1234         err = EINVAL;
1235         goto finished;
1236     }
1237     if (actualSize != bufSize) {
1238         fprintf(stderr, "ReadEntityHeader expected dataSize %zu got %zu\n",
1239                 bufSize, actualSize);
1240         err = EINVAL;
1241         goto finished;
1242     }
1243 
1244     nRead = reader.ReadEntityData(buf, bufSize);
1245     if (nRead < 0) {
1246         err = reader.Status();
1247         fprintf(stderr, "ReadEntityData failed with %s\n", strerror(err));
1248         goto finished;
1249     }
1250 
1251     if (0 != memcmp(buf, str, bufSize)) {
1252         fprintf(stderr, "ReadEntityData expected '%s' but got something starting with "
1253                 "%02x %02x %02x %02x  '%c%c%c%c'\n", str, buf[0], buf[1], buf[2], buf[3],
1254                 buf[0], buf[1], buf[2], buf[3]);
1255         err = EINVAL;
1256         goto finished;
1257     }
1258 
1259     // The next read will confirm whether it got the right amount of data.
1260 
1261 finished:
1262     if (err != NO_ERROR) {
1263         fprintf(stderr, "test_read_header_and_entity failed with %s\n", strerror(err));
1264     }
1265     free(buf);
1266     return err;
1267 }
1268 
1269 int
backup_helper_test_data_reader()1270 backup_helper_test_data_reader()
1271 {
1272     int err;
1273     int fd;
1274     const char* filename = SCRATCH_DIR "data_reader.data";
1275 
1276     system("rm -r " SCRATCH_DIR);
1277     mkdir(SCRATCH_DIR, 0777);
1278     mkdir(SCRATCH_DIR "data", 0777);
1279 
1280     fd = creat(filename, 0666);
1281     if (fd == -1) {
1282         fprintf(stderr, "error creating: %s\n", strerror(errno));
1283         return errno;
1284     }
1285 
1286     err = write(fd, DATA_GOLDEN_FILE, DATA_GOLDEN_FILE_SIZE);
1287     if (err != DATA_GOLDEN_FILE_SIZE) {
1288         fprintf(stderr, "Error \"%s\" writing golden file %s\n", strerror(errno), filename);
1289         return errno;
1290     }
1291 
1292     close(fd);
1293 
1294     fd = open(filename, O_RDONLY);
1295     if (fd == -1) {
1296         fprintf(stderr, "Error \"%s\" opening golden file %s for read\n", strerror(errno),
1297                 filename);
1298         return errno;
1299     }
1300 
1301     {
1302         BackupDataReader reader(fd);
1303 
1304         err = 0;
1305 
1306         if (err == NO_ERROR) {
1307             err = test_read_header_and_entity(reader, "no_padding_");
1308         }
1309 
1310         if (err == NO_ERROR) {
1311             err = test_read_header_and_entity(reader, "padded_to__3");
1312         }
1313 
1314         if (err == NO_ERROR) {
1315             err = test_read_header_and_entity(reader, "padded_to_2__");
1316         }
1317 
1318         if (err == NO_ERROR) {
1319             err = test_read_header_and_entity(reader, "padded_to1");
1320         }
1321     }
1322 
1323     close(fd);
1324 
1325     return err;
1326 }
1327 
1328 static int
get_mod_time(const char * filename,struct timeval times[2])1329 get_mod_time(const char* filename, struct timeval times[2])
1330 {
1331     int err;
1332     struct stat64 st;
1333     err = stat64(filename, &st);
1334     if (err != 0) {
1335         fprintf(stderr, "stat '%s' failed: %s\n", filename, strerror(errno));
1336         return errno;
1337     }
1338 
1339     times[0].tv_sec = st.st_atim.tv_sec;
1340     times[0].tv_usec = st.st_atim.tv_nsec / 1000;
1341 
1342     times[1].tv_sec = st.st_mtim.tv_sec;
1343     times[1].tv_usec = st.st_mtim.tv_nsec / 1000;
1344 
1345     return 0;
1346 }
1347 
1348 int
backup_helper_test_files()1349 backup_helper_test_files()
1350 {
1351     int err;
1352     int oldSnapshotFD;
1353     int dataStreamFD;
1354     int newSnapshotFD;
1355 
1356     system("rm -r " SCRATCH_DIR);
1357     mkdir(SCRATCH_DIR, 0777);
1358     mkdir(SCRATCH_DIR "data", 0777);
1359 
1360     write_text_file(SCRATCH_DIR "data/b", "b\nbb\n");
1361     write_text_file(SCRATCH_DIR "data/c", "c\ncc\n");
1362     write_text_file(SCRATCH_DIR "data/d", "d\ndd\n");
1363     write_text_file(SCRATCH_DIR "data/e", "e\nee\n");
1364     write_text_file(SCRATCH_DIR "data/f", "f\nff\n");
1365     write_text_file(SCRATCH_DIR "data/h", "h\nhh\n");
1366 
1367     char const* files_before[] = {
1368         SCRATCH_DIR "data/b",
1369         SCRATCH_DIR "data/c",
1370         SCRATCH_DIR "data/d",
1371         SCRATCH_DIR "data/e",
1372         SCRATCH_DIR "data/f"
1373     };
1374 
1375     char const* keys_before[] = {
1376         "data/b",
1377         "data/c",
1378         "data/d",
1379         "data/e",
1380         "data/f"
1381     };
1382 
1383     dataStreamFD = creat(SCRATCH_DIR "1.data", 0666);
1384     if (dataStreamFD == -1) {
1385         fprintf(stderr, "error creating: %s\n", strerror(errno));
1386         return errno;
1387     }
1388 
1389     newSnapshotFD = creat(SCRATCH_DIR "before.snap", 0666);
1390     if (newSnapshotFD == -1) {
1391         fprintf(stderr, "error creating: %s\n", strerror(errno));
1392         return errno;
1393     }
1394 
1395     {
1396         BackupDataWriter dataStream(dataStreamFD);
1397 
1398         err = back_up_files(-1, &dataStream, newSnapshotFD, files_before, keys_before, 5);
1399         if (err != 0) {
1400             return err;
1401         }
1402     }
1403 
1404     close(dataStreamFD);
1405     close(newSnapshotFD);
1406 
1407     sleep(3);
1408 
1409     struct timeval d_times[2];
1410     struct timeval e_times[2];
1411 
1412     err = get_mod_time(SCRATCH_DIR "data/d", d_times);
1413     err |= get_mod_time(SCRATCH_DIR "data/e", e_times);
1414     if (err != 0) {
1415         return err;
1416     }
1417 
1418     write_text_file(SCRATCH_DIR "data/a", "a\naa\n");
1419     unlink(SCRATCH_DIR "data/c");
1420     write_text_file(SCRATCH_DIR "data/c", "c\ncc\n");
1421     write_text_file(SCRATCH_DIR "data/d", "dd\ndd\n");
1422     utimes(SCRATCH_DIR "data/d", d_times);
1423     write_text_file(SCRATCH_DIR "data/e", "z\nzz\n");
1424     utimes(SCRATCH_DIR "data/e", e_times);
1425     write_text_file(SCRATCH_DIR "data/g", "g\ngg\n");
1426     unlink(SCRATCH_DIR "data/f");
1427 
1428     char const* files_after[] = {
1429         SCRATCH_DIR "data/a", // added
1430         SCRATCH_DIR "data/b", // same
1431         SCRATCH_DIR "data/c", // different mod time
1432         SCRATCH_DIR "data/d", // different size (same mod time)
1433         SCRATCH_DIR "data/e", // different contents (same mod time, same size)
1434         SCRATCH_DIR "data/g"  // added
1435     };
1436 
1437     char const* keys_after[] = {
1438         "data/a", // added
1439         "data/b", // same
1440         "data/c", // different mod time
1441         "data/d", // different size (same mod time)
1442         "data/e", // different contents (same mod time, same size)
1443         "data/g"  // added
1444     };
1445 
1446     oldSnapshotFD = open(SCRATCH_DIR "before.snap", O_RDONLY);
1447     if (oldSnapshotFD == -1) {
1448         fprintf(stderr, "error opening: %s\n", strerror(errno));
1449         return errno;
1450     }
1451 
1452     dataStreamFD = creat(SCRATCH_DIR "2.data", 0666);
1453     if (dataStreamFD == -1) {
1454         fprintf(stderr, "error creating: %s\n", strerror(errno));
1455         return errno;
1456     }
1457 
1458     newSnapshotFD = creat(SCRATCH_DIR "after.snap", 0666);
1459     if (newSnapshotFD == -1) {
1460         fprintf(stderr, "error creating: %s\n", strerror(errno));
1461         return errno;
1462     }
1463 
1464     {
1465         BackupDataWriter dataStream(dataStreamFD);
1466 
1467         err = back_up_files(oldSnapshotFD, &dataStream, newSnapshotFD, files_after, keys_after, 6);
1468         if (err != 0) {
1469             return err;
1470         }
1471 }
1472 
1473     close(oldSnapshotFD);
1474     close(dataStreamFD);
1475     close(newSnapshotFD);
1476 
1477     return 0;
1478 }
1479 
1480 int
backup_helper_test_null_base()1481 backup_helper_test_null_base()
1482 {
1483     int err;
1484     int dataStreamFD;
1485     int newSnapshotFD;
1486 
1487     system("rm -r " SCRATCH_DIR);
1488     mkdir(SCRATCH_DIR, 0777);
1489     mkdir(SCRATCH_DIR "data", 0777);
1490 
1491     write_text_file(SCRATCH_DIR "data/a", "a\naa\n");
1492 
1493     char const* files[] = {
1494         SCRATCH_DIR "data/a",
1495     };
1496 
1497     char const* keys[] = {
1498         "a",
1499     };
1500 
1501     dataStreamFD = creat(SCRATCH_DIR "null_base.data", 0666);
1502     if (dataStreamFD == -1) {
1503         fprintf(stderr, "error creating: %s\n", strerror(errno));
1504         return errno;
1505     }
1506 
1507     newSnapshotFD = creat(SCRATCH_DIR "null_base.snap", 0666);
1508     if (newSnapshotFD == -1) {
1509         fprintf(stderr, "error creating: %s\n", strerror(errno));
1510         return errno;
1511     }
1512 
1513     {
1514         BackupDataWriter dataStream(dataStreamFD);
1515 
1516         err = back_up_files(-1, &dataStream, newSnapshotFD, files, keys, 1);
1517         if (err != 0) {
1518             return err;
1519         }
1520     }
1521 
1522     close(dataStreamFD);
1523     close(newSnapshotFD);
1524 
1525     return 0;
1526 }
1527 
1528 int
backup_helper_test_missing_file()1529 backup_helper_test_missing_file()
1530 {
1531     int err;
1532     int dataStreamFD;
1533     int newSnapshotFD;
1534 
1535     system("rm -r " SCRATCH_DIR);
1536     mkdir(SCRATCH_DIR, 0777);
1537     mkdir(SCRATCH_DIR "data", 0777);
1538 
1539     write_text_file(SCRATCH_DIR "data/b", "b\nbb\n");
1540 
1541     char const* files[] = {
1542         SCRATCH_DIR "data/a",
1543         SCRATCH_DIR "data/b",
1544         SCRATCH_DIR "data/c",
1545     };
1546 
1547     char const* keys[] = {
1548         "a",
1549         "b",
1550         "c",
1551     };
1552 
1553     dataStreamFD = creat(SCRATCH_DIR "null_base.data", 0666);
1554     if (dataStreamFD == -1) {
1555         fprintf(stderr, "error creating: %s\n", strerror(errno));
1556         return errno;
1557     }
1558 
1559     newSnapshotFD = creat(SCRATCH_DIR "null_base.snap", 0666);
1560     if (newSnapshotFD == -1) {
1561         fprintf(stderr, "error creating: %s\n", strerror(errno));
1562         return errno;
1563     }
1564 
1565     {
1566         BackupDataWriter dataStream(dataStreamFD);
1567 
1568         err = back_up_files(-1, &dataStream, newSnapshotFD, files, keys, 1);
1569         if (err != 0) {
1570             return err;
1571         }
1572     }
1573 
1574     close(dataStreamFD);
1575     close(newSnapshotFD);
1576 
1577     return 0;
1578 }
1579 
1580 
1581 #endif // TEST_BACKUP_HELPERS
1582 
1583 }
1584