SDDS_lzma.c File Reference

Implementation of LZMA-compressed file handling functions. More...

#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <syslog.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdint.h>
#include <string.h>
#include <stdarg.h>
#include <lzma.h>

Go to the source code of this file.

Classes
struct	lzmafile

Macros
#define	LZMA_EASY_ENCODER(a, b)
#define	BUF_SIZE   40960

Functions
void *	lzma_open (const char *path, const char *mode)
int	lzma_close (struct lzmafile *file)
long	lzma_read (struct lzmafile *file, void *buf, size_t count)
char *	lzma_gets (char *s, int size, struct lzmafile *file)
long	lzma_write (struct lzmafile *file, const void *buf, size_t count)
int	lzma_puts (const char *s, struct lzmafile *file)
int	lzma_putc (int c, struct lzmafile *file)
int	lzma_printf (struct lzmafile *file, const char *format,...)
int	lzma_eof (struct lzmafile *file)
long	lzma_tell (struct lzmafile *file)
int	lzma_seek (struct lzmafile *file, long offset, int whence)
void *	UnpackLZMAOpen (char *filename)

Variables
static const lzma_stream	lzma_stream_init = LZMA_STREAM_INIT

Detailed Description

Implementation of LZMA-compressed file handling functions.

This file provides a set of functions to work with files compressed using the LZMA compression algorithm. It abstracts the complexities of LZMA stream handling, offering a simple file-like interface for reading from and writing to compressed files.

Features:

• Open and close LZMA-compressed files.
• Read and write data with automatic compression/decompression.
• Support for reading lines and formatted output.
• Error handling with descriptive messages.

Copyright

