gui/src/tarfile.cc

   1 ///
   2 /// \file       tarfile.cc
   3 ///             API for reading and writing sequentially from compressed
   4 ///             tar files.
   5
   6 /*
   7     Copyright (C) 2007-2008, Chris Frey <cdfrey@foursquare.net>
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18     See the GNU General Public License in the COPYING file at the
  19     root directory of this project for more details.
  20 */
  21
  22 #include "tarfile.h"
  23
  24 #include <fcntl.h>
  25 #include <errno.h>
  26 #include <string.h>
  27
  28 namespace reuse {
  29
  30 TarFile::TarFile(const char *filename,
  31                  bool create,
  32                  tartype_t *compress_ops,
  33                  bool always_throw)
  34         : m_tar(0),
  35         m_throw(always_throw),
  36         m_writemode(create)
  37 {
  38         // figure out how to handle the file flags/modes
  39         int flags = 0;
  40         mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
  41
  42         if( m_writemode ) {
  43                 flags = O_WRONLY | O_CREAT | O_EXCL;
  44         }
  45         else {
  46                 flags = O_RDONLY;
  47         }
  48
  49         // open... throw on error, as we are in the constructor
  50         if( tar_open(&m_tar, const_cast<char*>(filename),
  51                 compress_ops, flags, mode, TAR_VERBOSE | TAR_GNU) == -1 ) {
  52                 throw TarError(std::string("Unable to open tar file: ") + strerror(errno));
  53         }
  54 }
  55
  56 TarFile::~TarFile()
  57 {
  58         try {
  59                 Close();
  60         } catch( TarError &te ) {}
  61 }
  62
  63 bool TarFile::False(const char *msg)
  64 {
  65         m_last_error = msg;
  66         if( m_throw )
  67                 throw TarError(msg);
  68         else
  69                 return false;
  70 }
  71
  72 bool TarFile::False(const std::string &msg, int err)
  73 {
  74         std::string str = msg;
  75         str += ": ";
  76         str += strerror(err);
  77         return False(str);
  78 }
  79
  80 bool TarFile::Close()
  81 {
  82         if( m_tar ) {
  83                 if( m_writemode ) {
  84                         if( tar_append_eof(m_tar) != 0 )
  85                                 return False("Unable to write eof", errno);
  86                 }
  87
  88                 if( tar_close(m_tar) != 0 ) {
  89                         return False("Unable to close file", errno);
  90                 }
  91                 m_tar = 0;
  92         }
  93         return true;
  94 }
  95
  96 /// Appends a new file to the current tarfile, using tarpath as
  97 /// its internal filename, and data as the complete file contents.
  98 /// Uses current date and time as file mtime.
  99 bool TarFile::AppendFile(const char *tarpath, const std::string &data)
 100 {
 101         // write standard file header
 102         th_set_type(m_tar, REGTYPE);
 103         th_set_mode(m_tar, 0644);
 104         th_set_path(m_tar, const_cast<char*>(tarpath));
 105         th_set_user(m_tar, 0);
 106         th_set_group(m_tar, 0);
 107         th_set_size(m_tar, data.size());
 108         th_set_mtime(m_tar, time(NULL));
 109         if( th_write(m_tar) != 0 ) {
 110                 return False("Unable to write tar header", errno);
 111         }
 112
 113         // write the data in blocks until finished
 114         char block[T_BLOCKSIZE];
 115         for( size_t pos = 0; pos < data.size(); pos += T_BLOCKSIZE ) {
 116                 memset(block, 0, T_BLOCKSIZE);
 117
 118                 size_t size = T_BLOCKSIZE;
 119                 if( data.size() - pos < T_BLOCKSIZE )
 120                         size = data.size() - pos;
 121
 122                 memcpy(block, data.data() + pos, size);
 123
 124                 if( tar_block_write(m_tar, block) != T_BLOCKSIZE ) {
 125                         return False("Unable to write block", errno);
 126                 }
 127         }
 128
 129         return true;
 130 }
 131
 132 /// Reads next available file into data, filling tarpath with
 133 /// internal filename from tarball.
 134 bool TarFile::ReadNextFile(std::string &tarpath, std::string &data)
 135 {
 136         // start fresh
 137         tarpath.clear();
 138         data.clear();
 139
 140         // read next tar file header
 141         if( th_read(m_tar) != 0 ) {
 142                 // this is not necessarily an error, as it could just
 143                 // be the end of file, so a simple false is good here,
 144                 // don't throw an exception
 145                 m_last_error = "";
 146                 return false;
 147         }
 148
 149         // write standard file header
 150         if( !TH_ISREG(m_tar) ) {
 151                 return False("Only regular files are supported inside a tarball.");
 152         }
 153
 154         tarpath = th_get_pathname(m_tar);
 155         size_t size = th_get_size(m_tar);
 156
 157         // read the data in blocks until finished
 158         char block[T_BLOCKSIZE];
 159         for( size_t pos = 0; pos < size; pos += T_BLOCKSIZE ) {
 160                 memset(block, 0, T_BLOCKSIZE);
 161
 162                 size_t readsize = T_BLOCKSIZE;
 163                 if( size - pos < T_BLOCKSIZE )
 164                         readsize = size - pos;
 165
 166                 if( tar_block_read(m_tar, block) != T_BLOCKSIZE ) {
 167                         return False("Unable to read block", errno);
 168                 }
 169
 170                 data.append(block, readsize);
 171         }
 172
 173         return true;
 174 }
 175
 176 /// Read next available filename, skipping the data if it is
 177 /// a regular file
 178 bool TarFile::ReadNextFilenameOnly(std::string &tarpath)
 179 {
 180         // start fresh
 181         tarpath.clear();
 182
 183         // read next tar file header
 184         if( th_read(m_tar) != 0 ) {
 185                 // this is not necessarily an error, as it could just
 186                 // be the end of file, so a simple false is good here,
 187                 // don't throw an exception
 188                 m_last_error = "";
 189                 return false;
 190         }
 191
 192         // write standard file header
 193         if( !TH_ISREG(m_tar) ) {
 194                 return False("Only regular files are supported inside a tarball.");
 195         }
 196
 197         tarpath = th_get_pathname(m_tar);
 198
 199         if( tar_skip_regfile(m_tar) != 0 ) {
 200                 return False("Unable to skip tar file", errno);
 201         }
 202
 203         return true;
 204 }
 205
 206
 207 } // namespace reuse
 208
 209
 210 #ifdef __TEST_MODE__
 211
 212 #include <iostream>
 213 #include <unistd.h>
 214
 215 using namespace std;
 216
 217 int main()
 218 {
 219         try {
 220                 cout << "Writing test file..." << endl;
 221                 reuse::TarFile output("tartest.tar.gz", true, true, true);
 222                 std::string data;
 223                 for( int i = 0; i < 60; i++ ) {
 224                         data.append("0123456789", 10);
 225                 }
 226
 227                 output.AppendFile("path1/test1.txt", data);
 228                 output.AppendFile("path2/test2.txt", data);
 229                 output.Close();
 230
 231
 232                 cout << "Reading test file..." << endl;
 233                 reuse::TarFile input("tartest.tar.gz", false, true, true);
 234                 std::string path, incoming;
 235
 236                 while( input.ReadNextFile(path, incoming) ) {
 237                         cout << "Read: " << path
 238                              << " Data: "
 239                              << (( data == incoming ) ? "equal" : "different")
 240                              << endl;
 241                 }
 242
 243                 input.Close();
 244
 245                 unlink("tartest.tar.gz");
 246
 247         } catch( reuse::TarFile::TarError &te ) {
 248                 cerr << te.what() << endl;
 249                 return 1;
 250         }
 251 }
 252
 253 #endif
 254