/******************************************
Mosel NI Examples
=================
File zlib.c
```````````
Example module defining an IO driver
for (un)compression using zlib library
which can be found at http://www.zlib.org
(c) 2008 Fair Isaac Corporation
author: Y. Colombani, 2003
zlib:
(c) 1995-2002 Jean-Loup Gailly and Mark Adler
*******************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#define XPRM_NICOMPAT 3004002 /* Compatibility level: Mosel 3.4.2 */
#include "xprm_ni.h"
#ifdef _WIN32
#define snprintf _snprintf
#define _WINDOWS
#define ZLIB_DLL
/* for precompiled zlib 1.2.1 */
#define ZLIB_WINAPI
#endif
#include "zlib.h"
#define BUFSIZE 1024 /* buffer size for data transfer */
/**************************************************/
/* gzip driver: to handle files using GZIP format */
/* Example: "zlib.gzip:mydata.gz" */
/**************************************************/
/* Functions of 'gzip' driver */
static void *gzip_open(XPRMcontext ctx,int *mode,const char *fname);
static int gzip_close(XPRMcontext ctx,gzFile gzf,int mode);
static long gzip_read(XPRMcontext ctx,gzFile gzf,void *buffer,
unsigned long size);
static long gzip_write(XPRMcontext ctx,gzFile gzf,void *buffer,
unsigned long size);
static void setgzerror(XPRMcontext ctx,gzFile gzf);
static XPRMiofcttab iodrv_gzip[]=
{
{XPRM_IOCTRL_OPEN,gzip_open},
{XPRM_IOCTRL_CLOSE,gzip_close},
{XPRM_IOCTRL_READ,gzip_read},
{XPRM_IOCTRL_WRITE,gzip_write},
{XPRM_IOCTRL_INFO,"filename"},
{0,NULL}
};
/*************************************************/
/* compress driver: to handle compressed streams */
/* As opposed to 'gzip' driver this driver does */
/* not require a physical file */
/* Note also that files produced by this driver */
/* are not compatible with gzip */
/* Example: "zlib.compress:mem:0x1234/256" */
/**************************************************/
/* Functions of 'compress' driver */
static void *comp_open(XPRMcontext ctx,int *mode,const char *fname);
static int comp_close(XPRMcontext ctx,z_streamp zstr,int mode);
static long comp_read(XPRMcontext ctx,z_streamp zstr,void *buffer,
unsigned long size);
static long comp_write(XPRMcontext ctx,z_streamp zstr,void *buffer,
unsigned long size);
static XPRMiofcttab iodrv_compress[]=
{
{XPRM_IOCTRL_OPEN,comp_open},
{XPRM_IOCTRL_CLOSE,comp_close},
{XPRM_IOCTRL_READ,comp_read},
{XPRM_IOCTRL_WRITE,comp_write},
{XPRM_IOCTRL_INFO,"extended_filename"},
{0,NULL}
};
/* Drivers of zlib module: gzip,compress */
static XPRMiodrvtab iodrv_zlib[]=
{
{"gzip",iodrv_gzip},
{"compress",iodrv_compress},
{NULL,NULL}
};
static int chkres(int);
/* Table of services: only IO drivers */
static XPRMdsoserv tabserv[]=
{
{XPRM_SRV_IODRVS,iodrv_zlib},
{XPRM_SRV_CHKRES,(void*)chkres}
};
/* DSO interface: only services */
static XPRMdsointer dsointer=
{
0,NULL,
0,NULL,
0,NULL,
sizeof(tabserv)/sizeof(mm_dsoserv),tabserv
};
static XPRMnifct mm; /* For storing Mosel NI function table */
/************************************************/
/* Initialize the library just after loading it */
/************************************************/
DSO_INIT zlib_init(XPRMnifct nifct, int *interver,int *libver, XPRMdsointer **interf)
{
const char *zlv;
mm=nifct; /* Save the table of Mosel NI functions */
*interver=XPRM_NIVERS; /* The interface version we are using */
/* We check ZLIB library version here */
zlv=zlibVersion();
if((zlv==NULL)||(zlv[0]!=ZLIB_VERSION[0]))
{
mm->dispmsg(NULL,"ZLIB: wrong version (expect %s got %s).\n",ZLIB_VERSION,
(zlv!=NULL)?zlv:"0");
return 1;
}
else
{
*libver=XPRM_MKVER(0,0,2); /* The version of the module: 0.0.2 */
*interf=&dsointer; /* Our interface */
return 0;
}
}
/****************************************************************/
/* Check restrictions (this module implements all restrictions) */
/****************************************************************/
static int chkres(int r)
{
return 0;
}
/****************************************/
/* Open a gzip-file for (de)compression */
/****************************************/
static void *gzip_open(XPRMcontext ctx,int *mode,const char *fname)
{
char cfname[MM_MAXPATHLEN];
char cmode[16];
int cml;
void *gzf;
if((fname==NULL)||
(mm->pathcheck(ctx,fname,cfname,MM_MAXPATHLEN,
((*mode)&MM_F_WRITE)?MM_RCHK_WRITE:MM_RCHK_READ)!=0))
{
mm->setioerrmsg(ctx,strerror(EACCES),1);
return NULL;
}
else
{
cml=2;
cmode[0]=((*mode)&MM_F_WRITE)?'w':'r';
cmode[1]=((*mode)&MM_F_BINARY)?'b':'t';
if((*mode)&MM_F_APPEND) cmode[cml++]='a';
cmode[cml]='\0';
gzf=gzopen(cfname,cmode);
if(gzf==NULL)
mm->setioerrmsg(ctx,strerror(errno),2);
return gzf;
}
}
/***********************/
/* Close the gzip-file */
/***********************/
static int gzip_close(XPRMcontext ctx,gzFile gzf,int mode)
{ return gzclose(gzf); }
/******************************/
/* Uncompress a block of data */
/******************************/
static long gzip_read(XPRMcontext ctx,gzFile gzf,void *buffer,
unsigned long size)
{
long l;
l=gzread(gzf,buffer,size);
if(l<0) setgzerror(ctx,gzf);
return l;
}
/****************************/
/* Compress a block of data */
/****************************/
static long gzip_write(XPRMcontext ctx,gzFile gzf,void *buffer,
unsigned long size)
{
long l;
l=gzwrite(gzf,buffer,size);
if(l<=0) setgzerror(ctx,gzf);
return l;
}
/*********************************/
/* Set message of the last error */
/*********************************/
static void setgzerror(XPRMcontext ctx,gzFile gzf)
{
int errnum;
const char *emsg;
if((((emsg=gzerror(gzf,&errnum))!=NULL)&&(errnum==Z_ERRNO)))
{
errnum=errno;
emsg=strerror(errno);
}
if(errnum!=0)
mm->setioerrmsg(ctx,emsg,errnum);
}
/*************************************/
/* Open a stream for (de)compression */
/*************************************/
static void *comp_open(XPRMcontext ctx,int *mode,const char *fname)
{
z_streamp zstr;
int rts;
/* 1st: open actual file */
if(mm->fopen(ctx,((*mode)&XPRM_F_WRITE)|XPRM_F_BINARY,fname)<0)
{
*mode|=XPRM_F_SILENT; /* Error message already displayed */
/* switch so silent mode */
return NULL;
}
else
{ /* If OK, prepare data structures for zlib */
/* Allocate memory for zstream and a buffer */
if((zstr=(z_streamp)malloc(sizeof(z_stream)+BUFSIZE))==NULL)
{
mm->fclose(ctx,(*mode)&(XPRM_F_READ|XPRM_F_WRITE));
mm->setioerrmsg(ctx,"Not enough memory",1);
return NULL;
}
memset(zstr,0,sizeof(z_stream));
zstr->zalloc=Z_NULL;
zstr->zfree=Z_NULL;
if(((*mode)&(XPRM_F_READ|XPRM_F_WRITE))==XPRM_F_READ)
{ /* For reading: 'inflate' algorithm */
rts=inflateInit(zstr);
zstr->next_in=(void *)(zstr+1); /* Buffer is after zstream */
}
else
{ /* For writing: 'deflate' algorithm */
rts=deflateInit(zstr,Z_DEFAULT_COMPRESSION);
zstr->next_out=(void *)(zstr+1); /* Buffer is after zstream */
zstr->avail_out=BUFSIZE;
}
if(rts!=Z_OK)
{
mm->setioerrmsg(ctx,zstr->msg,rts);
free(zstr);
mm->fclose(ctx,(*mode)&(XPRM_F_READ|XPRM_F_WRITE));
return NULL;
}
else
return zstr;
}
}
/********************/
/* Close the stream */
/********************/
static int comp_close(XPRMcontext ctx,z_stream *zstr,int mode)
{
int rts1,rts2;
Bytef dummy;
if((mode&(XPRM_F_READ|XPRM_F_WRITE))==XPRM_F_READ)
{ /* If reading: just release zstream */
rts1=inflateEnd(zstr);
}
else
{ /* If writing: buffers have to be flushed first */
zstr->next_in=&dummy;
zstr->avail_in=0;
if(zstr->avail_out==0)
{
mm->fwrite(ctx,zstr+1,BUFSIZE);
zstr->next_out=(void *)(zstr+1);
zstr->avail_out=BUFSIZE;
}
do
{
rts1=deflate(zstr,Z_FINISH);
if(BUFSIZE-zstr->avail_out>0)
mm->fwrite(ctx,zstr+1,BUFSIZE-zstr->avail_out);
zstr->next_out=(void *)(zstr+1);
zstr->avail_out=BUFSIZE;
} while(rts1==Z_OK);
rts1=deflateEnd(zstr);
}
/* Finally close actual file and release memory */
rts2=mm->fclose(ctx,mode);
if(rts1!=Z_OK)
mm->setioerrmsg(ctx,zstr->msg,rts1);
free(zstr);
return (rts1!=Z_OK)||(rts2!=0);
}
/******************************/
/* Uncompress a block of data */
/******************************/
static long comp_read(XPRMcontext ctx,z_stream *zstr,void *buffer,
unsigned long size)
{
int rts,finish;
zstr->next_out=buffer;
zstr->avail_out=size;
finish=0;
do
{
if(zstr->avail_in==0)
{
zstr->avail_in=mm->fread(ctx,zstr+1,BUFSIZE);
zstr->next_in=(void *)(zstr+1);
finish=(zstr->avail_in==0);
}
rts=inflate(zstr,Z_NO_FLUSH);
} while((rts==Z_OK)&&(zstr->avail_out>0) && !finish);
if(finish && (zstr->avail_out>0))
rts=inflate(zstr,Z_SYNC_FLUSH);
if((rts==Z_OK)||(rts==Z_STREAM_END))
return (long)(size-zstr->avail_out);
else
{
mm->setioerrmsg(ctx,zstr->msg,rts);
return -1;
}
}
/****************************/
/* Compress a block of data */
/****************************/
static long comp_write(XPRMcontext ctx,z_stream *zstr,void *buffer,
unsigned long size)
{
int rts;
zstr->next_in=buffer;
zstr->avail_in=size;
do
{
if(zstr->avail_out==0)
{
mm->fwrite(ctx,zstr+1,BUFSIZE);
zstr->next_out=(void *)(zstr+1);
zstr->avail_out=BUFSIZE;
}
rts=deflate(zstr,Z_NO_FLUSH);
} while((rts==Z_OK)&&(zstr->avail_in>0));
if(rts==Z_OK)
return 1;
else
{
mm->setioerrmsg(ctx,zstr->msg,rts);
return 0;
}
}
|
