modules/compress/compress.c File Reference

#include <string.h>
#include <errno.h>
#include <zlib.h>
#include "lib/eggdrop/module.h"
#include "compress.h"
#include "tclcompress.c"

Go to the source code of this file.

Defines
#define	MODULE_NAME   "compress"
#define	MAKING_COMPRESS
#define	start   compress_LTX_start
#define	BUFLEN   512
Functions
static int	uncompress_to_file (char *f_src, char *f_target)
static int	compress_to_file (char *f_src, char *f_target, int mode_num)
static int	compress_file (char *filename, int mode_num)
static int	uncompress_file (char *filename)
static int	is_compressedfile (char *filename)
static void	adjust_mode_num (int *mode)
static int	compress_report (int idx, int details)
static char *	compress_close ()
EXPORT_SCOPE char *	start ()
char *	start (eggdrop_t *eggdrop)
Variables
static const char	rcsid [] = "$Id: compress.c,v 1.10 2003-12-11 00:49:10 wcc Exp $"
static eggdrop_t *	egg = NULL
static unsigned int	compressed_files
static unsigned int	uncompressed_files
static unsigned int	compress_level
static tcl_ints	my_tcl_ints []
static Function	compress_table []

---

Define Documentation

#define BUFLEN   512

Definition at line 50 of file compress.c.

Referenced by compress_to_file(), and uncompress_to_file().

#define MAKING_COMPRESS

Definition at line 33 of file compress.c.

#define MODULE_NAME   "compress"

Definition at line 32 of file compress.c.

#define start   compress_LTX_start

Definition at line 48 of file compress.c.

---

Function Documentation

static void adjust_mode_num

(

int *

mode

)

[inline, static]

Definition at line 178 of file compress.c.

Referenced by compress_to_file().

{
  if (*mode > 9)
    *mode = 9;
  else if (*mode < 0)
    *mode = 0;
}

static char* compress_close

(

)

[static]

Definition at line 359 of file compress.c.

References MODULE_NAME, my_tcl_cmds, and NULL.

{
  rem_help_reference("compress.help");
  rem_tcl_commands(my_tcl_cmds);
  rem_tcl_ints(my_tcl_ints);
  module_undepend(MODULE_NAME);
  return NULL;
}

static int compress_file	(	char *	filename,
		int	mode_num
	)			[static]

Definition at line 289 of file compress.c.

References COMPF_SUCCESS, compress_to_file, and movefile().

{
  char *temp_fn, randstr[5];
  int   ret;

  /* Create temporary filename. */
  temp_fn = malloc(strlen(filename) + 5);
  make_rand_str(randstr, 4);
  strcpy(temp_fn, filename);
  strcat(temp_fn, randstr);

  /* Compress file. */
  ret = compress_to_file(filename, temp_fn, mode_num);

  /* Overwrite old file with compressed version.  Only do so
   * if the compression routine succeeded.
   */
  if (ret == COMPF_SUCCESS)
    movefile(temp_fn, filename);

  free(temp_fn);
  return ret;
}

static int compress_report	(	int	idx,
		int	details
	)			[static]

Definition at line 348 of file compress.c.

References compressed_files, P_, and uncompressed_files.

{
  if (details) {
    dprintf(idx, P_("    Compressed %u file,", "    Compressed %u files,",
                    compressed_files), compressed_files);
    dprintf(idx, P_(" uncompressed %u file.\n", " uncompressed %u files.\n",
                    uncompressed_files), uncompressed_files);
  }
  return 0;
}

static int compress_to_file	(	char *	f_src,
		char *	f_target,
		int	mode_num
	)			[static]

Definition at line 221 of file compress.c.

References _, adjust_mode_num(), BUFLEN, COMPF_ERROR, COMPF_SUCCESS, compressed_files, is_file(), LOG_MISC, and putlog().

