[BACK]Return to compress.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/Attic/compress.c between version 1.1 and 1.2

version 1.1, 1999/09/26 20:53:34 version 1.2, 1999/11/23 22:25:53
Line 23 
Line 23 
 static z_stream incoming_stream;  static z_stream incoming_stream;
 static z_stream outgoing_stream;  static z_stream outgoing_stream;
   
 /* Initializes compression; level is compression level from 1 to 9 (as in  /* Initializes compression; level is compression level from 1 to 9
    gzip). */     (as in gzip). */
   
 void buffer_compress_init(int level)  void
   buffer_compress_init(int level)
 {  {
   debug("Enabling compression at level %d.", level);          debug("Enabling compression at level %d.", level);
   if (level < 1 || level > 9)          if (level < 1 || level > 9)
     fatal("Bad compression level %d.", level);                  fatal("Bad compression level %d.", level);
   inflateInit(&incoming_stream);          inflateInit(&incoming_stream);
   deflateInit(&outgoing_stream, level);          deflateInit(&outgoing_stream, level);
 }  }
   
 /* Frees any data structures allocated for compression. */  /* Frees any data structures allocated for compression. */
   
 void buffer_compress_uninit()  void
   buffer_compress_uninit()
 {  {
   debug("compress outgoing: raw data %lu, compressed %lu, factor %.2f",          debug("compress outgoing: raw data %lu, compressed %lu, factor %.2f",
         outgoing_stream.total_in, outgoing_stream.total_out,                outgoing_stream.total_in, outgoing_stream.total_out,
         outgoing_stream.total_in == 0 ? 0.0 :                outgoing_stream.total_in == 0 ? 0.0 :
          (double)outgoing_stream.total_out / outgoing_stream.total_in);                (double) outgoing_stream.total_out / outgoing_stream.total_in);
   debug("compress incoming: raw data %lu, compressed %lu, factor %.2f",          debug("compress incoming: raw data %lu, compressed %lu, factor %.2f",
         incoming_stream.total_out, incoming_stream.total_in,                incoming_stream.total_out, incoming_stream.total_in,
         incoming_stream.total_out == 0 ? 0.0 :                incoming_stream.total_out == 0 ? 0.0 :
           (double)incoming_stream.total_in / incoming_stream.total_out);                (double) incoming_stream.total_in / incoming_stream.total_out);
   inflateEnd(&incoming_stream);          inflateEnd(&incoming_stream);
   deflateEnd(&outgoing_stream);          deflateEnd(&outgoing_stream);
 }  }
   
 /* Compresses the contents of input_buffer into output_buffer.  All  /* Compresses the contents of input_buffer into output_buffer.  All
Line 59 
Line 61 
    form a single compression stream) by the receiver.  This appends     form a single compression stream) by the receiver.  This appends
    the compressed data to the output buffer. */     the compressed data to the output buffer. */
   
 void buffer_compress(Buffer *input_buffer, Buffer *output_buffer)  void
   buffer_compress(Buffer * input_buffer, Buffer * output_buffer)
 {  {
   char buf[4096];          char buf[4096];
   int status;          int status;
   
   /* This case is not handled below. */          /* This case is not handled below. */
   if (buffer_len(input_buffer) == 0)          if (buffer_len(input_buffer) == 0)
     return;                  return;
   
   /* Input is the contents of the input buffer. */          /* Input is the contents of the input buffer. */
   outgoing_stream.next_in = buffer_ptr(input_buffer);          outgoing_stream.next_in = buffer_ptr(input_buffer);
   outgoing_stream.avail_in = buffer_len(input_buffer);          outgoing_stream.avail_in = buffer_len(input_buffer);
   
   /* Loop compressing until deflate() returns with avail_out != 0. */          /* Loop compressing until deflate() returns with avail_out != 0. */
   do          do {
     {                  /* Set up fixed-size output buffer. */
       /* Set up fixed-size output buffer. */                  outgoing_stream.next_out = buf;
       outgoing_stream.next_out = buf;                  outgoing_stream.avail_out = sizeof(buf);
       outgoing_stream.avail_out = sizeof(buf);  
   
       /* Compress as much data into the buffer as possible. */                  /* Compress as much data into the buffer as possible. */
       status = deflate(&outgoing_stream, Z_PARTIAL_FLUSH);                  status = deflate(&outgoing_stream, Z_PARTIAL_FLUSH);
       switch (status)                  switch (status) {
         {                  case Z_OK:
         case Z_OK:                          /* Append compressed data to output_buffer. */
           /* Append compressed data to output_buffer. */                          buffer_append(output_buffer, buf,
           buffer_append(output_buffer, buf,                                        sizeof(buf) - outgoing_stream.avail_out);
                         sizeof(buf) - outgoing_stream.avail_out);                          break;
           break;                  case Z_STREAM_END:
         case Z_STREAM_END:                          fatal("buffer_compress: deflate returned Z_STREAM_END");
           fatal("buffer_compress: deflate returned Z_STREAM_END");                          /* NOTREACHED */
           /*NOTREACHED*/                  case Z_STREAM_ERROR:
         case Z_STREAM_ERROR:                          fatal("buffer_compress: deflate returned Z_STREAM_ERROR");
           fatal("buffer_compress: deflate returned Z_STREAM_ERROR");                          /* NOTREACHED */
           /*NOTREACHED*/                  case Z_BUF_ERROR:
         case Z_BUF_ERROR:                          fatal("buffer_compress: deflate returned Z_BUF_ERROR");
           fatal("buffer_compress: deflate returned Z_BUF_ERROR");                          /* NOTREACHED */
           /*NOTREACHED*/                  default:
         default:                          fatal("buffer_compress: deflate returned %d", status);
           fatal("buffer_compress: deflate returned %d", status);                          /* NOTREACHED */
           /*NOTREACHED*/                  }
         }          }
     }          while (outgoing_stream.avail_out == 0);
   while (outgoing_stream.avail_out == 0);  
 }  }
   
 /* Uncompresses the contents of input_buffer into output_buffer.  All  /* Uncompresses the contents of input_buffer into output_buffer.  All
Line 113 
Line 114 
    same order that buffers compressed with that.  This appends the     same order that buffers compressed with that.  This appends the
    uncompressed data to the output buffer. */     uncompressed data to the output buffer. */
   
 void buffer_uncompress(Buffer *input_buffer, Buffer *output_buffer)  void
   buffer_uncompress(Buffer * input_buffer, Buffer * output_buffer)
 {  {
   char buf[4096];          char buf[4096];
   int status;          int status;
   
   incoming_stream.next_in = buffer_ptr(input_buffer);          incoming_stream.next_in = buffer_ptr(input_buffer);
   incoming_stream.avail_in = buffer_len(input_buffer);          incoming_stream.avail_in = buffer_len(input_buffer);
   
   incoming_stream.next_out = buf;          incoming_stream.next_out = buf;
   incoming_stream.avail_out = sizeof(buf);          incoming_stream.avail_out = sizeof(buf);
   
   for (;;)          for (;;) {
     {                  status = inflate(&incoming_stream, Z_PARTIAL_FLUSH);
       status = inflate(&incoming_stream, Z_PARTIAL_FLUSH);                  switch (status) {
       switch (status)                  case Z_OK:
         {                          buffer_append(output_buffer, buf,
         case Z_OK:                                        sizeof(buf) - incoming_stream.avail_out);
           buffer_append(output_buffer, buf,                          incoming_stream.next_out = buf;
                         sizeof(buf) - incoming_stream.avail_out);                          incoming_stream.avail_out = sizeof(buf);
           incoming_stream.next_out = buf;                          break;
           incoming_stream.avail_out = sizeof(buf);                  case Z_STREAM_END:
           break;                          fatal("buffer_uncompress: inflate returned Z_STREAM_END");
         case Z_STREAM_END:                          /* NOTREACHED */
           fatal("buffer_uncompress: inflate returned Z_STREAM_END");                  case Z_DATA_ERROR:
           /*NOTREACHED*/                          fatal("buffer_uncompress: inflate returned Z_DATA_ERROR");
         case Z_DATA_ERROR:                          /* NOTREACHED */
           fatal("buffer_uncompress: inflate returned Z_DATA_ERROR");                  case Z_STREAM_ERROR:
           /*NOTREACHED*/                          fatal("buffer_uncompress: inflate returned Z_STREAM_ERROR");
         case Z_STREAM_ERROR:                          /* NOTREACHED */
           fatal("buffer_uncompress: inflate returned Z_STREAM_ERROR");                  case Z_BUF_ERROR:
           /*NOTREACHED*/                          /* Comments in zlib.h say that we should keep
         case Z_BUF_ERROR:                             calling inflate() until we get an error.  This
           /* Comments in zlib.h say that we should keep calling inflate()                             appears to be the error that we get. */
              until we get an error.  This appears to be the error that we                          return;
              get. */                  case Z_MEM_ERROR:
           return;                          fatal("buffer_uncompress: inflate returned Z_MEM_ERROR");
         case Z_MEM_ERROR:                          /* NOTREACHED */
           fatal("buffer_uncompress: inflate returned Z_MEM_ERROR");                  default:
           /*NOTREACHED*/                          fatal("buffer_uncompress: inflate returned %d", status);
         default:                  }
           fatal("buffer_uncompress: inflate returned %d", status);  
         }          }
     }  
 }  }
   
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.2