src/ngircd/conn-zip.c

   1 /*
   2  * ngIRCd -- The Next Generation IRC Daemon
   3  * Copyright (c)2001-2014 Alexander Barton (alex@barton.de) and Contributors.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  * Please read the file COPYING, README and AUTHORS for more information.
  10  */
  11
  12 #define CONN_MODULE
  13
  14 #include "portab.h"
  15
  16 /**
  17  * @file
  18  * Connection compression using ZLIB
  19  */
  20
  21 /* Additionan debug messages related to ZIP compression: 0=off / 1=on */
  22 #define DEBUG_ZIP 0
  23
  24 #ifdef ZLIB
  25
  26 #include <assert.h>
  27 #include <string.h>
  28 #include <zlib.h>
  29
  30 #include "conn.h"
  31 #include "conn-func.h"
  32 #include "log.h"
  33 #include "array.h"
  34
  35 #include "conn-zip.h"
  36
  37
  38 GLOBAL bool
  39 Zip_InitConn( CONN_ID Idx )
  40 {
  41         /* initialize zlib compression on this link */
  42
  43         assert( Idx > NONE );
  44
  45         My_Connections[Idx].zip.in.avail_in = 0;
  46         My_Connections[Idx].zip.in.total_in = 0;
  47         My_Connections[Idx].zip.in.total_out = 0;
  48         My_Connections[Idx].zip.in.zalloc = NULL;
  49         My_Connections[Idx].zip.in.zfree = NULL;
  50         My_Connections[Idx].zip.in.data_type = Z_ASCII;
  51
  52         if (inflateInit( &My_Connections[Idx].zip.in ) != Z_OK) {
  53                 Log(LOG_ALERT, "Can't initialize compression on connection %d (zlib inflate)!", Idx);
  54                 return false;
  55         }
  56
  57         My_Connections[Idx].zip.out.total_in = 0;
  58         My_Connections[Idx].zip.out.total_in = 0;
  59         My_Connections[Idx].zip.out.zalloc = NULL;
  60         My_Connections[Idx].zip.out.zfree = NULL;
  61         My_Connections[Idx].zip.out.data_type = Z_ASCII;
  62
  63         if (deflateInit( &My_Connections[Idx].zip.out, Z_DEFAULT_COMPRESSION ) != Z_OK) {
  64                 Log(LOG_ALERT, "Can't initialize compression on connection %d (zlib deflate)!", Idx);
  65                 return false;
  66         }
  67
  68         My_Connections[Idx].zip.bytes_in = My_Connections[Idx].bytes_in;
  69         My_Connections[Idx].zip.bytes_out = My_Connections[Idx].bytes_out;
  70
  71         Log(LOG_INFO, "Enabled link compression (zlib) on connection %d.", Idx);
  72         Conn_OPTION_ADD( &My_Connections[Idx], CONN_ZIP );
  73
  74         return true;
  75 } /* Zip_InitConn */
  76
  77
  78 /**
  79  * Copy data to the compression buffer of a connection. We do collect
  80  * some data there until it's full so that we can achieve better
  81  * compression ratios.
  82  * If the (pre-)compression buffer is full, we try to flush it ("actually
  83  * compress some data") and to add the new (uncompressed) data afterwards.
  84  * This function closes the connection on error.
  85  * @param Idx Connection handle.
  86  * @param Data Pointer to the data.
  87  * @param Len Length of the data to add.
  88  * @return true on success, false otherwise.
  89  */
  90 GLOBAL bool
  91 Zip_Buffer( CONN_ID Idx, const char *Data, size_t Len )
  92 {
  93         size_t buflen;
  94
  95         assert( Idx > NONE );
  96         assert( Data != NULL );
  97         assert( Len > 0 );
  98
  99         buflen = array_bytes(&My_Connections[Idx].zip.wbuf);
 100         if (buflen + Len >= WRITEBUFFER_SLINK_LEN) {
 101                 /* compression buffer is full, flush */
 102                 if( ! Zip_Flush( Idx )) return false;
 103         }
 104
 105         /* check again; if zip buf is still too large do not append data:
 106          * otherwise the zip wbuf would grow too large */
 107         buflen = array_bytes(&My_Connections[Idx].zip.wbuf);
 108         if (buflen + Len >= WRITEBUFFER_SLINK_LEN) {
 109                 Log(LOG_ALERT, "Zip Write buffer space exhausted: %lu bytes", buflen + Len);
 110                 Conn_Close(Idx, "Zip Write buffer space exhausted", NULL, false);
 111                 return false;
 112         }
 113         return array_catb(&My_Connections[Idx].zip.wbuf, Data, Len);
 114 } /* Zip_Buffer */
 115
 116
 117 /**
 118  * Compress data in ZIP buffer and move result to the write buffer of
 119  * the connection.
 120  * This function closes the connection on error.
 121  * @param Idx Connection handle.
 122  * @return true on success, false otherwise.
 123  */
 124 GLOBAL bool
 125 Zip_Flush( CONN_ID Idx )
 126 {
 127         int result;
 128         unsigned char zipbuf[WRITEBUFFER_SLINK_LEN];
 129         int zipbuf_used = 0;
 130         z_stream *out;
 131
 132         out = &My_Connections[Idx].zip.out;
 133
 134         out->avail_in = (uInt)array_bytes(&My_Connections[Idx].zip.wbuf);
 135         if (!out->avail_in)
 136                 return true;    /* nothing to do. */
 137
 138         out->next_in = array_start(&My_Connections[Idx].zip.wbuf);
 139         assert(out->next_in != NULL);
 140
 141         out->next_out = zipbuf;
 142         out->avail_out = (uInt)sizeof zipbuf;
 143
 144 #if DEBUG_ZIP
 145         Log(LOG_DEBUG, "out->avail_in %d, out->avail_out %d",
 146                 out->avail_in, out->avail_out);
 147 #endif
 148         result = deflate( out, Z_SYNC_FLUSH );
 149         if(( result != Z_OK ) || ( out->avail_in > 0 ))
 150         {
 151                 Log( LOG_ALERT, "Compression error: code %d!?", result );
 152                 Conn_Close( Idx, "Compression error!", NULL, false );
 153                 return false;
 154         }
 155
 156         if (out->avail_out <= 0) {
 157                 /* Not all data was compressed, because data became
 158                  * bigger while compressing it. */
 159                 Log(LOG_ALERT, "Compression error: buffer overflow!?");
 160                 Conn_Close(Idx, "Compression error!", NULL, false);
 161                 return false;
 162         }
 163
 164         assert(out->avail_out <= WRITEBUFFER_SLINK_LEN);
 165
 166         zipbuf_used = WRITEBUFFER_SLINK_LEN - out->avail_out;
 167 #if DEBUG_ZIP
 168         Log(LOG_DEBUG, "zipbuf_used: %d", zipbuf_used);
 169 #endif
 170         if (!array_catb(&My_Connections[Idx].wbuf,
 171                         (char *)zipbuf, (size_t) zipbuf_used)) {
 172                 Log (LOG_ALERT, "Compression error: can't copy data!?");
 173                 Conn_Close(Idx, "Compression error!", NULL, false);
 174                 return false;
 175         }
 176
 177         My_Connections[Idx].bytes_out += zipbuf_used;
 178         My_Connections[Idx].zip.bytes_out += array_bytes(&My_Connections[Idx].zip.wbuf);
 179         array_trunc(&My_Connections[Idx].zip.wbuf);
 180
 181         return true;
 182 } /* Zip_Flush */
 183
 184
 185 /**
 186  * uncompress data and copy it to read buffer.
 187  * Returns true if data has been unpacked or no
 188  * compressed data is currently pending in the zread buffer.
 189  * This function closes the connection on error.
 190  * @param Idx Connection handle.
 191  * @return true on success, false otherwise.
 192  */
 193 GLOBAL bool
 194 Unzip_Buffer( CONN_ID Idx )
 195 {
 196         int result;
 197         unsigned char unzipbuf[READBUFFER_LEN];
 198         int unzipbuf_used = 0;
 199         unsigned int z_rdatalen;
 200         unsigned int in_len;
 201
 202         z_stream *in;
 203
 204         assert( Idx > NONE );
 205
 206         z_rdatalen = (unsigned int)array_bytes(&My_Connections[Idx].zip.rbuf);
 207         if (z_rdatalen == 0)
 208                 return true;
 209
 210         in = &My_Connections[Idx].zip.in;
 211
 212         in->next_in = array_start(&My_Connections[Idx].zip.rbuf);
 213         assert(in->next_in != NULL);
 214
 215         in->avail_in = z_rdatalen;
 216         in->next_out = unzipbuf;
 217         in->avail_out = (uInt)sizeof unzipbuf;
 218
 219 #if DEBUG_ZIP
 220         Log(LOG_DEBUG, "in->avail_in %d, in->avail_out %d",
 221                 in->avail_in, in->avail_out);
 222 #endif
 223         result = inflate( in, Z_SYNC_FLUSH );
 224         if( result != Z_OK )
 225         {
 226                 Log(LOG_ALERT, "Decompression error: %s (code=%d, ni=%d, ai=%d, no=%d, ao=%d)!?", in->msg, result, in->next_in, in->avail_in, in->next_out, in->avail_out);
 227                 Conn_Close(Idx, "Decompression error!", NULL, false);
 228                 return false;
 229         }
 230
 231         assert(z_rdatalen >= in->avail_in);
 232         in_len = z_rdatalen - in->avail_in;
 233         unzipbuf_used = READBUFFER_LEN - in->avail_out;
 234 #if DEBUG_ZIP
 235         Log(LOG_DEBUG, "unzipbuf_used: %d - %d = %d", READBUFFER_LEN,
 236                 in->avail_out, unzipbuf_used);
 237 #endif
 238         assert(unzipbuf_used <= READBUFFER_LEN);
 239         if (!array_catb(&My_Connections[Idx].rbuf, (char*) unzipbuf,
 240                         (size_t)unzipbuf_used)) {
 241                 Log (LOG_ALERT, "Decompression error: can't copy data!?");
 242                 Conn_Close(Idx, "Decompression error!", NULL, false);
 243                 return false;
 244         }
 245         if( in->avail_in > 0 ) {
 246                 array_moveleft(&My_Connections[Idx].zip.rbuf, 1, in_len );
 247         } else {
 248                 array_trunc( &My_Connections[Idx].zip.rbuf );
 249                 My_Connections[Idx].zip.bytes_in += unzipbuf_used;
 250         }
 251
 252         return true;
 253 } /* Unzip_Buffer */
 254
 255
 256 /**
 257  * @param Idx Connection handle.
 258  * @return amount of sent (compressed) bytes
 259  */
 260 GLOBAL long
 261 Zip_SendBytes( CONN_ID Idx )
 262 {
 263         assert( Idx > NONE );
 264         return My_Connections[Idx].zip.bytes_out;
 265 } /* Zip_SendBytes */
 266
 267
 268 /**
 269  * @param Idx Connection handle.
 270  * @return amount of received (compressed) bytes
 271  */
 272 GLOBAL long
 273 Zip_RecvBytes( CONN_ID Idx )
 274 {
 275         assert( Idx > NONE );
 276         return My_Connections[Idx].zip.bytes_in;
 277 } /* Zip_RecvBytes */
 278
 279
 280 #endif
 281
 282
 283 /* -eof- */