{
  char  buf[BUFLEN], mode[5];
  FILE *fin, *fout;
  int   len;

  adjust_mode_num(&mode_num);
  snprintf(mode, sizeof mode, "wb%d", mode_num);

  if (!is_file(f_src)) {
    putlog(LOG_MISC, "*", _("Failed to compress file `%s': not a file."),
     f_src);
    return COMPF_ERROR;
  }
  fin = fopen(f_src, "rb");
  if (!fin) {
    putlog(LOG_MISC, "*", _("Failed to compress file `%1$s': open failed: %2$s."),
     f_src, strerror(errno));
    return COMPF_ERROR;
  }

  fout = gzopen(f_target, mode);
  if (!fout) {
    putlog(LOG_MISC, "*", _("Failed to compress file `%s': gzopen failed."),
     f_src);
    return COMPF_ERROR;
  }

#ifdef HAVE_MMAP
  if (compress_to_file_mmap(fout, fin) == COMPF_SUCCESS) {
    compressed_files++;
    return COMPF_SUCCESS;
  } else {
    /* To be on the safe side, close the file before attempting
     * to write again.
     */
    gzclose(fout);
    fout = gzopen(f_target, mode);
  }
#endif /* HAVE_MMAP */

  while (1) {
    len = fread(buf, 1, sizeof(buf), fin);
    if (ferror(fin)) {
      putlog(LOG_MISC, "*", _("Failed to compress file `%1$s': fread failed: %2$s"),
       f_src, strerror(errno));
      return COMPF_ERROR;
    }
    if (!len)
      break;
    if (gzwrite(fout, buf, (unsigned int) len) != len) {
      putlog(LOG_MISC, "*", _("Failed to compress file `%s': gzwrite failed."),
       f_src);
      return COMPF_ERROR;
    }
  }
  fclose(fin);
  if (gzclose(fout) != Z_OK) {
    putlog(LOG_MISC, "*", _("Failed to compress file `%s': gzclose failed."),
     f_src);
    return COMPF_ERROR;
  }
  compressed_files++;
  return COMPF_SUCCESS;
}

static int is_compressedfile

(

char *

filename

)

[static]

Definition at line 73 of file compress.c.

References COMPF_COMPRESSED, COMPF_FAILED, COMPF_UNCOMPRESSED, and is_file().

{
  char      buf1[50], buf2[50];
  FILE     *fin;
  register int    len1, len2, i;

  memset(buf1, 0, 50);
  memset(buf2, 0, 50);
  if (!is_file(filename))
    return COMPF_FAILED;

  /* Read data with zlib routines.
   */
  fin = gzopen(filename, "rb");
  if (!fin)
    return COMPF_FAILED;
  len1 = gzread(fin, buf1, sizeof(buf1));
  if (len1 < 0)
    return COMPF_FAILED;
  if (gzclose(fin) != Z_OK)
    return COMPF_FAILED;

  /* Read raw data.
   */
  fin = fopen(filename, "rb");
  if (!fin)
    return COMPF_FAILED;
  len2 = fread(buf2, 1, sizeof(buf2), fin);
  if (ferror(fin))
    return COMPF_FAILED;
  fclose(fin);

  /* Compare what we found.
   */
  if (len1 != len2)
    return COMPF_COMPRESSED;
  for (i = 0; i < sizeof(buf1); i++)
    if (buf1[i] != buf2[i])
      return COMPF_COMPRESSED;
  return COMPF_UNCOMPRESSED;
}

char* start

(

eggdrop_t *

eggdrop

)

Definition at line 386 of file compress.c.

References _, compress_level, compressed_files, egg, MODULE_NAME, my_tcl_cmds, NULL, and uncompressed_files.

{
  egg = eggdrop;
  compressed_files  = 0;
  uncompressed_files  = 0;
  compress_level  = 9;

  module_register(MODULE_NAME, compress_table, 1, 1);
  if (!module_depend(MODULE_NAME, "eggdrop", 107, 0)) {
    module_undepend(MODULE_NAME);
    return _("This module needs eggdrop1.7.0 or later");
  }
  add_tcl_ints(my_tcl_ints);
  add_tcl_commands(my_tcl_cmds);
  add_help_reference("compress.help");
  return NULL;
}

EXPORT_SCOPE char* start

(

)

static int uncompress_file

(

char *

filename

)

[static]