• (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
• (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.

License

This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.

Authors

R. Soliday

Definition in file SDDS_lzma.c.

Macro Definition Documentation

BUF_SIZE

#define BUF_SIZE   40960

Definition at line 55 of file SDDS_lzma.c.

LZMA_EASY_ENCODER

#define LZMA_EASY_ENCODER	(		a,
			b )

Value:

lzma_easy_encoder_single(a, b)

Definition at line 48 of file SDDS_lzma.c.

Function Documentation

lzma_close()

int lzma_close

(

struct lzmafile *

file

)

Definition at line 100 of file SDDS_lzma.c.

                                      {
  int ret, outsize;
  unsigned char buf[BUF_SIZE]; /* buffer used when flushing remaining
                                  output data in write mode */
  if (!file)
    return -1;
  if (file->mode == 'w') {
    /* flush LZMA output buffer */
    for (;;) {
      file->str.next_out = buf;
      file->str.avail_out = BUF_SIZE;
      ret = lzma_code(&file->str, LZMA_FINISH);
      if (ret != LZMA_STREAM_END && ret != LZMA_OK) {
        fprintf(stderr, "lzma_close error: encoding failed: %d\n", ret);
        lzma_end(&file->str);
        fclose(file->fp);
        free(file);
        return EOF;
      }
      outsize = BUF_SIZE - file->str.avail_out;
      if (fwrite(buf, 1, outsize, file->fp) != outsize) {
        lzma_end(&file->str);
        fclose(file->fp);
        free(file);
        return EOF;
      }
      if (ret == LZMA_STREAM_END)
        break;
    }
  }
  lzma_end(&file->str);
  ret = fclose(file->fp);
  free(file);
  return ret;
}

lzma_eof()

int lzma_eof

(

struct lzmafile *

file

)

Definition at line 378 of file SDDS_lzma.c.

                                    {
  lzma_stream *lstr;
  lstr = &file->str;
  if (lstr->avail_in == 0) {
    return feof(file->fp);
  } else {
    return 0;
  }
}

lzma_gets()

char * lzma_gets	(	char *	s,
		int	size,
		struct lzmafile *	file )

Definition at line 181 of file SDDS_lzma.c.

                                                          {
  int ret;
  int i = 0;
  lzma_stream *lstr;
  if (file->mode != 'r')
    return NULL;
  if (s == NULL || size < 1)
    return NULL;
  s[0] = '\0';
  lstr = &file->str;
  lstr->next_out = (void *)s;
 
  /* decompress until newline or EOF or output buffer is full */
  while (1) {
    if (lstr->avail_in == 0) {
      /* refill input buffer */
      ret = fread(file->rdbuf, 1, BUF_SIZE, file->fp);
      if (ret == 0) {
        break; /* EOF */
      }
      lstr->next_in = file->rdbuf; /* buffer containing lzma data just read */
      lstr->avail_in = ret;        /* number of bytes read */
    }
    if (i + 1 == size) {
      s[i] = '\0';
      break;
    }
    lstr->avail_out = 1;
    ret = lzma_code(lstr, LZMA_RUN);
    /* this fills up lstr->next_out and decreases lstr->avail_out */
    /* it also emptys lstr->next_in and decreases lstr->avail_in */
    if (ret != LZMA_OK && ret != LZMA_STREAM_END) {
      fprintf(stderr, "lzma_gets error: decoding failed: %d\n", ret);
      return NULL;
    }
    if (ret == LZMA_STREAM_END) { /* EOF */
      s[i + 1] = '\0';
      break;
    }
    if (s[i] == 10) { /* 10 is the value for \n */
      if (i > 0) {    /* we sometimes get \10\10 */
        if ((i == 1) && (s[0] == 32)) {
          /* when uncompressing the lzma stream we some times end 
             up with \10\32\10 instead of a simple \10 */
        } else {
          s[i + 1] = '\0';
          break;
        }
      }
    }
    i++;
  }
  return s;
}

lzma_open()

void * lzma_open	(	const char *	path,
		const char *	mode )

Definition at line 70 of file SDDS_lzma.c.

                                                    {
  int ret;
 
  /* initialize LZMA stream */
  struct lzmafile *lf = malloc(sizeof(struct lzmafile));
  lf->fp = fopen(path, mode);
  lf->str = lzma_stream_init;
  lf->mode = mode[0];
  if (mode[0] == 'r') {
#if LZMA_VERSION <= UINT32_C(49990030)
    ret = lzma_auto_decoder(&lf->str, NULL, NULL);
#else
    ret = lzma_auto_decoder(&lf->str, -1, 0);
#endif
    lf->str.avail_in = 0;
  } else {
    /* I decided to use level 2 encoding */
    /* Perhaps this should be user configurable in an environment variable */
    ret = LZMA_EASY_ENCODER(&lf->str, 2);
  }
  if (ret != LZMA_OK) {
    fprintf(stderr, "lzma_open error: %d\n", ret);
    return NULL;
  }
  return (void *)lf;
}

lzma_printf()

int lzma_printf	(	struct lzmafile *	file,
		const char *	format,
			... )

Definition at line 355 of file SDDS_lzma.c.

                                                                {
  size_t size = 32768;
  int len;
  unsigned char in[32768];
  va_list va;
  va_start(va, format);
 
  in[size - 1] = 0;
  (void)vsnprintf((char *)in, size, format, va);
  va_end(va);
  len = strlen((char *)in);
 
  /* check that printf() results fit in buffer */
  if (len <= 0 || len >= (int)size || in[size - 1] != 0) {
    fprintf(stderr, "lzma_printf error: the printf results do not fit in the buffer\n");
    return -1;
  }
  in[len] = '\0';
  len = lzma_write(file, in, len);
 
  return len;
}

lzma_putc()

int lzma_putc	(	int	c,
		struct lzmafile *	file )

Definition at line 319 of file SDDS_lzma.c.

                                            {
  int ret;
  lzma_stream *lstr = &file->str;
 
  unsigned char bufout[1]; /* compressed output buffer */
  char buf[1];
 
  if (file->mode != 'w') {
    fprintf(stderr, "lzma_putc error: file was not opened for writting\n");
    return EOF;
  }
  buf[0] = c;
 
  lstr->next_in = (void *)buf;
  lstr->avail_in = 1;
  while (lstr->avail_in) {
    lstr->next_out = bufout;
    lstr->avail_out = 1;
    ret = lzma_code(lstr, LZMA_RUN);
    if (ret != LZMA_OK) {
      fprintf(stderr, "lzma_putc error: encoding failed: %d\n", ret);
      return EOF;
    }
    ret = fwrite(bufout, 1, 1 - lstr->avail_out, file->fp);
    if (ret != 1 - lstr->avail_out) {
      fprintf(stderr, "lzma_putc error\n");
      return EOF;
    }
  }
  return (unsigned char)c;
}

lzma_puts()

int lzma_puts	(	const char *	s,
		struct lzmafile *	file )

Definition at line 275 of file SDDS_lzma.c.

                                                    {
  int ret;
  lzma_stream *lstr = &file->str;
  int count;
  unsigned char *bufout; /* compressed output buffer */
  char *buf;
 
  if (file->mode != 'w') {
    fprintf(stderr, "lzma_puts error: file was not opened for writting\n");
    return EOF;
  }
  count = strlen(s);
  bufout = malloc(sizeof(unsigned char) * count);
  buf = malloc(sizeof(char) * count);
  strncpy(buf, s, count);
 
  lstr->next_in = (void *)buf;
  lstr->avail_in = count;
  while (lstr->avail_in) {
    lstr->next_out = bufout;
    lstr->avail_out = count;
    ret = lzma_code(lstr, LZMA_RUN);
    if (ret != LZMA_OK) {
      fprintf(stderr, "lzma_puts error: encoding failed: %d\n", ret);
      free(bufout);
      free(buf);
      return EOF;
    }
    ret = fwrite(bufout, 1, count - lstr->avail_out, file->fp);
    if (ret != count - lstr->avail_out) {
      fprintf(stderr, "lzma_puts error\n");
      free(bufout);
      free(buf);
      return EOF;
    }
  }
  free(bufout);
  free(buf);
  return count;
}

lzma_read()

long lzma_read	(	struct lzmafile *	file,
		void *	buf,
		size_t	count )

Definition at line 140 of file SDDS_lzma.c.

                                                               {
  int ret;
  lzma_stream *lstr;
  if (file->mode != 'r')
    return -1;
 
  lstr = &file->str;
  lstr->next_out = buf;
  lstr->avail_out = count;
 
  /* decompress until EOF or output buffer is full */
  while (lstr->avail_out) {
    if (lstr->avail_in == 0) {
      /* refill input buffer */
      ret = fread(file->rdbuf, 1, BUF_SIZE, file->fp);
      if (ret == 0) {
        break; /* EOF */
      }
      lstr->next_in = file->rdbuf; /* buffer containing lzma data just read */
      lstr->avail_in = ret;        /* number of bytes read */
    }
    ret = lzma_code(lstr, LZMA_RUN);
    /* this fills up lstr->next_out and decreases lstr->avail_out */
    /* it also emptys lstr->next_in and decreases lstr->avail_in */
    if (ret != LZMA_OK && ret != LZMA_STREAM_END) {
      fprintf(stderr, "lzma_read error: decoding failed: %d\n", ret);
      return -1;
    }
    if (ret == LZMA_STREAM_END) {
      break; /* EOF */
    }
  }
  return count - lstr->avail_out; /* length of buf that has valid data */
}

lzma_seek()

int lzma_seek	(	struct lzmafile *	file,
		long	offset,
		int	whence )

Definition at line 397 of file SDDS_lzma.c.

                                                              {
  return fseek(file->fp, offset, whence);
}

lzma_tell()

long lzma_tell

(

struct lzmafile *

file

)

Definition at line 393 of file SDDS_lzma.c.

                                      {
  return ftell(file->fp);
}

lzma_write()

long lzma_write	(	struct lzmafile *	file,
		const void *	buf,
		size_t	count )

Definition at line 239 of file SDDS_lzma.c.

                                                                      {
  int ret;
  lzma_stream *lstr = &file->str;
  unsigned char *bufout; /* compressed output buffer */
  bufout = malloc(sizeof(char) * count);
 
  if (file->mode != 'w') {
    fprintf(stderr, "lzma_write error: file was not opened for writting\n");
    free(bufout);
    return -1;
  }
  lstr->next_in = buf;
  lstr->avail_in = count;
  while (lstr->avail_in) {
    lstr->next_out = bufout;
    lstr->avail_out = count;
    ret = lzma_code(lstr, LZMA_RUN);
    if (ret != LZMA_OK) {
      fprintf(stderr, "lzma_write error: encoding failed: %d\n", ret);
      free(bufout);
      return -1;
    }
    ret = fwrite(bufout, 1, count - lstr->avail_out, file->fp);
    if (ret != count - lstr->avail_out) {
      fprintf(stderr, "lzma_write error\n");
      free(bufout);
      return -1;
    }
  }
  free(bufout);
  return count;
}

UnpackLZMAOpen()

void * UnpackLZMAOpen

(

char *

filename

)

Definition at line 401 of file SDDS_lzma.c.

                                     {
  if (!filename)
    return NULL;
  return lzma_open(filename, "rb");
}

Variable Documentation

lzma_stream_init

const lzma_stream lzma_stream_init = LZMA_STREAM_INIT

static

Definition at line 57 of file SDDS_lzma.c.