src/mod/compress.mod/compress.c File Reference

#include <string.h>
#include <errno.h>
#include <zlib.h>
#include "src/mod/module.h"
#include "share.mod/share.h"
#include "compress.h"
#include "tclcompress.c"

Include dependency graph for compress.c:

Go to the source code of this file.

Defines
#define	MODULE_NAME   "compress"
#define	MAKING_COMPRESS
#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	uff_comp (int idx, char *filename)
static int	uff_uncomp (int idx, char *filename)
static int	uff_ask_compress (int idx)
static int	compress_expmem (void)
static int	compress_report (int idx, int details)
static char *	compress_close ()
EXPORT_SCOPE char *	compress_start ()
char *	compress_start (Function *global_funcs)
Variables
static Function *	global = 0
static Function *	share_funcs = 0
static unsigned int	compressed_files
static unsigned int	uncompressed_files
static unsigned int	share_compressed
static unsigned int	compress_level
static uff_table_t	compress_uff_table []
static tcl_ints	my_tcl_ints []
static Function	compress_table []

---

Define Documentation

#define BUFLEN   512

Definition at line 48 of file compress.c.

Referenced by compress_to_file(), and uncompress_to_file().

#define MAKING_COMPRESS

Definition at line 30 of file compress.c.

#define MODULE_NAME   "compress"

Definition at line 29 of file compress.c.

---

Function Documentation

static void adjust_mode_num

(

int *

mode

)

[inline, static]

Definition at line 176 of file compress.c.

Referenced by compress_to_file().

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

Here is the caller graph for this function:

static char* compress_close

(

)

[static]

Definition at line 396 of file compress.c.

References MODULE_NAME, module_undepend, NULL, rem_help_reference, rem_tcl_commands, rem_tcl_ints, and uff_deltable().

{
  rem_help_reference("compress.help");
  rem_tcl_commands(my_tcl_cmds);
  rem_tcl_ints(my_tcl_ints);
  uff_deltable(compress_uff_table);

  module_undepend(MODULE_NAME);
  return NULL;
}

Here is the call graph for this function:

static int compress_expmem

(

void

)

[static]

Definition at line 376 of file compress.c.

Referenced by compress_report().

{
  return 0;
}

Here is the caller graph for this function:

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

Definition at line 286 of file compress.c.

References COMPF_SUCCESS, compress_to_file(), make_rand_str, movefile, nfree, and nmalloc.

Referenced by uff_comp().

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

  /* Create temporary filename. */
  temp_fn = nmalloc(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);

  nfree(temp_fn);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 381 of file compress.c.

References compress_expmem(), compressed_files, dprintf, and uncompressed_files.

{
  if (details) {
    int size = compress_expmem();

    dprintf(idx, "    %u file%s compressed\n", compressed_files,
            (compressed_files != 1) ? "s" : "");
    dprintf(idx, "    %u file%s uncompressed\n", uncompressed_files,
            (uncompressed_files != 1) ? "s" : "");
    dprintf(idx, "    Using %d byte%s of memory\n", size,
            (size != 1) ? "s" : "");
  }
  return 0;
}

Here is the call graph for this function:

char* compress_start

(

Function *

global_funcs

)

Definition at line 424 of file compress.c.

References add_help_reference, add_tcl_commands, add_tcl_ints, compress_level, compressed_files, global, module_depend, MODULE_NAME, module_register, module_undepend, NULL, share_compressed, share_funcs, uff_addtable(), and uncompressed_files.

{
  global = global_funcs;

  compressed_files = 0;
  uncompressed_files = 0;
  share_compressed = 0;
  compress_level = 9;

  module_register(MODULE_NAME, compress_table, 1, 1);
  if (!module_depend(MODULE_NAME, "eggdrop", 106, 0)) {
    module_undepend(MODULE_NAME);
    return "This module requires Eggdrop 1.6.0 or later.";
  }

  share_funcs = module_depend(MODULE_NAME, "share", 2, 3);
  if (!share_funcs) {
    module_undepend(MODULE_NAME);
    return "This module requires share module 2.3 or later.";
  }

  uff_addtable(compress_uff_table);
  add_tcl_ints(my_tcl_ints);
  add_tcl_commands(my_tcl_cmds);
  add_help_reference("compress.help");
  return NULL;
}

