zstrm.c File Reference

Zlib compression of network traffic. More...

#include "config.h"
#include <limits.h>
#include <stdbool.h>
#include <string.h>
#include <time.h>
#include <zconf.h>
#include <zlib.h>
#include "mutt/lib.h"
#include "zstrm.h"
#include "connection.h"

Include dependency graph for zstrm.c:

Go to the source code of this file.

Data Structures
struct	ZstrmDirection
	A stream of data being (de-)compressed. More...
struct	ZstrmContext
	Data compression layer. More...

Functions
static void *	zstrm_malloc (void *opaque, unsigned int items, unsigned int size)
	Redirector function for zlib's malloc().
static void	zstrm_free (void *opaque, void *address)
	Redirector function for zlib's free().
static int	zstrm_open (struct Connection *conn)
	Open a socket - Implements Connection::open() -.
static int	zstrm_close (struct Connection *conn)
	Close a socket - Implements Connection::close() -.
static int	zstrm_read (struct Connection *conn, char *buf, size_t len)
	Read compressed data from a socket - Implements Connection::read() -.
static int	zstrm_poll (struct Connection *conn, time_t wait_secs)
	Check if any data is waiting on a socket - Implements Connection::poll() -.
static int	zstrm_write (struct Connection *conn, const char *buf, size_t count)
	Write compressed data to a socket - Implements Connection::write() -.
void	mutt_zstrm_wrap_conn (struct Connection *conn)
	Wrap a compression layer around a Connection.

Detailed Description

Zlib compression of network traffic.

Authors

• Fabian Groffen
• Richard Russon
• Pietro Cerutti

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file zstrm.c.

Function Documentation

zstrm_malloc()

void * zstrm_malloc ( void * opaque, unsigned int items, unsigned int size )

static

Redirector function for zlib's malloc().

Parameters

opaque	Opaque zlib handle
items	Number of blocks
size	Size of blocks

Return values

ptr	Memory on the heap

Definition at line 72 of file zstrm.c.

{
  return mutt_mem_calloc(items, size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

zstrm_free()

void zstrm_free ( void * opaque, void * address )

static

Redirector function for zlib's free().

Parameters

opaque	Opaque zlib handle
address	Memory to free

Definition at line 82 of file zstrm.c.

{
  FREE(&address);
}

Here is the caller graph for this function:

mutt_zstrm_wrap_conn()

void mutt_zstrm_wrap_conn

(

struct Connection *

conn

)

Wrap a compression layer around a Connection.

Parameters

conn	Connection to wrap

Replace the read/write functions with our compression functions. After reading from the socket, we decompress and pass on the data. Before writing to a socket, we compress the data.

Definition at line 303 of file zstrm.c.

{
  struct ZstrmContext *zctx = MUTT_MEM_CALLOC(1, struct ZstrmContext);
 
  /* store wrapped stream as next stream */
  zctx->next_conn.fd = conn->fd;
  zctx->next_conn.sockdata = conn->sockdata;
  zctx->next_conn.open = conn->open;
  zctx->next_conn.close = conn->close;
  zctx->next_conn.read = conn->read;
  zctx->next_conn.write = conn->write;
  zctx->next_conn.poll = conn->poll;
 
  /* replace connection with our wrappers, where appropriate */
  conn->sockdata = zctx;
  conn->open = zstrm_open;
  conn->read = zstrm_read;
  conn->write = zstrm_write;
  conn->close = zstrm_close;
  conn->poll = zstrm_poll;
 
  /* allocate/setup (de)compression buffers */
  zctx->read.len = 8192;
  zctx->read.buf = MUTT_MEM_MALLOC(zctx->read.len, char);
  zctx->read.pos = 0;
  zctx->write.len = 8192;
  zctx->write.buf = MUTT_MEM_MALLOC(zctx->write.len, char);
  zctx->write.pos = 0;
 
  /* initialise zlib for inflate and deflate for RFC4978 */
  zctx->read.z.zalloc = zstrm_malloc;
  zctx->read.z.zfree = zstrm_free;
  zctx->read.z.opaque = NULL;
  zctx->read.z.avail_out = zctx->read.len;
  (void) inflateInit2(&zctx->read.z, -15);
  zctx->write.z.zalloc = zstrm_malloc;
  zctx->write.z.zfree = zstrm_free;
  zctx->write.z.opaque = NULL;
  zctx->write.z.avail_out = zctx->write.len;
  (void) deflateInit2(&zctx->write.z, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -15, 8,
                      Z_DEFAULT_STRATEGY);
}

Here is the call graph for this function:

Here is the caller graph for this function: