1 /*

     2  * A C++ I/O streams interface to the zlib gz* functions

     3  *

     4  * by Ludwig Schwardt <schwardt@sun.ac.za>

     5  * original version by Kevin Ruland <kevin@rodin.wustl.edu>

     6  *

     7  * This version is standard-compliant and compatible with gcc 3.x.

     8  */

     9 

    10 #include "zfstream.h"

    11 #include <cstring>          // for strcpy, strcat, strlen (mode strings)

    12 #include <cstdio>           // for BUFSIZ

    13 

    14 // Internal buffer sizes (default and "unbuffered" versions)

    15 #define BIGBUFSIZE BUFSIZ

    16 #define SMALLBUFSIZE 1

    17 

    18 /*****************************************************************************/

    19 

    20 // Default constructor

    21 gzfilebuf::gzfilebuf()

    22 : file(NULL), io_mode(std::ios_base::openmode(0)), own_fd(false),

    23   buffer(NULL), buffer_size(BIGBUFSIZE), own_buffer(true)

    24 {

    25   // No buffers to start with

    26   this->disable_buffer();

    27 }

    28 

    29 // Destructor

    30 gzfilebuf::~gzfilebuf()

    31 {

    32   // Sync output buffer and close only if responsible for file

    33   // (i.e. attached streams should be left open at this stage)

    34   this->sync();

    35   if (own_fd)

    36     this->close();

    37   // Make sure internal buffer is deallocated

    38   this->disable_buffer();

    39 }

    40 

    41 // Set compression level and strategy

    42 int

    43 gzfilebuf::setcompression(int comp_level,

    44                           int comp_strategy)

    45 {

    46   return gzsetparams(file, comp_level, comp_strategy);

    47 }

    48 

    49 // Open gzipped file

    50 gzfilebuf*

    51 gzfilebuf::open(const char *name,

    52                 std::ios_base::openmode mode)

    53 {

    54   // Fail if file already open

    55   if (this->is_open())

    56     return NULL;

    57   // Don't support simultaneous read/write access (yet)

    58   if ((mode & std::ios_base::in) && (mode & std::ios_base::out))

    59     return NULL;

    60 

    61   // Build mode string for gzopen and check it [27.8.1.3.2]

    62   char char_mode[6] = "\0\0\0\0\0";

    63   if (!this->open_mode(mode, char_mode))

    64     return NULL;

    65 

    66   // Attempt to open file

    67   if ((file = gzopen(name, char_mode)) == NULL)

    68     return NULL;

    69 

    70   // On success, allocate internal buffer and set flags

    71   this->enable_buffer();

    72   io_mode = mode;

    73   own_fd = true;

    74   return this;

    75 }

    76 

    77 // Attach to gzipped file

    78 gzfilebuf*

    79 gzfilebuf::attach(int fd,

    80                   std::ios_base::openmode mode)

    81 {

    82   // Fail if file already open

    83   if (this->is_open())

    84     return NULL;

    85   // Don't support simultaneous read/write access (yet)

    86   if ((mode & std::ios_base::in) && (mode & std::ios_base::out))

    87     return NULL;

    88 

    89   // Build mode string for gzdopen and check it [27.8.1.3.2]

    90   char char_mode[6] = "\0\0\0\0\0";

    91   if (!this->open_mode(mode, char_mode))

    92     return NULL;

    93 

    94   // Attempt to attach to file

    95   if ((file = gzdopen(fd, char_mode)) == NULL)

    96     return NULL;

    97 

    98   // On success, allocate internal buffer and set flags

    99   this->enable_buffer();

   100   io_mode = mode;

   101   own_fd = false;

   102   return this;

   103 }

   104 

   105 // Close gzipped file

   106 gzfilebuf*

   107 gzfilebuf::close()

   108 {

   109   // Fail immediately if no file is open

   110   if (!this->is_open())

   111     return NULL;

   112   // Assume success

   113   gzfilebuf* retval = this;

   114   // Attempt to sync and close gzipped file

   115   if (this->sync() == -1)

   116     retval = NULL;

   117   if (gzclose(file) < 0)

   118     retval = NULL;

   119   // File is now gone anyway (postcondition [27.8.1.3.8])

   120   file = NULL;

   121   own_fd = false;

   122   // Destroy internal buffer if it exists

   123   this->disable_buffer();

   124   return retval;

   125 }

   126 

   127 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

   128 

   129 // Convert int open mode to mode string

   130 bool

   131 gzfilebuf::open_mode(std::ios_base::openmode mode,

   132                      char* c_mode) const

   133 {

   134   bool testb = mode & std::ios_base::binary;

   135   bool testi = mode & std::ios_base::in;

   136   bool testo = mode & std::ios_base::out;

   137   bool testt = mode & std::ios_base::trunc;

   138   bool testa = mode & std::ios_base::app;

   139 

   140   // Check for valid flag combinations - see [27.8.1.3.2] (Table 92)

   141   // Original zfstream hardcoded the compression level to maximum here...

   142   // Double the time for less than 1% size improvement seems

   143   // excessive though - keeping it at the default level

   144   // To change back, just append "9" to the next three mode strings

   145   if (!testi && testo && !testt && !testa)

   146     strcpy(c_mode, "w");

   147   if (!testi && testo && !testt && testa)

   148     strcpy(c_mode, "a");

   149   if (!testi && testo && testt && !testa)

   150     strcpy(c_mode, "w");

   151   if (testi && !testo && !testt && !testa)

   152     strcpy(c_mode, "r");

   153   // No read/write mode yet

   154 //  if (testi && testo && !testt && !testa)

   155 //    strcpy(c_mode, "r+");

   156 //  if (testi && testo && testt && !testa)

   157 //    strcpy(c_mode, "w+");

   158 

   159   // Mode string should be empty for invalid combination of flags

   160   if (strlen(c_mode) == 0)

   161     return false;

   162   if (testb)

   163     strcat(c_mode, "b");

   164   return true;

   165 }

   166 

   167 // Determine number of characters in internal get buffer

   168 std::streamsize

   169 gzfilebuf::showmanyc()

   170 {

   171   // Calls to underflow will fail if file not opened for reading

   172   if (!this->is_open() || !(io_mode & std::ios_base::in))

   173     return -1;

   174   // Make sure get area is in use

   175   if (this->gptr() && (this->gptr() < this->egptr()))

   176     return std::streamsize(this->egptr() - this->gptr());

   177   else

   178     return 0;

   179 }

   180 

   181 // Fill get area from gzipped file

   182 gzfilebuf::int_type

   183 gzfilebuf::underflow()

   184 {

   185   // If something is left in the get area by chance, return it

   186   // (this shouldn't normally happen, as underflow is only supposed

   187   // to be called when gptr >= egptr, but it serves as error check)

   188   if (this->gptr() && (this->gptr() < this->egptr()))

   189     return traits_type::to_int_type(*(this->gptr()));

   190 

   191   // If the file hasn't been opened for reading, produce error

   192   if (!this->is_open() || !(io_mode & std::ios_base::in))

   193     return traits_type::eof();

   194 

   195   // Attempt to fill internal buffer from gzipped file

   196   // (buffer must be guaranteed to exist...)

   197   int bytes_read = gzread(file, buffer, buffer_size);

   198   // Indicates error or EOF

   199   if (bytes_read <= 0)

   200   {

   201     // Reset get area

   202     this->setg(buffer, buffer, buffer);

   203     return traits_type::eof();

   204   }

   205   // Make all bytes read from file available as get area

   206   this->setg(buffer, buffer, buffer + bytes_read);

   207 

   208   // Return next character in get area

   209   return traits_type::to_int_type(*(this->gptr()));

   210 }

   211 

   212 // Write put area to gzipped file

   213 gzfilebuf::int_type

   214 gzfilebuf::overflow(int_type c)

   215 {

   216   // Determine whether put area is in use

   217   if (this->pbase())

   218   {

   219     // Double-check pointer range

   220     if (this->pptr() > this->epptr() || this->pptr() < this->pbase())

   221       return traits_type::eof();

   222     // Add extra character to buffer if not EOF

   223     if (!traits_type::eq_int_type(c, traits_type::eof()))

   224     {

   225       *(this->pptr()) = traits_type::to_char_type(c);

   226       this->pbump(1);

   227     }

   228     // Number of characters to write to file

   229     int bytes_to_write = this->pptr() - this->pbase();

   230     // Overflow doesn't fail if nothing is to be written

   231     if (bytes_to_write > 0)

   232     {

   233       // If the file hasn't been opened for writing, produce error

   234       if (!this->is_open() || !(io_mode & std::ios_base::out))

   235         return traits_type::eof();

   236       // If gzipped file won't accept all bytes written to it, fail

   237       if (gzwrite(file, this->pbase(), bytes_to_write) != bytes_to_write)

   238         return traits_type::eof();

   239       // Reset next pointer to point to pbase on success

   240       this->pbump(-bytes_to_write);

   241     }

   242   }

   243   // Write extra character to file if not EOF

   244   else if (!traits_type::eq_int_type(c, traits_type::eof()))

   245   {

   246     // If the file hasn't been opened for writing, produce error

   247     if (!this->is_open() || !(io_mode & std::ios_base::out))

   248       return traits_type::eof();

   249     // Impromptu char buffer (allows "unbuffered" output)

   250     char_type last_char = traits_type::to_char_type(c);

   251     // If gzipped file won't accept this character, fail

   252     if (gzwrite(file, &last_char, 1) != 1)

   253       return traits_type::eof();

   254   }

   255 

   256   // If you got here, you have succeeded (even if c was EOF)

   257   // The return value should therefore be non-EOF

   258   if (traits_type::eq_int_type(c, traits_type::eof()))

   259     return traits_type::not_eof(c);

   260   else

   261     return c;

   262 }

   263 

   264 // Assign new buffer

   265 std::streambuf*

   266 gzfilebuf::setbuf(char_type* p,

   267                   std::streamsize n)

   268 {

   269   // First make sure stuff is sync'ed, for safety

   270   if (this->sync() == -1)

   271     return NULL;

   272   // If buffering is turned off on purpose via setbuf(0,0), still allocate one...

   273   // "Unbuffered" only really refers to put [27.8.1.4.10], while get needs at

   274   // least a buffer of size 1 (very inefficient though, therefore make it bigger?)

   275   // This follows from [27.5.2.4.3]/12 (gptr needs to point at something, it seems)

   276   if (!p || !n)

   277   {

   278     // Replace existing buffer (if any) with small internal buffer

   279     this->disable_buffer();

   280     buffer = NULL;

   281     buffer_size = 0;

   282     own_buffer = true;

   283     this->enable_buffer();

   284   }

   285   else

   286   {

   287     // Replace existing buffer (if any) with external buffer

   288     this->disable_buffer();

   289     buffer = p;

   290     buffer_size = n;

   291     own_buffer = false;

   292     this->enable_buffer();

   293   }

   294   return this;

   295 }

   296 

   297 // Write put area to gzipped file (i.e. ensures that put area is empty)

   298 int

   299 gzfilebuf::sync()

   300 {

   301   return traits_type::eq_int_type(this->overflow(), traits_type::eof()) ? -1 : 0;

   302 }

   303 

   304 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

   305 

   306 // Allocate internal buffer

   307 void

   308 gzfilebuf::enable_buffer()

   309 {

   310   // If internal buffer required, allocate one

   311   if (own_buffer && !buffer)

   312   {

   313     // Check for buffered vs. "unbuffered"

   314     if (buffer_size > 0)

   315     {

   316       // Allocate internal buffer

   317       buffer = new char_type[buffer_size];

   318       // Get area starts empty and will be expanded by underflow as need arises

   319       this->setg(buffer, buffer, buffer);

   320       // Setup entire internal buffer as put area.

   321       // The one-past-end pointer actually points to the last element of the buffer,

   322       // so that overflow(c) can safely add the extra character c to the sequence.

   323       // These pointers remain in place for the duration of the buffer

   324       this->setp(buffer, buffer + buffer_size - 1);

   325     }

   326     else

   327     {

   328       // Even in "unbuffered" case, (small?) get buffer is still required

   329       buffer_size = SMALLBUFSIZE;

   330       buffer = new char_type[buffer_size];

   331       this->setg(buffer, buffer, buffer);

   332       // "Unbuffered" means no put buffer

   333       this->setp(0, 0);

   334     }

   335   }

   336   else

   337   {

   338     // If buffer already allocated, reset buffer pointers just to make sure no

   339     // stale chars are lying around

   340     this->setg(buffer, buffer, buffer);

   341     this->setp(buffer, buffer + buffer_size - 1);

   342   }

   343 }

   344 

   345 // Destroy internal buffer

   346 void

   347 gzfilebuf::disable_buffer()

   348 {

   349   // If internal buffer exists, deallocate it

   350   if (own_buffer && buffer)

   351   {

   352     // Preserve unbuffered status by zeroing size

   353     if (!this->pbase())

   354       buffer_size = 0;

   355     delete[] buffer;

   356     buffer = NULL;

   357     this->setg(0, 0, 0);

   358     this->setp(0, 0);

   359   }

   360   else

   361   {

   362     // Reset buffer pointers to initial state if external buffer exists

   363     this->setg(buffer, buffer, buffer);

   364     if (buffer)

   365       this->setp(buffer, buffer + buffer_size - 1);

   366     else

   367       this->setp(0, 0);

   368   }

   369 }

   370 

   371 /*****************************************************************************/

   372 

   373 // Default constructor initializes stream buffer

   374 gzifstream::gzifstream()

   375 : std::istream(NULL), sb()

   376 { this->init(&sb); }

   377 

   378 // Initialize stream buffer and open file

   379 gzifstream::gzifstream(const char* name,

   380                        std::ios_base::openmode mode)

   381 : std::istream(NULL), sb()

   382 {

   383   this->init(&sb);

   384   this->open(name, mode);

   385 }

   386 

   387 // Initialize stream buffer and attach to file

   388 gzifstream::gzifstream(int fd,

   389                        std::ios_base::openmode mode)

   390 : std::istream(NULL), sb()

   391 {

   392   this->init(&sb);

   393   this->attach(fd, mode);

   394 }

   395 

   396 // Open file and go into fail() state if unsuccessful

   397 void

   398 gzifstream::open(const char* name,

   399                  std::ios_base::openmode mode)

   400 {

   401   if (!sb.open(name, mode | std::ios_base::in))

   402     this->setstate(std::ios_base::failbit);

   403   else

   404     this->clear();

   405 }

   406 

   407 // Attach to file and go into fail() state if unsuccessful

   408 void

   409 gzifstream::attach(int fd,

   410                    std::ios_base::openmode mode)

   411 {

   412   if (!sb.attach(fd, mode | std::ios_base::in))

   413     this->setstate(std::ios_base::failbit);

   414   else

   415     this->clear();

   416 }

   417 

   418 // Close file

   419 void

   420 gzifstream::close()

   421 {

   422   if (!sb.close())

   423     this->setstate(std::ios_base::failbit);

   424 }

   425 

   426 /*****************************************************************************/

   427 

   428 // Default constructor initializes stream buffer

   429 gzofstream::gzofstream()

   430 : std::ostream(NULL), sb()

   431 { this->init(&sb); }

   432 

   433 // Initialize stream buffer and open file

   434 gzofstream::gzofstream(const char* name,

   435                        std::ios_base::openmode mode)

   436 : std::ostream(NULL), sb()

   437 {

   438   this->init(&sb);

   439   this->open(name, mode);

   440 }

   441 

   442 // Initialize stream buffer and attach to file

   443 gzofstream::gzofstream(int fd,

   444                        std::ios_base::openmode mode)

   445 : std::ostream(NULL), sb()

   446 {

   447   this->init(&sb);

   448   this->attach(fd, mode);

   449 }

   450 

   451 // Open file and go into fail() state if unsuccessful

   452 void

   453 gzofstream::open(const char* name,

   454                  std::ios_base::openmode mode)

   455 {

   456   if (!sb.open(name, mode | std::ios_base::out))

   457     this->setstate(std::ios_base::failbit);

   458   else

   459     this->clear();

   460 }

   461 

   462 // Attach to file and go into fail() state if unsuccessful

   463 void

   464 gzofstream::attach(int fd,

   465                    std::ios_base::openmode mode)

   466 {

   467   if (!sb.attach(fd, mode | std::ios_base::out))

   468     this->setstate(std::ios_base::failbit);

   469   else

   470     this->clear();

   471 }

   472 

   473 // Close file

   474 void

   475 gzofstream::close()

   476 {

   477   if (!sb.close())

   478     this->setstate(std::ios_base::failbit);

   479 }