Here is the call graph for this function:

EXPORT_SCOPE char* compress_start

(

)

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

Definition at line 219 of file compress.c.

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

Referenced by compress_file().

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

  adjust_mode_num(&mode_num);
  egg_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 `%s': open failed: %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 `%s': fread failed: %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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int is_compressedfile

(

char *

filename

)

[static]

Definition at line 72 of file compress.c.

References COMPF_COMPRESSED, COMPF_FAILED, COMPF_UNCOMPRESSED, egg_memset, and is_file.

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

  egg_memset(buf1, 0, 50);
  egg_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;
}

static int uff_ask_compress

(

int

idx

)

[static]

Definition at line 353 of file compress.c.

References share_compressed.

{
  if (share_compressed)
    return 1;
  else
    return 0;
}

static int uff_comp	(	int	idx,
		char *	filename
	)			[static]

Definition at line 341 of file compress.c.

References compress_file(), compress_level, dcc, and debug1.

{
  debug1("Compressing user file for %s.", dcc[idx].nick);
  return compress_file(filename, compress_level);
}

Here is the call graph for this function:

static int uff_uncomp	(	int	idx,
		char *	filename
	)			[static]

Definition at line 347 of file compress.c.

References dcc, debug1, and uncompress_file().

{
  debug1("Uncompressing user file from %s.", dcc[idx].nick);
  return uncompress_file(filename);
}

Here is the call graph for this function:

static int uncompress_file

(

char *

filename

)

[static]

Definition at line 312 of file compress.c.

References COMPF_SUCCESS, make_rand_str, movefile, nfree, nmalloc, and uncompress_to_file().

Referenced by uff_uncomp().

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

  /* Create temporary filename. */
  temp_fn = nmalloc(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);

  nfree(temp_fn);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 121 of file compress.c.

References BUFLEN, COMPF_ERROR, COMPF_SUCCESS, is_file, LOG_MISC, putlog, and uncompressed_files.

Referenced by uncompress_file().

{
  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 `%s': open failed: %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 `%s': fwrite "
             "failed: %s.", f_src, strerror(errno));
      return COMPF_ERROR;
    }
  }
  if (fclose(fout)) {
    putlog(LOG_MISC, "*", "Failed to uncompress file `%s': fclose failed: %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;
}

Here is the caller graph for this function:

---

Variable Documentation

unsigned int compress_level [static]

Definition at line 56 of file compress.c.

Referenced by compress_start(), and uff_comp().

Function compress_table[] [static]

Initial value:

 {
  
  (Function) compress_start,
  (Function) compress_close,
  (Function) compress_expmem,
  (Function) compress_report,
  
  (Function) compress_to_file,
  (Function) compress_file,
  (Function) uncompress_to_file,
  (Function) uncompress_file,
  
  (Function) is_compressedfile,
}

Definition at line 409 of file compress.c.

uff_table_t compress_uff_table[] [static]

Initial value:

 {
  {"compress", UFF_COMPRESS, uff_ask_compress, 100, uff_comp, uff_uncomp},
  { 0 ,       0,             0 ,             0,    0 ,            0 }
}

Definition at line 361 of file compress.c.

unsigned int compressed_files [static]

Definition at line 53 of file compress.c.

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

Function* global = 0 [static]

Definition at line 51 of file compress.c.

tcl_ints my_tcl_ints[] [static]

Initial value:

 {
  {"share-compressed", (int *)&share_compressed},
  {"compress-level",     (int *)&compress_level},
  { 0 ,                                    0 }
}

Definition at line 370 of file compress.c.

unsigned int share_compressed [static]

Definition at line 55 of file compress.c.

Referenced by compress_start(), and uff_ask_compress().

Function * share_funcs = 0 [static]

Definition at line 51 of file compress.c.

Referenced by compress_start().

unsigned int uncompressed_files [static]

Definition at line 54 of file compress.c.

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