SDDS_lzma.c File Reference

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>
#include "mdb.h"
#include "mdb_thread.h"

Go to the source code of this file.

Functions
static int	SDDS_GetLockedLZMACompressionLevel (void)
void	SDDS_SetLZMACompressionLevel (int32_t level)
int32_t	SDDS_GetLZMACompressionLevel (void)
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 136 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 415 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 217 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 99 of file SDDS_lzma.c.

                                                    {
  int ret;
 
  /* initialize LZMA stream */
  struct lzmafile *lf = malloc(sizeof(struct lzmafile));
  if (!lf)
    return NULL;
  lf->fp = fopen(path, mode);
  if (!lf->fp) {
    free(lf);
    return NULL;
  }
  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 {
    ret = LZMA_EASY_ENCODER(&lf->str, SDDS_GetLockedLZMACompressionLevel());
  }
  if (ret != LZMA_OK) {
    fprintf(stderr, "lzma_open error: %d\n", ret);
    lzma_end(&lf->str);
    fclose(lf->fp);
    free(lf);
    return NULL;
  }
  return (void *)lf;
}

lzma_printf()

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

Definition at line 392 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 356 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 311 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 176 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 434 of file SDDS_lzma.c.

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

lzma_tell()

long lzma_tell

(

struct lzmafile *

file

)

Definition at line 430 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 275 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;
}

SDDS_GetLockedLZMACompressionLevel()

static int SDDS_GetLockedLZMACompressionLevel ( void )

static

Definition at line 75 of file SDDS_lzma.c.

                                                    {
  int level;
  mdb_thread_lock(&lzmaCompressionLevelLock);
  level = lzmaCompressionLevel;
  mdb_thread_unlock(&lzmaCompressionLevelLock);
  return level;
}

SDDS_GetLZMACompressionLevel()

int32_t SDDS_GetLZMACompressionLevel

(

void

)

Definition at line 91 of file SDDS_lzma.c.

                                           {
  return SDDS_GetLockedLZMACompressionLevel();
}

SDDS_SetLZMACompressionLevel()

void SDDS_SetLZMACompressionLevel

(

int32_t

level

)

Definition at line 83 of file SDDS_lzma.c.

                                                 {
  if (level >= 0 && level <= 9) {
    mdb_thread_lock(&lzmaCompressionLevelLock);
    lzmaCompressionLevel = level;
    mdb_thread_unlock(&lzmaCompressionLevelLock);
  }
}

UnpackLZMAOpen()

void * UnpackLZMAOpen

(

char *

filename

)

Definition at line 438 of file SDDS_lzma.c.

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