Definition at line 315 of file compress.c.

References COMPF_SUCCESS, movefile(), and uncompress_to_file.

{
  char *temp_fn, randstr[5];
  int   ret;

  /* Create temporary filename. */
  temp_fn = malloc(strlen(filename) + 5);
  make_rand_str(randstr, 4);
  strcpy(temp_fn, filename);
  strcat(temp_fn, randstr);

  /* Uncompress file. */
  ret = uncompress_to_file(filename, temp_fn);

  /* Overwrite old file with uncompressed version.  Only do so
   * if the uncompression routine succeeded.
   */
  if (ret == COMPF_SUCCESS)
    movefile(temp_fn, filename);

  free(temp_fn);
  return ret;
}

static int uncompress_to_file	(	char *	f_src,
		char *	f_target
	)			[static]

Definition at line 122 of file compress.c.

References _, BUFLEN, COMPF_ERROR, COMPF_SUCCESS, is_file(), LOG_MISC, putlog(), and uncompressed_files.

{
  char buf[BUFLEN];
  int len;
  FILE *fin, *fout;

  if (!is_file(f_src)) {
    putlog(LOG_MISC, "*", _("Failed to uncompress file `%s': not a file."),
     f_src);
    return COMPF_ERROR;
  }
  fin = gzopen(f_src, "rb");
  if (!fin) {
    putlog(LOG_MISC, "*", _("Failed to uncompress file `%s': gzopen failed."),
     f_src);
    return COMPF_ERROR;
  }

  fout = fopen(f_target, "wb");
  if (!fout) {
    putlog(LOG_MISC, "*", _("Failed to uncompress file `%1$s': open failed: %2$s."),
     f_src, strerror(errno));
    return COMPF_ERROR;
  }

  while (1) {
    len = gzread(fin, buf, sizeof(buf));
    if (len < 0) {
      putlog(LOG_MISC, "*", _("Failed to uncompress file `%s': gzread failed."),
       f_src);
      return COMPF_ERROR;
    }
    if (!len)
      break;
    if ((int) fwrite(buf, 1, (unsigned int) len, fout) != len) {
      putlog(LOG_MISC, "*", _("Failed to uncompress file `%1$s': fwrite failed: %2$s."),
       f_src, strerror(errno));
      return COMPF_ERROR;
    }
  }
  if (fclose(fout)) {
    putlog(LOG_MISC, "*", _("Failed to uncompress file `%1$s': fclose failed: %2$s."),
     f_src, strerror(errno));
    return COMPF_ERROR;
  }
  if (gzclose(fin) != Z_OK) {
    putlog(LOG_MISC, "*", _("Failed to uncompress file `%s': gzclose failed."),
     f_src);
    return COMPF_ERROR;
  }
  uncompressed_files++;
  return COMPF_SUCCESS;
}

---

Variable Documentation

unsigned int compress_level [static]

Definition at line 57 of file compress.c.

Referenced by start(), and tcl_compress_file().

Function compress_table[] [static]

Initial value:

{
  
  (Function) start,
  (Function) compress_close,
  (Function) 0,
  (Function) compress_report,
  
  (Function) compress_to_file,
  (Function) compress_file,
  (Function) uncompress_to_file,
  (Function) uncompress_file,
  
  (Function) is_compressedfile,
}

Definition at line 370 of file compress.c.

unsigned int compressed_files [static]

Definition at line 55 of file compress.c.

Referenced by compress_report(), compress_to_file(), and start().

eggdrop_t* egg = NULL [static]

Definition at line 53 of file compress.c.

tcl_ints my_tcl_ints[] [static]

Initial value:

 {
  {"compress_level",    &compress_level},
  {NULL,                  NULL}
}

Definition at line 343 of file compress.c.

Referenced by channels_close(), and start().

const char rcsid[] = "$Id: compress.c,v 1.10 2003-12-11 00:49:10 wcc Exp $" [static]

Definition at line 29 of file compress.c.

unsigned int uncompressed_files [static]

Definition at line 56 of file compress.c.

Referenced by compress_report(), start(), and uncompress_to_file().