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.

#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.

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)

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 379 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 356 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 320 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);
  memcpy(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 398 of file SDDS_lzma.c.

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

◆ lzma_tell()

long lzma_tell ( struct lzmafile * file )

Definition at line 394 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 402 of file SDDS_lzma.c.

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