/pkginst/Makefile |
---|
0,0 → 1,65 |
# |
# pkginst Makefile -- requires OpenWatcom (wmake) |
# Copyright (C) 2021 Mateusz Viste |
# |
CFLAGS = -0 -ml -os -wx -we -d0 -i=zlib |
LDFLAGS = -ml -lr -fe=pkginst.exe |
LIBS = zlib\zlib_l.lib |
all: pkginst.exe |
pkginst.exe: kitten.obj main.obj crc32.obj fileexst.obj getdelim.obj helpers.obj inf.obj kprintf.obj libunzip.obj loadconf.obj lsm.obj parsecmd.obj pkginst.obj pkgrem.obj rtrim.obj showinst.obj |
wcl $(LDFLAGS) $(LIBS) *.obj |
kitten.obj: kitten\kitten.c |
wcc $(CFLAGS) kitten\kitten.c |
main.obj: main.c |
wcc $(CFLAGS) main.c |
crc32.obj: crc32.c |
wcc $(CFLAGS) crc32.c |
fileexst.obj: fileexst.c |
wcc $(CFLAGS) fileexst.c |
getdelim.obj: getdelim.c |
wcc $(CFLAGS) getdelim.c |
helpers.obj: helpers.c |
wcc $(CFLAGS) helpers.c |
inf.obj: inf.c |
wcc $(CFLAGS) inf.c |
kprintf.obj: kprintf.c |
wcc $(CFLAGS) kprintf.c |
libunzip.obj: libunzip.c |
wcc $(CFLAGS) libunzip.c |
loadconf.obj: loadconf.c |
wcc $(CFLAGS) loadconf.c |
lsm.obj: lsm.c |
wcc $(CFLAGS) lsm.c |
parsecmd.obj: parsecmd.c |
wcc $(CFLAGS) parsecmd.c |
pkginst.obj: pkginst.c |
wcc $(CFLAGS) pkginst.c |
pkgrem.obj: pkgrem.c |
wcc $(CFLAGS) pkgrem.c |
rtrim.obj: rtrim.c |
wcc $(CFLAGS) rtrim.c |
showinst.obj: showinst.c |
wcc $(CFLAGS) showinst.c |
clean: .symbolic |
del *.obj |
del pkginst.exe |
/pkginst/crc32.c |
---|
0,0 → 1,128 |
/* |
* $Id: crc32.c,v 1.1.1.1 1996/02/18 21:38:12 ylo Exp $ |
* $Log: crc32.c,v $ |
* Revision 1.1.1.1 1996/02/18 21:38:12 ylo |
* Imported ssh-1.2.13. |
* |
* Revision 1.2 1995/07/13 01:21:34 ylo |
* Added cvs log. |
* |
* $Endlog$ |
*/ |
/* The implementation here was originally done by Gary S. Brown. I have |
borrowed the tables directly, and made some minor changes to the |
crc32-function (including changing the interface). */ |
#include "crc32.h" |
/* ============================================================= */ |
/* COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or */ |
/* code or tables extracted from it, as desired without restriction. */ |
/* */ |
/* First, the polynomial itself and its table of feedback terms. The */ |
/* polynomial is */ |
/* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 */ |
/* */ |
/* Note that we take it "backwards" and put the highest-order term in */ |
/* the lowest-order bit. The X^32 term is "implied"; the LSB is the */ |
/* X^31 term, etc. The X^0 term (usually shown as "+1") results in */ |
/* the MSB being 1. */ |
/* */ |
/* Note that the usual hardware shift register implementation, which */ |
/* is what we're using (we're merely optimizing it by doing eight-bit */ |
/* chunks at a time) shifts bits into the lowest-order term. In our */ |
/* implementation, that means shifting towards the right. Why do we */ |
/* do it this way? Because the calculated CRC must be transmitted in */ |
/* order from highest-order term to lowest-order term. UARTs transmit */ |
/* characters in order from LSB to MSB. By storing the CRC this way, */ |
/* we hand it to the UART in the order low-byte to high-byte; the UART */ |
/* sends each low-bit to hight-bit; and the result is transmission bit */ |
/* by bit from highest- to lowest-order term without requiring any bit */ |
/* shuffling on our part. Reception works similarly. */ |
/* */ |
/* The feedback terms table consists of 256, 32-bit entries. Notes: */ |
/* */ |
/* The table can be generated at runtime if desired; code to do so */ |
/* is shown later. It might not be obvious, but the feedback */ |
/* terms simply represent the results of eight shift/xor opera- */ |
/* tions for all combinations of data and CRC register values. */ |
/* */ |
/* The values must be right-shifted by eight bits by the "updcrc" */ |
/* logic; the shift must be unsigned (bring in zeroes). On some */ |
/* hardware you could probably optimize the shift in assembler by */ |
/* using byte-swap instructions. */ |
/* polynomial $edb88320 */ |
/* */ |
/* -------------------------------------------------------------------- */ |
const unsigned long crc32_tab[256] = { |
0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, |
0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, |
0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, |
0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, |
0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, |
0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, |
0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, |
0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, |
0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, |
0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, |
0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, |
0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, |
0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, |
0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, |
0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, |
0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, |
0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, |
0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, |
0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, |
0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, |
0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, |
0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, |
0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, |
0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, |
0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, |
0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, |
0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, |
0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, |
0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, |
0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, |
0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, |
0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, |
0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, |
0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, |
0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, |
0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, |
0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, |
0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, |
0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, |
0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, |
0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, |
0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, |
0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, |
0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, |
0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, |
0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, |
0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, |
0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, |
0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, |
0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, |
0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, |
0x2d02ef8dL |
}; |
/* Return a 32-bit CRC of the contents of the buffer. */ |
unsigned long crc32_init(void) { |
return(0xFFFFFFFFlu); |
} |
void crc32_feed(unsigned long *crc32val, const unsigned char *s, unsigned int len) { |
unsigned long i; |
for (i = 0; i < len; i++) *crc32val = crc32_tab[(*crc32val ^ s[i]) & 0xff] ^ (*crc32val >> 8); |
} |
void crc32_finish(unsigned long *crc32val) { |
*crc32val ^= 0xFFFFFFFFlu; |
} |
/pkginst/crc32.h |
---|
0,0 → 1,25 |
/* |
* $Id: crc32.h,v 1.1.1.1 1996/02/18 21:38:11 ylo Exp $ |
* $Log: crc32.h,v $ |
* Revision 1.1.1.1 1996/02/18 21:38:11 ylo |
* Imported ssh-1.2.13. |
* |
* Revision 1.2 1995/07/13 01:21:45 ylo |
* Removed "Last modified" header. |
* Added cvs log. |
* |
* $Endlog$ |
*/ |
#ifndef CRC32_H_SENTINEL |
#define CRC32_H_SENTINEL |
unsigned long crc32_init(void); |
/* This computes a 32 bit CRC of the data in the buffer, and returns the |
CRC. The polynomial used is 0xedb88320. */ |
void crc32_feed(unsigned long *crc32val, const unsigned char *buf, unsigned int len); |
void crc32_finish(unsigned long *crc32val); |
#endif /* CRC32_H_SENTINEL */ |
/pkginst/fdnpkg.h |
---|
0,0 → 1,18 |
/* |
* This file is part of FDNPKG |
* Copyright (C) 2012-2016 Mateusz Viste |
*/ |
#ifndef FDNPKG_H_SENTINEL |
#define FDNPKG_H_SENTINEL |
/* flags used by FDNPKG */ |
#define PKGINST_SKIPLINKS 1 |
#define PKGINST_UPDATE 2 |
struct flist_t { |
struct flist_t *next; |
char fname[2]; /* this must be the last item in the structure, it will be expanded to fit the filename */ |
}; |
#endif |
/pkginst/fileexst.c |
---|
0,0 → 1,15 |
/* |
* fileexists checks whether a file exists or not. |
* returns 0 if file not found, non-zero otherwise. |
*/ |
#include <stdio.h> |
#include "fileexst.h" |
int fileexists(const char *filename) { |
FILE *fd; |
fd = fopen(filename, "rb"); |
if (fd == NULL) return(0); /* file does not exists */ |
fclose(fd); |
return(1); |
} |
/pkginst/fileexst.h |
---|
0,0 → 1,11 |
/* |
* fileexists checks whether a file exists or not. |
* returns 0 if file not found, non-zero otherwise. |
*/ |
#ifndef fileexists_sentinel |
#define fileexists_sentinel |
int fileexists(const char *filename); |
#endif |
/pkginst/getdelim.c |
---|
0,0 → 1,116 |
/* getdelim.c --- Implementation of replacement getdelim function. |
Copyright (C) 1994, 1996, 1997, 1998, 2001, 2003, 2005 Free |
Software Foundation, Inc. |
This program is free software; you can redistribute it and/or |
modify it under the terms of the GNU General Public License as |
published by the Free Software Foundation; either version 2, or (at |
your option) any later version. |
This program is distributed in the hope that it will be useful, but |
WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
General Public License for more details. |
You should have received a copy of the GNU General Public License |
along with this program; if not, write to the Free Software |
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
02110-1301, USA. */ |
/* Ported from glibc by Simon Josefsson. */ |
#ifdef HAVE_CONFIG_H |
# include <config.h> |
#endif |
#include "getdelim.h" |
#include <limits.h> |
#include <stdlib.h> |
#include <errno.h> |
#ifndef SIZE_MAX |
# define SIZE_MAX ((size_t) -1) |
#endif |
#ifndef SSIZE_MAX |
# define SSIZE_MAX ((ssize_t) (SIZE_MAX / 2)) |
#endif |
#if !HAVE_FLOCKFILE |
# undef flockfile |
# define flockfile(x) ((void) 0) |
#endif |
#if !HAVE_FUNLOCKFILE |
# undef funlockfile |
# define funlockfile(x) ((void) 0) |
#endif |
/* Read up to (and including) a DELIMITER from FP into *LINEPTR (and |
NUL-terminate it). *LINEPTR is a pointer returned from malloc (or |
NULL), pointing to *N characters of space. It is realloc'ed as |
necessary. Returns the number of characters read (not including |
the null terminator), or -1 on error or EOF. */ |
ssize_t getdelim(char **lineptr, size_t *n, int delimiter, FILE *fp) { |
ssize_t result; |
size_t cur_len = 0; |
if ((lineptr == NULL) || (n == NULL) || (fp == NULL)) { |
errno = EINVAL; |
return(-1); |
} |
flockfile (fp); |
if ((*lineptr == NULL) || (*n == 0)) { |
*n = 120; |
*lineptr = (char *)malloc(*n); |
if (*lineptr == NULL) { |
result = -1; |
goto unlock_return; |
} |
} |
for (;;) { |
int i; |
i = getc(fp); |
if (i == EOF) { |
result = -1; |
break; |
} |
/* Make enough space for len+1 (for final NUL) bytes. */ |
if (cur_len + 1 >= *n) { |
size_t needed_max = SSIZE_MAX < SIZE_MAX ? (size_t) SSIZE_MAX + 1 : SIZE_MAX; |
size_t needed = 2 * *n + 1; /* Be generous. */ |
char *new_lineptr; |
if (needed_max < needed) needed = needed_max; |
if (cur_len + 1 >= needed) { |
result = -1; |
goto unlock_return; |
} |
new_lineptr = (char *) realloc (*lineptr, needed); |
if (new_lineptr == NULL) { |
result = -1; |
goto unlock_return; |
} |
*lineptr = new_lineptr; |
*n = needed; |
} |
(*lineptr)[cur_len] = i; |
cur_len++; |
if (i == delimiter) break; |
} |
(*lineptr)[cur_len] = '\0'; |
if (cur_len != 0) result = cur_len; |
/* result = cur_len ? cur_len : result; */ /* this one have been replaced by the line above for reading simplicity */ |
unlock_return: |
funlockfile(fp); |
return(result); |
} |
/pkginst/getdelim.h |
---|
0,0 → 1,28 |
/* getdelim.h --- Prototype for replacement getdelim function. |
Copyright (C) 2005 Free Software Foundation, Inc. |
This program is free software; you can redistribute it and/or |
modify it under the terms of the GNU General Public License as |
published by the Free Software Foundation; either version 2, or (at |
your option) any later version. |
This program is distributed in the hope that it will be useful, but |
WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
General Public License for more details. |
You should have received a copy of the GNU General Public License |
along with this program; if not, write to the Free Software |
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
02110-1301, USA. */ |
/* Written by Simon Josefsson. */ |
/* Get size_t, FILE, ssize_t. And getdelim, if available. */ |
# include <stddef.h> |
# include <stdio.h> |
# include <sys/types.h> |
#if !HAVE_DECL_GETDELIM |
ssize_t getdelim (char **lineptr, size_t *n, int delimiter, FILE *stream); |
#endif /* !HAVE_GETDELIM */ |
/pkginst/helpers.c |
---|
0,0 → 1,248 |
/* |
* This file is part of pkginst |
* Copyright (C) 2012-2021 Mateusz Viste |
* |
* It contains a few helper function... |
*/ |
#include <ctype.h> /* tolower() */ |
#include <direct.h> /* provides the mkdir() prototype */ |
#include <string.h> /* */ |
#include <stdio.h> /* sprintf() */ |
#include <stdlib.h> /* atoi() */ |
#include <sys/stat.h> /* mkdir() */ |
#include "helpers.h" |
/* translates a version string into a array of integer values. The array must be 8-position long. |
returns 0 if parsing was successful, non-zero otherwise. |
Accepted formats follow: |
300.12.1 |
1 |
12.2.34.2-4.5 |
1.2c |
1.01 |
2013-12-31 */ |
static int versiontointarr(char *verstr, int *arr) { |
int i, vlen, dotcounter = 1, firstcharaftersep = 0; |
char *digits[8]; |
char verstrcopy[16]; |
/* fill the array with zeroes first */ |
for (i = 0; i < 8; i++) arr[i] = 0; |
/* first extensively validate the input */ |
if (verstr == NULL) return(-1); |
vlen = strlen(verstr); |
if (vlen == 0) return(-1); |
if (vlen > 15) return(-1); |
if ((verstr[0] < '0') || (verstr[0] > '9')) return(-1); /* a version string must start with a 0..9 digit */ |
if ((tolower(verstr[vlen - 1]) >= 'a') && (tolower(verstr[vlen - 1]) <= 'z') && (vlen > 1)) { /* remove any letter from the end, and use it as a (very) minor differenciator */ |
vlen -= 1; |
arr[7] = tolower(verstr[vlen]); |
} |
if ((verstr[vlen - 1] < '0') || (verstr[vlen - 1] > '9')) return(-1); /* a version string must end with a 0..9 digit */ |
digits[0] = verstrcopy; |
for (i = 0; i < vlen; i++) { |
verstrcopy[i] = verstr[i]; |
switch (verstr[i]) { |
case '.': |
case '-': |
if (i == 0) return(-1); |
if (verstrcopy[i-1] == 0) return(-1); /* do not allow two separators in a row */ |
if (dotcounter > 6) return(-1); |
digits[dotcounter++] = &verstrcopy[i + 1]; |
verstrcopy[i] = 0; |
firstcharaftersep = 1; |
break; |
case '0': |
/* if this is a zero right after a separator, and trailed with a digit |
* (as in '1.01'), then enforce a separator first */ |
if ((firstcharaftersep != 0) && (verstr[i+1] >= '0') && (verstr[i+1] <= '9')) { |
if (dotcounter > 6) return(-1); |
digits[dotcounter++] = &verstrcopy[i + 1]; |
verstrcopy[i] = 0; |
} |
break; |
case '1': |
case '2': |
case '3': |
case '4': |
case '5': |
case '6': |
case '7': |
case '8': |
case '9': |
firstcharaftersep = 0; |
break; |
default: /* do not allow any character different than 0..9 or '.' */ |
return(-1); |
break; |
} |
} |
verstrcopy[i] = 0; |
/* now that we know the input is sane, let's process it */ |
for (i = 0; i < dotcounter; i++) { |
int tmpint; |
tmpint = atoi(digits[i]); |
if ((tmpint < 0) || (tmpint > 32000)) return(-1); |
arr[i] = tmpint; |
} |
return(0); |
} |
/* compares version strings v1 and v2. Returns 1 if v2 is newer than v1, 0 otherwise, and -1 if comparison is unable to tell */ |
int isversionnewer(char *v1, char *v2) { |
int x1[8], x2[8], i; |
if ((v1 == NULL) || (v2 == NULL)) return(-1); /* if input is invalid (NULL), don't continue */ |
if (strcasecmp(v1, v2) == 0) return(0); /* if both versions are the same, don't continue */ |
/* check versions of the decimal format 1.23... */ |
if ((versiontointarr(v1, x1) != 0) || (versiontointarr(v2, x2) != 0)) return(-1); |
for (i = 0; i < 8; i++) { |
if (x2[i] > x1[i]) return(1); |
if (x2[i] < x1[i]) return(0); |
} |
return(0); |
} |
/* change all / to \ in a string */ |
void slash2backslash(char *str) { |
int x; |
for (x = 0; str[x] != 0; x++) { |
if (str[x] == '/') str[x] = '\\'; |
} |
} |
/* change all \ to / in a string */ |
void backslash2slash(char *str) { |
int x; |
for (x = 0; str[x] != 0; x++) { |
if (str[x] == '\\') str[x] = '/'; |
} |
} |
void removeDoubleBackslashes(char *str) { |
char *curpos; |
int x; |
for (;;) { |
curpos = fdnpkg_strcasestr(str, "\\\\"); |
if (curpos == NULL) return; /* job done */ |
for (x = 1; curpos[x] != 0; x++) { |
curpos[x - 1] = curpos[x]; |
} |
curpos[x - 1] = 0; |
} |
} |
/* converts a string to all lowercase */ |
void strtolower(char *mystring) { |
int x; |
for (x = 0; mystring[x] != 0; x++) mystring[x] = tolower(mystring[x]); |
} |
/* Find the first occurrence of find in s, ignore case. */ |
char *fdnpkg_strcasestr(const char *s, const char *find) { |
char c, sc; |
size_t len; |
if ((c = *find++) != 0) { |
c = tolower((unsigned char)c); |
len = strlen(find); |
do { |
do { |
if ((sc = *s++) == 0) return(NULL); |
} while ((char)tolower((unsigned char)sc) != c); |
} while (strncasecmp(s, find, len) != 0); |
s--; |
} |
return((char *)s); |
} |
/* Creates directories recursively */ |
void mkpath(char *dirs) { |
int x; |
char savechar; |
for (x = 0; dirs[x] != 0; x++) { |
if (((dirs[x] == '/') || (dirs[x] == '\\')) && (x > 0)) { |
if (dirs[x - 1] != ':') { /* avoid d:\ stuff */ |
savechar = dirs[x]; |
dirs[x] = 0; |
/* make the dir */ |
mkdir(dirs); |
dirs[x] = savechar; |
} |
} |
} |
} |
/* returns a pointer to the start of the filename, out of a path\to\file string, and |
fills respath with the local folder where the file should be placed. */ |
char *computelocalpath(char *longfilename, char *respath, const char *dosdir, const struct customdirs *dirlist) { |
int x, lastsep = 0, firstsep = -1; |
char savedchar; |
char *shortfilename, *pathstart; |
pathstart = longfilename; |
for (x = 0; longfilename[x] != 0; x++) { |
if ((longfilename[x] == '/') || (longfilename[x] == '\\')) { |
lastsep = x; |
if (firstsep < 0) firstsep = x; |
} |
} |
shortfilename = &longfilename[lastsep + 1]; |
/* look for possible custom path */ |
if (firstsep > 0) { |
savedchar = longfilename[firstsep]; |
longfilename[firstsep] = 0; |
for (; dirlist != NULL; dirlist = dirlist->next) { |
if (fdnpkg_strcasestr(longfilename, dirlist->name) == longfilename) { /* found! */ |
/* sprintf(respath, "%s\\%s", dirlist->location, &longfilename[firstsep + 1]); */ |
pathstart = &longfilename[firstsep + 1]; |
dosdir = dirlist->location; |
break; |
} |
} |
longfilename[firstsep] = savedchar; /* restore longfilename as it was */ |
} |
/* apply the default (DOSDIR) path */ |
savedchar = longfilename[lastsep + 1]; |
longfilename[lastsep + 1] = 0; |
sprintf(respath, "%s\\%s", dosdir, pathstart); |
slash2backslash(respath); |
removeDoubleBackslashes(respath); |
longfilename[lastsep + 1] = savedchar; |
return(shortfilename); |
} |
/* detect local paths (eg. C:\REPO). Returns 1 if the url looks like a local path, zero otherwise. */ |
int detect_localpath(char *url) { |
if (url[0] != 0) { |
if (url[1] != 0) { |
if ((url[1] == ':') && ((url[2] == '\\') || (url[2] == '/'))) return(1); |
} |
} |
return(0); |
} |
/* analyzes a filename string and returns the pointer to the file's extension |
* (which can be empty) */ |
char *getfext(char *fname) { |
char *res = NULL; |
for (; *fname != 0; fname++) { |
if (*fname == '.') res = fname + 1; |
} |
/* if no dot found, then point to the string's null terminator */ |
if (res == NULL) return(fname); |
return(res); |
} |
/pkginst/helpers.h |
---|
0,0 → 1,21 |
/* |
* This file is part of pkginst |
* Copyright (C) 2012-2021 Mateusz Viste |
* |
* It contains a few helper function... |
*/ |
#ifndef helpers_sentinel |
#define helpers_sentinel |
#include "loadconf.h" /* required for the customdirs struct */ |
int isversionnewer(char *v1, char *v2); |
void slash2backslash(char *str); |
void backslash2slash(char *str); |
void strtolower(char *mystring); |
char *fdnpkg_strcasestr(const char *s, const char *find); |
void mkpath(char *dirs); |
char *computelocalpath(char *longfilename, char *respath, const char *dosdir, const struct customdirs *dirlist); |
void removeDoubleBackslashes(char *str); |
int detect_localpath(char *url); |
char *getfext(char *fname); |
#endif |
/pkginst/inf.c |
---|
0,0 → 1,85 |
/* This file is part of the FDNPKG project. It is an adaptation of the |
* "zpipe.c" example of zlib's inflate() and deflate() usage. |
* |
* Not copyrighted -- provided to the public domain |
* original version 1.4 11 December 2005 Mark Adler |
* adaptations for FDNPKG integration by Mateusz Viste, 2015 |
*/ |
#include <stdio.h> |
#include <string.h> |
#include "crc32.h" |
#include "zlib\zlib.h" |
#include "inf.h" |
#define CHUNK 16384 |
/* Decompress from file source to file dest until stream ends or EOF. |
* inf() returns Z_OK on success, Z_MEM_ERROR if memory could not be allocated |
* for processing, Z_DATA_ERROR if the deflate data is invalid or incomplete, |
* Z_VERSION_ERROR if the version of zlib.h and the version of the library |
* linked do not match, or Z_ERRNO if there is an error reading or writing the |
* files. */ |
int inf(FILE *source, FILE *dest, unsigned char *buff32K, unsigned long *cksum, long streamlen) { |
int ret; |
unsigned int have; |
z_stream strm; |
unsigned char *in = buff32K; |
unsigned char *out = buff32K + CHUNK; |
/* allocate inflate state */ |
strm.zalloc = Z_NULL; |
strm.zfree = Z_NULL; |
strm.opaque = Z_NULL; |
strm.avail_in = 0; |
strm.next_in = Z_NULL; |
ret = inflateInit2(&strm, -15); /* according to the zlib doc, passing -15 to inflateInit2() means "this is a raw deflate stream" (as opposed to a zlib- or gz- wrapped stream) */ |
if (ret != Z_OK) return(ret); |
/* decompress until deflate stream ends or end of file */ |
do { |
strm.avail_in = fread(in, 1, (streamlen > CHUNK ? CHUNK : streamlen), source); |
if (ferror(source)) { |
(void)inflateEnd(&strm); |
return(Z_ERRNO); |
} |
streamlen -= strm.avail_in; |
if (strm.avail_in == 0) break; |
strm.next_in = in; |
/* run inflate() on input until output buffer not full */ |
do { |
strm.avail_out = CHUNK; |
strm.next_out = out; |
ret = inflate(&strm, Z_NO_FLUSH); |
switch (ret) { |
case Z_NEED_DICT: |
ret = Z_DATA_ERROR; /* and fall through */ |
case Z_DATA_ERROR: |
case Z_MEM_ERROR: |
(void)inflateEnd(&strm); |
return(ret); |
} |
have = CHUNK - strm.avail_out; |
if ((fwrite(out, 1, have, dest) != have) || (ferror(dest))) { |
(void)inflateEnd(&strm); |
return(Z_ERRNO); |
} |
/* feed the CRC32 */ |
crc32_feed(cksum, out, have); |
} while (strm.avail_out == 0); |
/* done when inflate() says it's done */ |
} while (ret != Z_STREAM_END); |
/* clean up and return */ |
(void)inflateEnd(&strm); |
if (Z_STREAM_END) { |
return(Z_OK); |
} else { |
return(Z_DATA_ERROR); |
} |
} |
/pkginst/inf.h |
---|
0,0 → 1,13 |
#ifndef INF_H |
#define INF_H |
/* Decompress from file source to file dest until stream ends or EOF. |
* inf() returns Z_OK on success, Z_MEM_ERROR if memory could not be allocated |
* for processing, Z_DATA_ERROR if the deflate data is invalid or incomplete, |
* Z_VERSION_ERROR if the version of zlib.h and the version of the library |
* linked do not match, or Z_ERRNO if there is an error reading or writing the |
* files. */ |
int inf(FILE *source, FILE *dest, unsigned char *buff32k, unsigned long *cksum, long streamlen); |
#endif |
/pkginst/kitten/kitten.c |
---|
0,0 → 1,698 |
/* Functions that emulate UNIX catgets */ |
/* Copyright (C) 1999,2000,2001 Jim Hall <jhall@freedos.org> */ |
/* Kitten version 2003 by Tom Ehlert, heavily modified by Eric Auer 2003 */ |
/* |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Lesser General Public |
License as published by the Free Software Foundation; either |
version 2.1 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Lesser General Public License for more details. |
You should have received a copy of the GNU Lesser General Public |
License along with this library; if not, write to the Free Software |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
*/ |
#ifndef NO_KITTEN |
#include <stdio.h> /* sprintf */ |
#ifndef _MICROC_ |
#include <stdlib.h> /* getenv */ |
#include <string.h> /* strchr */ |
#include <dos.h> |
#ifndef __PACIFIC__ |
#include <fcntl.h> |
#else |
#define O_RDONLY 0 |
#define O_TEXT 0 |
#endif |
#else |
#include <intr.h> |
#include <file.h> |
#define O_RDONLY READONLY |
#define O_TEXT 0 |
#endif |
/* assert we are running in small model */ |
/* else pointer below has to be done correctly */ |
/* char verify_small_pointers[sizeof(void*) == 2 ? 1 : -1]; */ |
#include "kitten.h" |
char catcontents[8192]; |
struct catstring |
{ |
char key1; |
char key2; |
char *text; |
}; |
/* Micro-C does not support typedef */ |
#define catstring_t struct catstring |
catstring_t catpoints[128]; |
/* Local prototypes */ |
int catread (char *catfile); /* Reads a catfile into the hash */ |
char *processEscChars (char *line); /* Converts c escape sequences to chars */ |
int get_char (int file); /* not meant for external use */ |
/* external use would cause consistency problems if */ |
/* value or related file of the file handle changes */ |
int mystrtoul (char *src, int base, int size); |
/* Globals */ |
nl_catd _kitten_catalog = 0; /* _kitten_catalog descriptor or 0 */ |
char catfile[128]; /* full path to _kitten_catalog */ |
char getlbuf[8192]; /* read buffer for better speed */ |
char *getlp; /* current point in buffer */ |
int getlrem = -1; /* remaining bytes in buffer */ |
char lastcr = 0; /* for 2byte CR LF sequences */ |
#ifndef _MICROC_ |
#ifndef __DJGPP__ |
/* DOS handle based file usage */ |
int |
dos_open (char *filename, int mode) |
{ |
union REGS r; |
struct SREGS s; |
#ifndef __WATCOMC__ |
if (mode); /* mode ignored - readonly supported */ |
#endif |
r.h.ah = 0x3d; |
r.h.al = 0; /* read mode only supoported now !! */ |
r.x.dx = FP_OFF (filename); |
s.ds = FP_SEG (filename); |
intdosx (&r, &r, &s); |
return ((r.x.cflag) ? -1 : (int) r.x.ax); |
} |
int |
dos_read (int file, void *ptr, unsigned count) |
{ |
union REGS r; |
struct SREGS s; |
r.h.ah = 0x3f; |
r.x.bx = file; |
r.x.cx = count; |
r.x.dx = FP_OFF (ptr); |
s.ds = FP_SEG (ptr); |
intdosx (&r, &r, &s); |
return ((r.x.cflag) ? 0 : r.x.ax); |
} |
int |
dos_write (int file, void *ptr, unsigned count) |
{ |
union REGS r; |
struct SREGS s; |
r.h.ah = 0x40; |
r.x.bx = file; |
r.x.cx = count; |
r.x.dx = FP_OFF (ptr); |
s.ds = FP_SEG (ptr); |
intdosx (&r, &r, &s); |
return ((r.x.cflag) ? 0 : r.x.ax); |
} |
void |
dos_close (int file) |
{ |
union REGS r; |
r.h.ah = 0x3e; |
r.x.bx = file; |
intdos (&r, &r); |
} |
#endif /*DJGPP*/ |
#endif /*Micro-C */ |
/* Functions */ |
/** |
* On success, catgets() returns a pointer to an internal |
* buffer area containing the null-terminated message string. |
* On failure, catgets() returns the value 'message'. |
*/ |
char * |
kittengets (int setnum, int msgnum, char *message) |
{ |
/* In Micro-C, variables must be defined at the start of the |
* function and may not be immediately assigned a value |
*/ |
#ifdef _MICROC_ |
int i; |
i = 0; |
#else |
int i = 0; |
#endif |
while ((catpoints[i].key1 != setnum) || (catpoints[i].key2 != msgnum)) |
{ |
if ((catpoints[i].text == NULL) || (i > 127)) /* at EOF */ |
return message; |
i++; |
} |
if (catpoints[i].text == NULL) |
return message; |
else |
return (catpoints[i].text); |
} |
/** |
* Initialize kitten for program (name). |
*/ |
nl_catd |
kittenopen (char *name) |
{ |
/* catopen() returns a message _kitten_catalog descriptor * |
* of type nl_catd on success. On failure, it returns -1. */ |
char catlang[3]; /* from LANG environment var. */ |
char *nlsptr; /* ptr to NLSPATH */ |
char *lang; /* ptr to LANG */ |
int i; |
#ifdef _MICROC_ |
char *tok; |
int toklen; |
#endif |
/* Open the _kitten_catalog file */ |
/* The value of `_kitten_catalog' will be set based on catread */ |
if (_kitten_catalog) |
{ /* Already one open */ |
write (1, "cat already open\r\n", strlen ("cat already open\r\n")); |
return (-1); |
} |
for (i = 0; i < 128; i++) |
catpoints[i].text = NULL; |
if (strchr (name, '\\')) |
{ |
/* unusual case: 'name' is a filename */ |
write (1, "found \\\r\n", 9); |
_kitten_catalog = catread (name); |
if (_kitten_catalog) |
return (_kitten_catalog); |
} |
/* If the message _kitten_catalog file name does not contain a directory * |
* separator, then we need to try to locate the message _kitten_catalog. */ |
/* We will need the value of LANG, and may need a 2-letter abbrev of |
LANG later on, so get it now. */ |
lang = getenv ("LANG"); |
if (lang == NULL) |
{ |
/* printf("no lang= found\n"); *//* not fatal, though */ |
/* Return failure - we won't be able to locate the cat file */ |
return (-1); |
} |
if ((strlen (lang) < 2) || ((strlen (lang) > 2) && (lang[2] != '-'))) |
{ |
/* Return failure - we won't be able to locate the cat file */ |
return (-1); |
} |
memcpy (catlang, lang, 2); |
/* we copy the full LANG value or the part before "-" if "-" found */ |
catlang[2] = '\0'; |
/* step through NLSPATH */ |
nlsptr = getenv ("NLSPATH"); |
if (nlsptr == NULL) |
{ |
/* printf("no NLSPATH= found\n"); *//* not fatal either */ |
/* Return failure - we won't be able to locate the cat file */ |
return (-1); |
} |
catfile[0] = '\0'; |
while (nlsptr && nlsptr[0]) |
{ |
#ifdef _MICROC_ |
tok = strchr (nlsptr, ';'); |
#else |
char *tok = strchr (nlsptr, ';'); |
int toklen; |
#endif |
if (tok == NULL) |
toklen = strlen (nlsptr); /* last segment */ |
else |
toklen = tok - nlsptr; /* segment terminated by ';' */ |
/* catfile = malloc(toklen+1+strlen(name)+1+strlen(lang)+1); */ |
/* Try to find the _kitten_catalog file in each path from NLSPATH */ |
if ((toklen + 6 + strlen (name)) > sizeof (catfile)) |
{ |
write (1, "NLSPATH overflow\r\n", strlen ("NLSPATH overflow\r\n")); |
return 0; /* overflow in NLSPATH, should never happen */ |
} |
/* Rule #1: %NLSPATH%\%LANG%\cat */ |
memcpy (catfile, nlsptr, toklen); |
strcpy (catfile + toklen, "\\"); |
strcat (catfile, catlang); |
strcat (catfile, "\\"); |
strcat (catfile, name); |
_kitten_catalog = catread (catfile); |
if (_kitten_catalog) |
return (_kitten_catalog); |
/* Rule #2: %NLSPATH%\cat.%LANG% */ |
/* memcpy(catfile, nlsptr, toklen); */ |
strcpy (catfile + toklen, "\\"); |
strcat (catfile, name); |
strcat (catfile, "."); |
strcat (catfile, catlang); |
_kitten_catalog = catread (catfile); |
if (_kitten_catalog) |
return (_kitten_catalog); |
/* Grab next tok for the next while iteration */ |
nlsptr = tok; |
if (nlsptr) |
nlsptr++; |
} /* while tok */ |
/* We could not find it. Return failure. */ |
return (-1); |
} |
/** |
* Load a message catalog into memory. |
*/ |
int |
catread (char *catfile) |
{ |
int file; /* pointer to the catfile */ |
int i; |
char *where; |
char *tok; |
#ifdef _MICROC_ |
char *msg; |
char *key; |
int key1; |
int key2; |
#endif |
/* Get the whole catfile into a buffer and parse it */ |
file = open (catfile, O_RDONLY | O_TEXT); |
if (file < 0) |
/* Cannot open the file. Return failure */ |
return 0; |
for (i = 0; i < 128; i++) |
catpoints[i].text = NULL; |
for (i = 0; (unsigned int) i < sizeof (catcontents); i++) |
catcontents[i] = '\0'; |
/* Read the file into memory */ |
i = read (file, catcontents, sizeof (catcontents) - 1); |
if ((i == sizeof (catcontents) - 1) || (i < 1)) |
return 0; /* file was too big or too small */ |
where = catcontents; |
i = 0; /* catpoints entry */ |
do |
{ |
#ifndef _MICROC_ |
char *msg; |
char *key; |
int key1 = 0; |
int key2 = 0; |
#else |
key1 = 0; |
key2 = 0; |
#endif |
tok = strchr (where, '\n'); |
if (tok == NULL) |
{ /* done? */ |
close (file); |
return 1; /* success */ |
} |
tok[0] = '\0'; /* terminate here */ |
tok--; /* guess: \r before \n */ |
if (tok[0] != '\r') |
tok++; /* if not, go back */ |
else |
{ |
tok[0] = '\0'; /* terminate here already */ |
tok++; |
} |
tok++; /* this is where the next line starts */ |
if ((where[0] >= '0') && (where[0] <= '9') && |
((msg = strchr (where, ':')) != NULL)) |
{ |
/* Skip everything which starts with # or with no digit */ |
/* Entries look like "1.2:This is a message" */ |
msg[0] = '\0'; /* remove : */ |
msg++; /* go past the : */ |
if ((key = strchr (where, '.')) != NULL) |
{ |
key[0] = '\0'; /* turn . into terminator */ |
key++; /* go past the . */ |
key1 = mystrtoul (where, 10, strlen (where)); |
key2 = mystrtoul (key, 10, strlen (key)); |
if ((key1 >= 0) && (key2 >= 0)) |
{ |
catpoints[i].key1 = key1; |
catpoints[i].key2 = key2; |
catpoints[i].text = processEscChars (msg); |
if (catpoints[i].text == NULL) /* ESC parse error */ |
catpoints[i].text = msg; |
i++; /* next entry! */ |
} /* valid keys */ |
} /* . found */ |
} /* : and digit found */ |
where = tok; /* go to next line */ |
} |
while (1); |
#ifdef __PACIFIC__ |
return 0; |
#endif |
} |
void |
kittenclose (void) |
{ |
/* close a message _kitten_catalog */ |
_kitten_catalog = 0; |
} |
/** |
* Parse a string that represents an unsigned integer. |
* Returns -1 if an error is found. The first size |
* chars of the string are parsed. |
*/ |
int |
mystrtoul (char *src, int base, int size) |
{ |
#ifdef _MICROC_ |
int ret; |
int digit; |
int ch; |
ret = 0; |
#else |
int ret = 0; |
#endif |
for (; size > 0; size--) |
{ |
#ifdef _MICROC_ |
ch = *src; |
#else |
int digit; |
int ch = *src; |
#endif |
src++; |
if (ch >= '0' && ch <= '9') |
digit = ch - '0'; |
else if (ch >= 'A' && ch <= 'Z') |
digit = ch - 'A' + 10; |
else if (ch >= 'a' && ch <= 'z') |
digit = ch - 'a' + 10; |
else |
return -1; |
if (digit >= base) |
return -1; |
ret = ret * base + digit; |
} /* for */ |
return ret; |
} |
/** |
* Process strings, converting \n, \t, \v, \b, \r, \f, \\, |
* \ddd, \xdd and \x0dd to actual chars. |
* (Note: \x is an extension to support hexadecimal) |
* This is used to allow the messages to use c escape sequences. |
* Modifies the line in-place (always same size or shorter). |
* Returns a pointer to input string. |
*/ |
char * |
processEscChars (char *line) |
{ |
/* used when converting \xdd and \ddd (hex or octal) characters */ |
char ch; |
#ifdef _MICROC_ |
char *src; |
char *dst; |
int chx; |
src = line; |
dst = line; |
#else |
char *src = line; |
char *dst = line; /* possible as dst is shorter than src */ |
#endif |
if (line == NULL) |
return line; |
/* cycle through copying characters, except when a \ is encountered. */ |
while (*src != '\0') |
{ |
ch = *src; |
src++; |
if (ch == '\\') |
{ |
ch = *src; /* what follows slash? */ |
src++; |
switch (ch) |
{ |
case '\\': /* a single slash */ |
*dst = '\\'; |
dst++; |
break; |
case 'n': /* a newline (linefeed) */ |
*dst = '\n'; |
dst++; |
break; |
case 'r': /* a carriage return */ |
*dst = '\r'; |
dst++; |
break; |
case 't': /* a horizontal tab */ |
*dst = '\t'; |
dst++; |
break; |
case 'v': /* a vertical tab */ |
*dst = '\v'; |
dst++; |
break; |
case 'b': /* a backspace */ |
*dst = '\b'; |
dst++; |
break; |
case 'a': /* alert */ |
*dst = '\a'; |
dst++; |
break; |
case 'f': /* formfeed */ |
*dst = '\f'; |
dst++; |
break; |
case 'x': /* extension supporting hex numbers \xdd or \x0dd */ |
{ |
#ifdef _MICROC_ |
chx = mystrtoul (src, 16, 2); /* get value */ |
#else |
int chx = mystrtoul (src, 16, 2); /* get value */ |
#endif |
if (chx >= 0) |
{ /* store character */ |
*dst = chx; |
dst++; |
src += 2; |
} |
else /* error so just store x (loose slash) */ |
{ |
*dst = *src; |
dst++; |
} |
} |
break; |
default: /* just store letter (loose slash) or handle octal */ |
{ |
#ifdef _MICROC_ |
chx = mystrtoul (src, 8, 3); /* get value */ |
#else |
int chx = mystrtoul (src, 8, 3); /* get value */ |
#endif |
if (chx >= 0) |
{ /* store character */ |
*dst = chx; |
dst++; |
src += 3; |
} |
else |
{ |
*dst = *src; |
dst++; |
} |
} |
break; |
} /* switch */ |
} /* if backslash */ |
else |
{ |
*dst = ch; |
dst++; |
} |
} /* while */ |
/* ensure '\0' terminated */ |
*dst = '\0'; |
return line; |
} |
int |
get_char (int file) |
{ |
#ifdef _MICROC_ |
int rval; |
rval = -1; |
#else |
int rval = -1; |
#endif |
if (getlrem <= 0) |
{ /* (re)init buffer */ |
getlrem = read (file, getlbuf, sizeof (getlbuf)); |
if (getlrem <= 0) |
return -1; /* fail: read error / EOF */ |
getlp = getlbuf; /* init pointer */ |
} |
if (getlrem > 0) |
{ /* consume byte from buffer */ |
rval = getlp[0]; |
getlp++; |
getlrem--; |
} |
return rval; |
} |
/** |
* Read a line of text from file. You must call this with |
* a null buffer or null size to flush buffers when you are |
* done with a file before using it on the next file. Cannot |
* be used for 2 files at the same time. |
*/ |
int |
get_line (int file, char *str, int size) |
{ |
int ch; |
#ifdef _MICROC_ |
int success; |
success = 0; |
#else |
int success = 0; |
#endif |
if ((size == 0) || (str == NULL)) |
{ /* re-init get_line buffers */ |
getlp = getlbuf; |
getlrem = -1; |
lastcr = 0; |
return 0; |
} |
str[0] = '\0'; |
while ((size > 0) && (success == 0)) |
{ |
ch = get_char (file); |
if (ch < 0) |
break; /* (can cause fail if no \n found yet) */ |
if (ch == '\r') |
ch = get_char (file); /* ignore \r */ |
str[0] = ch; |
if ((ch == '\n') || (ch == '\r')) |
{ /* done? */ |
str[0] = '\0'; |
return 1; /* success */ |
} |
str++; |
size--; |
} /* while */ |
str[0] = '\0'; /* terminate buffer */ |
return success; |
} |
#endif /*NO_KITTEN */ |
/pkginst/kitten/kitten.h |
---|
0,0 → 1,78 |
/* Functions that emulate UNIX catgets, some small DOS file functions */ |
/* Copyright (C) 1999,2000 Jim Hall <jhall@freedos.org> */ |
/* Kitten version by Tom Ehlert, heavily modified by Eric Auer 2003 */ |
/* |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Lesser General Public |
License as published by the Free Software Foundation; either |
version 2.1 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Lesser General Public License for more details. |
You should have received a copy of the GNU Lesser General Public |
License along with this library; if not, write to the Free Software |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
*/ |
#ifndef _CATGETS_H |
#define _CATGETS_H |
#ifdef __cplusplus |
extern "C" |
{ |
#endif |
#ifdef NO_KITTEN |
#define kittengets(x,y,z) (z) |
#define kittenclose() |
#define kittenopen(a) |
#else |
/* Data types */ |
#define nl_catd int |
/* Functions */ |
#define catgets(catalog, set,message_number,message) kittengets(set,message_number,message) |
#define catopen(name,flag) kittenopen(name) |
#define catclose(catalog) kittenclose() |
char *kittengets (int set_number, int message_number, char *message); |
nl_catd kittenopen (char *name); |
void kittenclose (void); |
int get_line (int file, char *buffer, int size); |
#ifndef _MICROC_ |
#ifndef __DJGPP__ |
int dos_open (char *filename, int mode); |
#define open(filename,mode) dos_open(filename,mode) |
int dos_read (int file, void *ptr, unsigned count); |
#define read(file, ptr, count) dos_read(file,ptr,count) |
int dos_write (int file, void *ptr, unsigned count); |
#define write(file, ptr, count) dos_write(file,ptr,count) |
void dos_close (int file); |
#define close(file) dos_close(file) |
#endif /*DJGPP*/ |
#endif /*Micro-C */ |
#endif /*NO_KITTEN */ |
#ifdef __cplusplus |
} |
#endif |
#endif /* _CATGETS_H */ |
/pkginst/kprintf.c |
---|
0,0 → 1,24 |
/* |
* This file provides dummy functions that simulate kitten-enabled routines |
* without actually having kitten. |
* |
* Copyright (C) 2015-2021 Mateusz Viste |
*/ |
#include <stdio.h> /* vprintf() */ |
#include <stdarg.h> /* va_list, va_start()... */ |
#include "kitten/kitten.h" |
#include "kprintf.h" |
void kitten_printf(short x, short y, char *fmt, ...) { |
va_list args; |
va_start(args, fmt); |
vprintf(kittengets(x, y, fmt), args); |
va_end(args); |
} |
void kitten_puts(short x, short y, char *fmt) { |
puts(kittengets(x, y, fmt)); |
} |
/pkginst/kprintf.h |
---|
0,0 → 1,12 |
/* |
* The following is a macro-like function that uses kitten instead |
* of directly doing printf. |
*/ |
#ifndef kprintf_sentinel |
#define kprintf_sentinel |
void kitten_printf(short x, short y, char *fmt, ...); |
void kitten_puts(short x, short y, char *fmt); |
#endif |
/pkginst/libunzip.c |
---|
0,0 → 1,257 |
/* |
* This file is part of the FDNPKG project |
* http://fdnpkg.sourceforge.net |
* |
* Copyright (C) 2012-2016 Mateusz Viste. All rights reserved. |
* |
* Simple library providing functions to unzip files from zip archives. |
*/ |
#include <stdio.h> /* printf(), FILE, fclose()... */ |
#include <stdlib.h> /* NULL */ |
#include <string.h> /* memset() */ |
#include <time.h> /* mktime() */ |
#include <utime.h> /* utime() */ |
#include <unistd.h> /* unlink() */ |
#include "crc32.h" |
#include "kprintf.h" |
#include "parsecmd.h" |
#include "inf.h" /* DEFLATE support */ |
#include "version.h" |
#include "libunzip.h" /* include self for control */ |
/* converts a "DOS format" timestamp into unix timestamp. The DOS timestamp is constructed an array of 4 bytes, that contains following data at the bit level: |
* HHHHHMMM MMMSSSSS YYYYYYYM MMMDDDDD |
* where: |
* day of month is always within 1-31 range; |
* month is always within 1-12 range; |
* year starts from 1980 and continues for 127 years |
* seconds are actually not 0-59 but rather 0-29 as there are only 32 possible values – to get actual seconds multiply this field by 2; |
* minutes are always within 0-59 range; |
* hours are always within 0-23 range. */ |
static time_t dostime2unix(unsigned char *buff) { |
struct tm curtime; |
time_t result; |
memset(&curtime, 0, sizeof(curtime)); /* make sure to set everything in curtime to 0's */ |
curtime.tm_sec = (buff[0] & 31) << 1; /* seconds (0..60) */ |
curtime.tm_min = (((buff[1] << 8) | buff[0]) >> 5) & 63 ; /* minutes after the hour (0..59) */ |
curtime.tm_hour = (buff[1] >> 3); /* hours since midnight (0..23) */ |
curtime.tm_mday = buff[2] & 31; /* day of the month (1..31) */ |
curtime.tm_mon = ((((buff[3] << 8) | buff[2]) >> 5) & 15) - 1; /* months since January (0, 11) */ |
curtime.tm_year = (buff[3] >> 1) + 80; /* years since 1900 */ |
curtime.tm_wday = 0; /* days since Sunday (0..6) - leave 0, mktime() will set it */ |
curtime.tm_yday = 0; /* days since January 1 (0..365]) - leave 0, mktime() will set it */ |
curtime.tm_isdst = -1; /* Daylight Saving Time flag. Positive if DST is in effect, zero if not and negative if no information is available */ |
result = mktime(&curtime); |
if (result == (time_t)-1) return(0); |
return(result); |
} |
/* opens a zip file and provides the list of files in the archive. |
returns a pointer to a ziplist (linked list) with all records, or NULL on error. |
The ziplist is allocated automatically, and must be freed via zip_freelist. */ |
struct ziplist *zip_listfiles(FILE *fd) { |
struct ziplist *reslist = NULL; |
struct ziplist *newentry; |
unsigned long entrysig; |
unsigned short filenamelen, extrafieldlen, filecommentlen; |
unsigned long compfilelen; |
int centraldirectoryfound = 0; |
unsigned int ux; |
unsigned char hdrbuff[64]; |
rewind(fd); /* make sure the file cursor is at the very beginning of the file */ |
for (;;) { /* read entry after entry */ |
int x, eofflag; |
long longbuff; |
entrysig = 0; |
eofflag = 0; |
/* read the entry signature first */ |
for (x = 0; x < 32; x += 8) { |
if ((longbuff = fgetc(fd)) == EOF) { |
eofflag = 1; |
break; |
} |
entrysig |= (longbuff << x); |
} |
if (eofflag != 0) break; |
/* printf("sig: 0x%08x\n", entrysig); */ |
if (entrysig == 0x04034b50ul) { /* local file */ |
unsigned int generalpurposeflags; |
/* read and parse the zip header */ |
fread(hdrbuff, 1, 26, fd); |
/* read filename's length so I can allocate the proper amound of mem */ |
filenamelen = hdrbuff[23]; |
filenamelen <<= 8; |
filenamelen |= hdrbuff[22]; |
/* create new entry and link it into the list */ |
newentry = calloc(sizeof(struct ziplist) + filenamelen, 1); |
if (newentry == NULL) { |
kitten_puts(8, 0, "Out of memory!"); |
zip_freelist(&reslist); |
break; |
} |
newentry->nextfile = reslist; |
newentry->flags = 0; |
reslist = newentry; |
/* read further areas of the header, and fill zip entry */ |
generalpurposeflags = hdrbuff[3]; /* parse the general */ |
generalpurposeflags <<= 8; /* purpose flags and */ |
generalpurposeflags |= hdrbuff[2]; /* save them for later */ |
newentry->compmethod = hdrbuff[4] | (hdrbuff[5] << 8); |
newentry->timestamp = dostime2unix(&hdrbuff[6]); |
newentry->crc32 = 0; |
for (x = 13; x >= 10; x--) { |
newentry->crc32 <<= 8; |
newentry->crc32 |= hdrbuff[x]; |
} |
newentry->compressedfilelen = 0; |
for (x = 17; x >= 14; x--) { |
newentry->compressedfilelen <<= 8; |
newentry->compressedfilelen |= hdrbuff[x]; |
} |
newentry->filelen = 0; |
for (x = 21; x >= 18; x--) { |
newentry->filelen <<= 8; |
newentry->filelen |= hdrbuff[x]; |
} |
extrafieldlen = hdrbuff[25]; |
extrafieldlen <<= 8; |
extrafieldlen |= hdrbuff[24]; |
/* printf("Filename len: %d / extrafield len: %d / compfile len: %ld / filelen: %ld\n", filenamelen, extrafieldlen, newentry->compressedfilelen, newentry->filelen); */ |
/* check general purpose flags */ |
if ((generalpurposeflags & 1) != 0) newentry->flags |= ZIP_FLAG_ENCRYPTED; |
/* parse the filename */ |
for (ux = 0; ux < filenamelen; ux++) newentry->filename[ux] = fgetc(fd); /* store filename */ |
if (newentry->filename[filenamelen - 1] == '/') newentry->flags |= ZIP_FLAG_ISADIR; /* if filename ends with / it's a dir. Note that ZIP forbids the usage of '\' in ZIP paths anyway */ |
/* printf("Filename: %s (%ld bytes compressed)\n", newentry->filename, newentry->compressedfilelen); */ |
newentry->dataoffset = ftell(fd) + extrafieldlen; |
/* skip rest of fields and data */ |
fseek(fd, (extrafieldlen + newentry->compressedfilelen), SEEK_CUR); |
} else if (entrysig == 0x02014b50ul) { /* central directory */ |
centraldirectoryfound = 1; |
/* parse header now */ |
fread(hdrbuff, 1, 42, fd); |
filenamelen = hdrbuff[22] | (hdrbuff[23] << 8); |
extrafieldlen = hdrbuff[24] | (hdrbuff[25] << 8); |
filecommentlen = hdrbuff[26] | (hdrbuff[27] << 8); |
compfilelen = 0; |
for (x = 17; x >= 14; x--) { |
compfilelen <<= 8; |
compfilelen |= hdrbuff[x]; |
} |
/* printf("central dir\n"); */ |
/* skip rest of fields and data */ |
fseek(fd, (filenamelen + extrafieldlen + compfilelen + filecommentlen), SEEK_CUR); |
} else if (entrysig == 0x08074b50ul) { /* Data descriptor header */ |
/* no need to read the header we just have to skip it */ |
fseek(fd, 12, SEEK_CUR); /* the header is 3x4 bytes (CRC + compressed len + uncompressed len) */ |
} else { /* unknown sig */ |
kitten_printf(8, 1, "unknown zip sig: 0x%08lx", entrysig); |
puts(""); |
zip_freelist(&reslist); |
break; |
} |
} |
/* if we got no central directory record, the file is incomplete */ |
if (centraldirectoryfound == 0) zip_freelist(&reslist); |
return(reslist); |
} |
/* unzips a file. zipfd points to the open zip file, curzipnode to the entry to extract, and fulldestfilename is the destination file where to unzip it. returns 0 on success, non-zero otherwise. */ |
int zip_unzip(FILE *zipfd, struct ziplist *curzipnode, char *fulldestfilename) { |
#define buffsize 32 * 1024l /* MUST be at least 32K */ |
FILE *filefd; |
unsigned long cksum; |
int extract_res; |
unsigned char *buff; |
struct utimbuf filetimestamp; |
/* first of all, check we support the compression method */ |
switch (curzipnode->compmethod) { |
case 0: /* stored */ |
case 8: /* deflated */ |
break; |
default: /* unsupported compression method, sorry */ |
return(-1); |
break; |
} |
/* open the dst file */ |
filefd = fopen(fulldestfilename, "wb"); |
if (filefd == NULL) return(-2); /* failed to open the dst file */ |
/* allocate buffers for data I/O */ |
buff = malloc(buffsize); |
if (buff == NULL) { |
fclose(filefd); |
unlink(fulldestfilename); /* remove the failed file once it is closed */ |
return(-6); |
} |
if (fseek(zipfd, curzipnode->dataoffset, SEEK_SET) != 0) { /* set the reading position inside the zip file */ |
free(buff); |
fclose(filefd); |
unlink(fulldestfilename); /* remove the failed file once it is closed */ |
return(-7); |
} |
extract_res = -255; |
cksum = crc32_init(); /* init the crc32 */ |
if (curzipnode->compmethod == 0) { /* if the file is stored, copy it over */ |
long i, toread; |
extract_res = 0; /* assume we will succeed */ |
for (i = 0; i < curzipnode->filelen;) { |
toread = curzipnode->filelen - i; |
if (toread > buffsize) toread = buffsize; |
if (fread(buff, toread, 1, zipfd) != 1) extract_res = -3; /* read a chunk of data */ |
crc32_feed(&cksum, buff, toread); /* update the crc32 checksum */ |
if (fwrite(buff, toread, 1, filefd) != 1) extract_res = -4; /* write data chunk to dst file */ |
i += toread; |
} |
} else if (curzipnode->compmethod == 8) { /* if the file is deflated, inflate it */ |
extract_res = inf(zipfd, filefd, buff, &cksum, curzipnode->compressedfilelen); |
} |
/* clean up memory, close the dst file and terminates crc32 */ |
free(buff); |
fclose(filefd); /* close the dst file */ |
crc32_finish(&cksum); |
/* printf("extract_res=%d / cksum_expected=%08lX / cksum_obtained=%08lX\n", extract_res, curzipnode->crc32, cksum); */ |
if (extract_res != 0) { /* was the extraction process successful? */ |
unlink(fulldestfilename); /* remove the failed file */ |
return(extract_res); |
} |
if (cksum != curzipnode->crc32) { /* is the crc32 ok after extraction? */ |
unlink(fulldestfilename); /* remove the failed file */ |
return(-9); |
} |
/* Set the timestamp of the new file to what was set in the zip file */ |
filetimestamp.actime = curzipnode->timestamp; |
filetimestamp.modtime = curzipnode->timestamp; |
utime(fulldestfilename, &filetimestamp); |
return(0); |
} |
/* Call this to free a ziplist computed by zip_listfiles() */ |
void zip_freelist(struct ziplist **ziplist) { |
struct ziplist *zipentrytobefreed; |
while (*ziplist != NULL) { /* iterate through the linked list and free all nodes */ |
zipentrytobefreed = *ziplist; |
*ziplist = zipentrytobefreed->nextfile; |
/* free the node entry */ |
free(zipentrytobefreed); |
} |
*ziplist = NULL; |
} |
/pkginst/libunzip.h |
---|
0,0 → 1,35 |
/* |
* This file is part of the FDNPKG project |
* http://fdnpkg.sourceforge.net |
* |
* Copyright (C) 2012-2016 Mateusz Viste. All rights reserved. |
* |
* Simple library providing functions to unzip files from zip archives. |
*/ |
#ifndef libunzip_sentinel |
#define libunzip_sentinel |
#include <time.h> /* required for the time_t definition */ |
#define ZIP_FLAG_ISADIR 1 |
#define ZIP_FLAG_ENCRYPTED 2 |
struct ziplist { |
long filelen; |
long compressedfilelen; |
unsigned long crc32; |
long dataoffset; /* offset in the file where compressed data starts */ |
struct ziplist *nextfile; |
time_t timestamp; /* the timestamp of the file */ |
short compmethod; |
unsigned char flags; /* zero for files, non-zero for directories */ |
char filename[1]; /* must be last element (gets expanded at runtime) */ |
}; |
struct ziplist *zip_listfiles(FILE *fd); |
int zip_unzip(FILE *zipfd, struct ziplist *curzipnode, char *fulldestfilename); |
void zip_freelist(struct ziplist **ziplist); |
#endif |
/pkginst/loadconf.c |
---|
0,0 → 1,296 |
/* |
* This file is part of pkginst (SvarDOS). |
* |
* Loads the list of repositories from a config file. |
* |
* Copyright (C) 2012-2021 Mateusz Viste |
*/ |
#include <stdio.h> /* printf(), fclose(), fopen()... */ |
#include <string.h> /* strcasecmp() */ |
#include <stdlib.h> /* malloc(), free() */ |
#include "fdnpkg.h" /* PKGINST_SKIPLINKS... */ |
#include "helpers.h" /* slash2backslash(), removeDoubleBackslashes()... */ |
#include "kprintf.h" |
#include "loadconf.h" |
#include "parsecmd.h" |
void freeconf(struct customdirs **dirlist) { |
struct customdirs *curpos; |
/* free the linked list of custom dirs */ |
while (*dirlist != NULL) { |
curpos = *dirlist; |
*dirlist = (*dirlist)->next; |
free(curpos); |
} |
} |
static int checkfordoubledirlist(const struct customdirs *dirlist) { |
struct customdirs *curpos; |
for (; dirlist != NULL; dirlist = dirlist->next) { |
for (curpos = dirlist->next; curpos != NULL; curpos = curpos->next) { |
if (strcasecmp(curpos->name, dirlist->name) == 0) { |
kitten_printf(7, 0, "Error: custom dir '%s' is listed twice!", curpos->name); |
puts(""); |
return(-1); |
} |
} |
} |
return(0); |
} |
/* validates dirlist entries: check that they are absolute paths and are not using restricted names */ |
static int validatedirlist(const struct customdirs *dirlist) { |
for (; dirlist != NULL; dirlist = dirlist->next) { |
/* the location must be at least 3 characters long to be a valid absolute path (like 'c:\')*/ |
if (strlen(dirlist->location) < 3) { |
kitten_printf(7, 15, "Error: custom dir '%s' is not a valid absolute path!", dirlist->name); |
puts(""); |
return(-1); |
} |
/* is it a valid absolute path? should start with [a..Z]:\ */ |
if ((dirlist->location[1] != ':') || |
((dirlist->location[2] != '/') && (dirlist->location[2] != '\\')) || |
(((dirlist->location[0] < 'a') || (dirlist->location[0] > 'z')) && ((dirlist->location[0] < 'A') || (dirlist->location[0] > 'Z')))) { |
kitten_printf(7, 15, "Error: custom dir '%s' is not a valid absolute path!", dirlist->name); |
puts(""); |
return(-1); |
} |
/* check for forbidden names */ |
if ((strcasecmp(dirlist->name, "appinfo") == 0) || |
(strcasecmp(dirlist->name, "bin") == 0) || |
(strcasecmp(dirlist->name, "doc") == 0) || |
(strcasecmp(dirlist->name, "help") == 0) || |
(strcasecmp(dirlist->name, "nls") == 0) || |
(strcasecmp(dirlist->name, "packages") == 0)) { |
kitten_printf(7, 16, "Error: custom dir '%s' is a reserved name!", dirlist->name); |
puts(""); |
return(-1); |
} |
} |
return(0); |
} |
/* add (and allocates) a new custom dir entry to dirlist. Returns 0 on success, |
or non-zero on failure (failures happen on out of memory events). */ |
static int addnewdir(struct customdirs **dirlist, const char *name, const char *location) { |
struct customdirs *newentry; |
if (strlen(name) >= sizeof(newentry->name)) return(-2); |
newentry = malloc(sizeof(struct customdirs) + strlen(location) + 1); |
if (newentry == NULL) return(-1); |
strcpy(newentry->name, name); |
strcpy(newentry->location, location); |
newentry->next = *dirlist; |
*dirlist = newentry; |
return(0); |
} |
int loadconf(const char *dosdir, struct customdirs **dirlist, int *flags) { |
int bytebuff, parserstate = 0; |
FILE *fd; |
#define maxtok 16 |
char token[maxtok]; |
#define maxval 256 |
char value[maxval]; |
char cfgfile[256]; |
int curtok = 0, curval = 0, nline = 1; |
snprintf(cfgfile, sizeof(cfgfile), "%s\\cfg\\pkginst.cfg", dosdir); |
fd = fopen(cfgfile, "r"); |
if (fd == NULL) { |
kitten_printf(7, 1, "Error: Could not open config file (%s)!", cfgfile); |
puts(""); |
return(-1); |
} |
/* read the config file line by line */ |
do { |
bytebuff = fgetc(fd); |
if (bytebuff != '\r') { |
switch (parserstate) { |
case 0: /* Looking for start of line */ |
if ((bytebuff == EOF) || (bytebuff == ' ') || (bytebuff == '\t')) break; |
if (bytebuff == '\n') { |
nline += 1; |
break; |
} |
if (bytebuff == '#') { |
parserstate = 9; |
} else { |
token[0] = bytebuff; |
curtok = 1; |
parserstate = 1; |
} |
break; |
case 1: /* Looking for token end */ |
if ((bytebuff == EOF) || (bytebuff == '\n')) { |
kitten_printf(7, 2, "Warning: token without value on line #%d", nline); |
puts(""); |
if (bytebuff == '\n') nline += 1; |
parserstate = 0; |
break; |
} |
if ((bytebuff == ' ') || (bytebuff == '\t')) { |
token[curtok] = 0; |
parserstate = 2; |
} else { |
token[curtok] = bytebuff; |
curtok += 1; |
if (curtok >= maxtok) { |
parserstate = 9; /* ignore the line */ |
kitten_printf(7, 3, "Warning: Config file token overflow on line #%d", nline); |
puts(""); |
} |
} |
break; |
case 2: /* Looking for value start */ |
if ((bytebuff == EOF) || (bytebuff == '\n')) { |
kitten_printf(7, 4, "Warning: token with empty value on line #%d", nline); |
puts(""); |
if (bytebuff == '\n') nline += 1; |
parserstate = 0; |
break; |
} |
if ((bytebuff != ' ') && (bytebuff != '\t')) { |
value[0] = bytebuff; |
curval = 1; |
parserstate = 3; |
} |
break; |
case 3: /* Looking for value end */ |
if ((bytebuff == EOF) || (bytebuff == '\n')) { |
parserstate = 0; |
value[curval] = 0; |
if ((value[curval - 1] == ' ') || (value[curval - 1] == '\t')) { |
kitten_printf(7, 5, "Warning: trailing white-space(s) after value on line #%d", nline); |
puts(""); |
while ((value[curval - 1] == ' ') || (value[curval - 1] == '\t')) value[--curval] = 0; |
} |
/* Interpret the token/value pair now! */ |
/* printf("token='%s' ; value = '%s'\n", token, value); */ |
if (strcasecmp(token, "SKIPLINKS") == 0) { |
int tmpint = atoi(value); /* must be 0/1 */ |
if (tmpint == 0) { |
/* do nothing */ |
} else if (tmpint == 1) { |
*flags |= PKGINST_SKIPLINKS; |
} else { |
kitten_printf(7, 10, "Warning: Ignored an illegal '%s' value at line #%d", "skiplinks", nline); |
puts(""); |
} |
} else if (strcasecmp(token, "DIR") == 0) { /* custom repository entry */ |
char *argv[2], *evar, *evar_content, *realLocation; |
#define realLocation_len 512 |
int x, y; |
if (parsecmd(value, argv, 2) != 2) { |
kitten_printf(7, 11, "Warning: Invalid 'DIR' directive found at line #%d", nline); |
puts(""); |
} |
realLocation = malloc(realLocation_len); |
if (realLocation == NULL) { |
kitten_printf(2, 14, "Out of memory! (%s)", "malloc realLocation"); |
puts(""); |
freeconf(dirlist); |
fclose(fd); |
return(-1); |
} |
realLocation[0] = 0; /* force it to be empty, since we might use strcat() on this later! */ |
/* resolve possible env variables */ |
evar = NULL; |
y = 0; |
for (x = 0; argv[1][x] != 0; x++) { |
if (evar == NULL) { /* searching for % and copying */ |
if (argv[1][x] == '%') { |
evar = &argv[1][x+1]; |
} else { |
if (y + 1 > realLocation_len) { |
kitten_printf(7, 12, "Error: DIR path too long at line #%d", nline); |
puts(""); |
freeconf(dirlist); |
free(realLocation); |
fclose(fd); |
return(-1); |
} |
realLocation[y] = argv[1][x]; /* copy over */ |
y++; |
realLocation[y] = 0; /* make sure to terminate the string at any time */ |
} |
} else { /* reading a % variable */ |
if (argv[1][x] == '%') { |
argv[1][x] = 0; |
evar_content = getenv(evar); |
if (evar_content == NULL) { |
kitten_printf(7, 13, "Error: Found inexisting environnement variable '%s' at line #%d", evar, nline); |
puts(""); |
freeconf(dirlist); |
free(realLocation); |
fclose(fd); |
return(-1); |
} |
if (strlen(evar_content) + y + 1 > realLocation_len) { |
kitten_printf(7, 12, "Error: DIR path too long at line #%d", nline); |
puts(""); |
freeconf(dirlist); |
free(realLocation); |
fclose(fd); |
return(-1); |
} |
strcat(realLocation, evar_content); |
y += strlen(evar_content); |
evar = NULL; |
} |
} |
} |
/* add the entry to the list */ |
slash2backslash(realLocation); |
removeDoubleBackslashes(realLocation); |
if (realLocation[strlen(realLocation) - 1] != '\\') strcat(realLocation, "\\"); /* make sure to end dirs with a backslash */ |
if (addnewdir(dirlist, argv[0], realLocation) != 0) { |
kitten_printf(2, 14, "Out of memory! (%s)", "addnewdir"); |
puts(""); |
freeconf(dirlist); |
free(realLocation); |
fclose(fd); |
return(-1); |
} |
free(realLocation); |
} else { /* unknown token */ |
kitten_printf(7, 8, "Warning: Unknown token '%s' at line #%d", token, nline); |
puts(""); |
} |
/* interpretation done */ |
if (bytebuff == '\n') nline += 1; |
} else { |
value[curval] = bytebuff; |
curval += 1; |
if ((curval + 1) >= maxval) { |
parserstate = 9; /* ignore the line */ |
kitten_printf(7, 9, "Warning: Config file value overflow on line #%d", nline); |
puts(""); |
} |
} |
break; |
case 9: /* Got comment, ignoring the rest of line */ |
if (bytebuff == EOF) break; |
if (bytebuff == '\n') { |
nline += 1; |
parserstate = 0; |
} |
break; |
} |
} |
} while (bytebuff != EOF); |
fclose(fd); |
/* perform some validations */ |
if (checkfordoubledirlist(*dirlist) != 0) return(-1); |
if (validatedirlist(*dirlist) != 0) return(-1); |
return(0); |
} |
/pkginst/loadconf.h |
---|
0,0 → 1,23 |
/* |
* This file is part of pkginst. |
* |
* Copyright (C) 2012-2021 Mateusz Viste |
*/ |
#ifndef loadrepolist_sentinel |
#define loadrepolist_sentinel |
struct customdirs { |
struct customdirs *next; |
char name[9]; |
char location[1]; /* extended at alloc time */ |
}; |
/* Loads the list of custom directories from the config file |
* Returns 0 on success, or -1 on failure. */ |
int loadconf(const char *dosdir, struct customdirs **dirlist, int *flags); |
/* Free the memory allocated at configuration load. */ |
void freeconf(struct customdirs **dirlist); |
#endif |
/pkginst/lsm.c |
---|
0,0 → 1,77 |
/* |
* This file is part of FDNPKG |
* Copyright (C) 2013-2016 Mateusz Viste, All rights reserved. |
*/ |
#include <stdio.h> /* fopen, fclose... */ |
#include <string.h> /* strcasecmp() */ |
#include "lsm.h" /* include self for control */ |
#include "rtrim.h" |
#include "version.h" |
/* reads a line from a file descriptor, and writes it to *line, the *line array is filled no more than maxlen bytes. returns the number of byte read on success, or a negative value on failure (reaching EOF is considered an error condition) */ |
static int readline_fromfile(FILE *fd, char *line, int maxlen) { |
int bytebuff, linelen = 0; |
for (;;) { |
bytebuff = fgetc(fd); |
if (bytebuff == EOF) { |
line[linelen] = 0; |
if (linelen == 0) return(-1); |
return(linelen); |
} |
if (bytebuff < 0) return(-1); |
if (bytebuff == '\r') continue; /* ignore CR */ |
if (bytebuff == '\n') { |
line[linelen] = 0; |
return(linelen); |
} |
if (linelen < maxlen) line[linelen++] = bytebuff; |
} |
} |
/* Loads metadata from an LSM file. Returns 0 on success, non-zero on error. */ |
int readlsm(char *filename, char *version, int version_maxlen) { |
char linebuff[128]; |
char *valuestr; |
int x; |
FILE *fd; |
/* reset fields to be read to empty values */ |
version[0] = 0; |
/* open the file */ |
fd = fopen(filename, "rb"); |
if (fd == NULL) return(-1); |
/* check the file's header */ |
if (readline_fromfile(fd, linebuff, 64) < 0) { |
fclose(fd); |
return(-1); |
} |
if (strcasecmp(linebuff, "begin3") != 0) { |
fclose(fd); |
return(-1); |
} |
/* read the LSM file line by line */ |
while (readline_fromfile(fd, linebuff, 127) >= 0) { |
for (x = 0;; x++) { |
if (linebuff[x] == 0) { |
x = -1; |
break; |
} else if (linebuff[x] == ':') { |
break; |
} |
} |
if (x > 0) { |
linebuff[x] = 0; |
valuestr = linebuff + x + 1; |
trim(linebuff); |
trim(valuestr); |
if (strcasecmp(linebuff, "version") == 0) { |
snprintf(version, version_maxlen, "%s", valuestr); |
version[version_maxlen] = 0; /* snprintf is supposed to terminate string itself, but the DJGPP doesn't */ |
} |
} |
} |
fclose(fd); |
return(0); |
} |
/pkginst/lsm.h |
---|
0,0 → 1,10 |
/* |
* This file is part of FDNPKG |
* Copyright (C) 2013-2016 Mateusz Viste, All rights reserved. |
*/ |
#ifndef readlsm_h_sentinel |
#define readlsm_h_sentinel |
/* Loads metadata from an LSM file. Returns 0 on success, non-zero on error. */ |
int readlsm(char *filename, char *version, int version_maxlen); |
#endif |
/pkginst/main.c |
---|
0,0 → 1,160 |
/* |
* PKGINST - SvarDOS package installer |
* |
* PUBLISHED UNDER THE TERMS OF THE MIT LICENSE |
* |
* COPYRIGHT (C) 2016-2021 MATEUSZ VISTE, ALL RIGHTS RESERVED. |
* |
* Permission is hereby granted, free of charge, to any person obtaining a |
* copy of this software and associated documentation files (the "Software"), |
* to deal in the Software without restriction, including without limitation |
* the rights to use, copy, modify, merge, publish, distribute, sublicense, |
* and/or sell copies of the Software, and to permit persons to whom the |
* Software is furnished to do so, subject to the following conditions: |
* |
* The above copyright notice and this permission notice shall be included in |
* all copies or substantial portions of the Software. |
* |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
* DEALINGS IN THE SOFTWARE. |
*/ |
#include <stdio.h> /* printf() */ |
#include <stdlib.h> /* malloc() and friends */ |
#include <string.h> /* strcasecmp() */ |
#include "kitten/kitten.h" |
#include "kprintf.h" |
#include "libunzip.h" |
#include "pkginst.h" |
#include "pkgrem.h" |
#include "showinst.h" |
#include "version.h" |
enum ACTIONTYPES { |
ACTION_INSTALL, |
ACTION_REMOVE, |
ACTION_LISTFILES, |
ACTION_HELP |
}; |
static int showhelp(void) { |
printf("PKGINST ver " PVER " Copyright (C) " PDATE " Mateusz Viste\n" |
"\n" |
"PKGINST is the package installer for SvarDOS.\n" |
"\n" |
"Usage: PKGINST install package.zip\n" |
" PKGINST remove package\n" |
" PKGINST listfiles package\n" |
"\n" |
"PKGINST is published under the MIT license. It uses a configuration file\n" |
"located at %%DOSDIR%%\\CFG\\PKGINST.CFG\n" |
); |
return(1); |
} |
static enum ACTIONTYPES parsearg(int argc, char **argv) { |
/* I expect exactly 2 arguments (ie argc == 3) */ |
if (argc != 3) return(ACTION_HELP); |
/* look for valid actions */ |
if (strcasecmp(argv[1], "install") == 0) { |
return(ACTION_INSTALL); |
} else if (strcasecmp(argv[1], "remove") == 0) { |
return(ACTION_REMOVE); |
} else if (strcasecmp(argv[1], "listfiles") == 0) { |
return(ACTION_LISTFILES); |
} else { |
return(ACTION_HELP); |
} |
} |
static int pkginst(const char *file, int flags, const char *dosdir, const struct customdirs *dirlist) { |
char pkgname[32]; |
int t, lastpathdelim = -1, u = 0; |
struct ziplist *zipfileidx; |
FILE *zipfilefd; |
for (t = 0; file[t] != 0; t++) { |
if ((file[t] == '/') || (file[t] == '\\')) lastpathdelim = t; |
} |
/* copy the filename into pkgname (without path elements) */ |
for (t = lastpathdelim + 1; file[t] != 0; t++) pkgname[u++] = file[t]; |
pkgname[u] = 0; /* terminate the string */ |
/* truncate the file's extension (.zip) */ |
for (t = u; t > 0; t--) { |
if (pkgname[t] == '.') { |
pkgname[t] = 0; |
break; |
} |
} |
/* prepare the zip file and install it */ |
zipfileidx = pkginstall_preparepackage(pkgname, file, flags, &zipfilefd, dosdir, dirlist); |
if (zipfileidx != NULL) { |
int res = 0; |
if (pkginstall_installpackage(pkgname, dosdir, dirlist, zipfileidx, zipfilefd) != 0) res = 1; |
fclose(zipfilefd); |
return(res); |
} else { |
fclose(zipfilefd); |
return(1); |
} |
} |
int main(int argc, char **argv) { |
int res = 1, flags; |
enum ACTIONTYPES action; |
const char *dosdir; |
struct customdirs *dirlist; |
kittenopen("pkginst"); /* NLS init */ |
action = parsearg(argc, argv); |
if (action == ACTION_HELP) { |
showhelp(); |
goto GAMEOVER; |
} |
/* read the DOSDIR environment variable */ |
dosdir = getenv("DOSDIR"); |
if (dosdir == NULL) { |
kitten_puts(2, 2, "%DOSDIR% not set! You should make it point to the FreeDOS main directory."); |
kitten_puts(2, 3, "Example: SET DOSDIR=C:\\FDOS"); |
goto GAMEOVER; |
} |
/* load configuration */ |
flags = 0; |
dirlist = NULL; |
if (loadconf(dosdir, &dirlist, &flags) != 0) goto GAMEOVER; |
switch (action) { |
case ACTION_INSTALL: |
res = pkginst(argv[2], flags, dosdir, dirlist); |
break; |
case ACTION_REMOVE: |
res = pkgrem(argv[2], dosdir); |
break; |
case ACTION_LISTFILES: |
res = listfilesofpkg(argv[2], dosdir); |
break; |
default: |
res = showhelp(); |
break; |
} |
GAMEOVER: |
kittenclose(); /* NLS de-init */ |
if (res != 0) return(1); |
return(0); |
} |
/pkginst/parsecmd.c |
---|
0,0 → 1,37 |
/* This file provides functions for parsing commands and their arguments |
Warning: parsecmd() will modify the cmdline string, so it won't be |
readable anymore in any other way other than via ptrtable[]. |
This function returns the number of arguments that have been parsed, |
or -1 on parsing error. |
Copyright (C) 2012-2016 Mateusz Viste */ |
#include "version.h" |
int parsecmd(char *cmdline, char **ptrtable, int maxargs) { |
int x = 0, argc = 0, state = 0; |
for (;;) { |
switch (cmdline[x]) { /* detect delimiter and non-delimiter chars */ |
case 0x0: /* detect end of string */ |
return(argc); /* return number of arguments */ |
case ' ': /* space */ |
case 0x9: /* tab */ |
case 0xA: /* LF */ |
case 0xD: /* CR */ |
if (state != 0) { /* if awaiting for argument end */ |
cmdline[x] = 0; /* terminate the substring */ |
state = 0; /* switch to 'waiting for argument end' state */ |
} |
break; |
default: /* anything that is not a delimiter */ |
if (state == 0) { /* if awaiting for argument start */ |
if (argc == maxargs) return(-1); /* look out for arg overflow */ |
ptrtable[argc] = &cmdline[x]; /* save the address of the substring */ |
argc += 1; /* increment the arguments count */ |
state = 1; /* switch to 'waiting for argument' state */ |
} |
} |
x += 1; /* move to the next character of cmdline */ |
} |
} |
/pkginst/parsecmd.h |
---|
0,0 → 1,15 |
/* This file provides functions for parsing commands and their arguments |
Warning: parsecmd() will modify the cmdline string, so it won't be |
readable anymore in any other way other than via ptrtable[]. |
This function returns the number of arguments that have been parsed, |
or -1 on parsing error. |
Copyright (C) 2012-2016 Mateusz Viste */ |
#ifndef PARSECMD_H_SENTINEL |
#define PARSECMD_H_SENTINEL |
int parsecmd(char *cmdline, char **ptrtable, int maxargs); |
#endif |
/pkginst/pkginst.c |
---|
0,0 → 1,368 |
/* |
* This file is part of pkginst (SvarDOS) |
* Copyright (C) 2012-2021 Mateusz Viste |
* Changes by TK Chia |
*/ |
#include <ctype.h> /* toupper() */ |
#include <stdio.h> |
#include <stdlib.h> /* system() */ |
#include <string.h> /* strcpy() */ |
#include <unistd.h> /* read() */ |
#include <sys/types.h> /* struct utimbuf */ |
#include "crc32.h" /* all CRC32 related stuff */ |
#include "fdnpkg.h" /* PKGINST_SKIPLINKS... */ |
#include "helpers.h" /* slash2backslash(), strtolower() */ |
#include "fileexst.h" |
#include "kprintf.h" |
#include "libunzip.h" /* zip_listfiles()... */ |
#include "showinst.h" /* pkg_loadflist() */ |
#include "pkginst.h" /* include self for control */ |
#include "version.h" |
/* return 1 if fname looks like a link filename, 0 otherwise */ |
static int islinkfile(const char *fname) { |
char *link1 = "LINKS\\"; |
char *link2 = "links\\"; |
int x; |
for (x = 0; ; x++) { |
if (link1[x] == 0) return(1); |
if ((fname[x] != link1[x]) && (fname[x] != link2[x])) return(0); |
} |
} |
/* validate a filename (8+3, no weird characters, etc). returns 0 on success, |
* nonzero otherwise. */ |
static int validfilename(const char *fname) { |
int i, i2; |
char *validchars = "!#$%&'()-@^_`{}~"; |
int elemlen = 0; |
int elemmaxlen = 8; /* switches from 8 to 3 depending wheter I am analyzing |
a filename or an extension */ |
/* look for invalid chars in the entire string, and check the length of the |
* element at the same time */ |
for (i = 0; fname[i] != 0; i++) { |
/* director separators are threated specially */ |
if (fname[i] == '\\') { |
elemlen = 0; |
elemmaxlen = 8; |
continue; |
} |
/* '.' switches the check into extension mode */ |
if (fname[i] == '.') { |
if (elemlen == 0) return(-1); /* a file must have a base name */ |
if (elemmaxlen == 3) return(-2); /* a file cannot have two extensions */ |
elemlen = 0; |
elemmaxlen = 3; |
continue; |
} |
/* check that the element is not too long */ |
if (++elemlen > elemmaxlen) return(-3); |
/* look for valid characters */ |
if ((fname[i] >= 'a') && (fname[i] <= 'z')) continue; |
if ((fname[i] >= 'A') && (fname[i] <= 'Z')) continue; |
if ((fname[i] >= '0') && (fname[i] <= '9')) continue; |
if ((fname[i] & 128) != 0) continue; /* high bytes are okay (NLS) */ |
/* look for other valid characters */ |
for (i2 = 0; validchars[i2] != 0; i2++) { |
if (fname[i] == validchars[i2]) break; |
} |
if (validchars[i2] != 0) continue; |
/* if we are here, then the character is invalid */ |
return(-4); |
} |
/* all checks passed */ |
return(0); |
} |
/* processes a link file - that is, reads the target inside, and overwrite |
* the file with new content */ |
static void processlinkfile(const char *linkfile, const char *dosdir, const struct customdirs *dirlist, char *buff) { |
char origtarget[512]; |
int x; |
char *shortfile; |
unsigned char comstub[] = { /* machine code of a COM stub launcher */ |
0xBC,0x00,0x00,0xBB,0x00,0x10,0xB4,0x4A,0xCD,0x21,0xBB,0x2A,0x01,0x8C,0x5F,0x04, |
0x8C,0x5F,0x08,0x8C,0x5F,0x0C,0xB8,0x00,0x4B,0xBA,0x38,0x01,0xCD,0x21,0xB0,0x7F, |
0x72,0x04,0xB4,0x4D,0xCD,0x21,0xB4,0x4C,0xCD,0x21,0x00,0x00,0x80,0x00,0x00,0x00, |
0x5C,0x00,0x00,0x00,0x6C,0x00,0x00,0x00}; /* read comlink.asm for details */ |
const unsigned stack_paras = 12; |
unsigned alloc_paras, alloc_bytes; |
FILE *fd; |
/* open the link file and read the original target */ |
fd = fopen(linkfile, "r"); |
if (fd == NULL) { |
kitten_printf(3, 21, "Error: Failed to open link file '%s' for read access.", linkfile); |
puts(""); |
return; |
} |
x = fread(origtarget, 1, sizeof(origtarget) - 1, fd); |
origtarget[x] = 0; |
fclose(fd); |
/* validate the original target (ltrim to first \r or \n) */ |
for (x = 0; origtarget[x] != 0; x++) { |
if ((origtarget[x] == '\r') || (origtarget[x] == '\n')) { |
origtarget[x] = 0; |
break; |
} |
} |
/* translate the original target to a local path */ |
shortfile = computelocalpath(origtarget, buff, dosdir, dirlist); |
/* compute the amount of memory the stub should leave for itself: |
- 16 paragraphs needed for the PSP |
- sizeof(comstub) bytes needed for code and data |
- strlen(shortfile) + 1 for the command line |
- stack_paras paragraphs for the stack */ |
alloc_paras = 16 + (sizeof(comstub) + strlen(shortfile) + 16) / 16 + stack_paras; |
alloc_bytes = 16 * alloc_paras; |
comstub[1] = alloc_bytes & 0xff; |
comstub[2] = alloc_bytes >> 8; |
comstub[4] = alloc_paras & 0xff; |
comstub[5] = alloc_paras >> 8; |
/* write new content into the link file */ |
fd = fopen(linkfile, "wb"); |
if (fd == NULL) { |
kitten_printf(3, 22, "Error: Failed to open link file '%s' for write access.", linkfile); |
puts(""); |
return; |
} |
fwrite(comstub, 1, sizeof(comstub), fd); |
fprintf(fd, "%s%s%c", buff, shortfile, 0); |
fclose(fd); |
} |
/* returns 0 if pkgname is not installed, non-zero otherwise */ |
int is_package_installed(const char *pkgname, const char *dosdir) { |
char fname[512]; |
sprintf(fname, "%s\\packages\\%s.lst", dosdir, pkgname); |
return(fileexists(fname)); /* file exists -> package is installed */ |
} |
/* checks that pkgname is NOT installed. return 0 on success, non-zero otherwise. */ |
static int validate_package_not_installed(const char *pkgname, const char *dosdir) { |
if (is_package_installed(pkgname, dosdir) != 0) { |
kitten_printf(3, 18, "Package %s is already installed! You might want to use the 'update' action.", pkgname); |
puts(""); |
return(-1); |
} |
return(0); |
} |
/* find a filename in a flist linked list, and returns a pointer to it */ |
static struct flist_t *findfileinlist(struct flist_t *flist, const char *fname) { |
while (flist != NULL) { |
if (strcmp(flist->fname, fname) == 0) return(flist); |
flist = flist->next; |
} |
return(NULL); |
} |
/* prepare a package for installation. this is mandatory before actually installing it! |
* returns a pointer to the zip file's index on success, NULL on failure. the **zipfd pointer is updated with a file descriptor to the open zip file to install. */ |
struct ziplist *pkginstall_preparepackage(const char *pkgname, const char *zipfile, int flags, FILE **zipfd, const char *dosdir, const struct customdirs *dirlist) { |
char fname[256]; |
char appinfofile[256]; |
int appinfopresence; |
char *shortfile; |
struct ziplist *ziplinkedlist = NULL, *curzipnode, *prevzipnode; |
struct flist_t *flist = NULL; |
sprintf(appinfofile, "appinfo\\%s.lsm", pkgname); /* Prepare the appinfo/xxxx.lsm filename string for later use */ |
/* check if not already installed, if already here, print a message "you might want to use update instead" |
* of course this must not be done if we are in the process of upgrading said package */ |
if (((flags & PKGINST_UPDATE) == 0) && (validate_package_not_installed(pkgname, dosdir) != 0)) { |
return(NULL); |
} |
/* Now let's check the content of the zip file */ |
*zipfd = fopen(zipfile, "rb"); |
if (*zipfd == NULL) { |
kitten_puts(3, 8, "Error: Invalid zip archive! Package not installed."); |
goto RAII; |
} |
ziplinkedlist = zip_listfiles(*zipfd); |
if (ziplinkedlist == NULL) { |
kitten_puts(3, 8, "Error: Invalid zip archive! Package not installed."); |
goto RAII; |
} |
/* if updating, load the list of files belonging to the current package */ |
if ((flags & PKGINST_UPDATE) != 0) { |
flist = pkg_loadflist(pkgname, dosdir); |
} |
/* Verify that there's no collision with existing local files, look for the appinfo presence, get rid of sources if required, and rename BAT links into COM files */ |
appinfopresence = 0; |
prevzipnode = NULL; |
for (curzipnode = ziplinkedlist; curzipnode != NULL;) { |
/* change all slashes to backslashes, and switch into all-lowercase */ |
slash2backslash(curzipnode->filename); |
strtolower(curzipnode->filename); |
/* remove 'directory' ZIP entries to avoid false alerts about directory already existing */ |
if ((curzipnode->flags & ZIP_FLAG_ISADIR) != 0) { |
curzipnode->filename[0] = 0; /* mark it "empty", will be removed in a short moment */ |
} |
/* is it a "link file"? */ |
if (fdnpkg_strcasestr(curzipnode->filename, "links\\") == curzipnode->filename) { |
/* skip links, if that's what the user wants */ |
if ((flags & PKGINST_SKIPLINKS) != 0) { |
curzipnode->filename[0] = 0; /* in fact, we just mark the file as 'empty' on the filename.. see later below */ |
} else { |
/* if it's a *.BAT link, then rename it to *.COM */ |
char *ext = getfext(curzipnode->filename); |
if (strcasecmp(ext, "bat") == 0) sprintf(ext, "com"); |
} |
} |
if (curzipnode->filename[0] == 0) { /* ignore empty filenames (maybe it was empty originally, or has been emptied because it's a dropped source or link) */ |
if (prevzipnode == NULL) { /* take the item out of the list */ |
ziplinkedlist = curzipnode->nextfile; |
free(curzipnode); /* free the item */ |
curzipnode = ziplinkedlist; |
} else { |
prevzipnode->nextfile = curzipnode->nextfile; |
free(curzipnode); /* free the item */ |
curzipnode = prevzipnode->nextfile; |
} |
continue; /* go to the next item */ |
} |
/* validate that the file has a valid filename (8+3, no shady chars...) */ |
if (validfilename(curzipnode->filename) != 0) { |
kitten_puts(3, 23, "Error: Package contains an invalid filename:"); |
printf(" %s\n", curzipnode->filename); |
goto RAII_ERR; |
} |
/* look out for collisions with already existing files (unless we are |
* updating the package and the local file belongs to it */ |
shortfile = computelocalpath(curzipnode->filename, fname, dosdir, dirlist); |
strcat(fname, shortfile); |
if ((findfileinlist(flist, fname) == NULL) && (fileexists(fname) != 0)) { |
kitten_puts(3, 9, "Error: Package contains a file that already exists locally:"); |
printf(" %s\n", fname); |
goto RAII_ERR; |
} |
/* abort if any entry is encrypted */ |
if ((curzipnode->flags & ZIP_FLAG_ENCRYPTED) != 0) { |
kitten_printf(3, 20, "Error: Package contains an encrypted file:"); |
puts(""); |
printf(" %s\n", curzipnode->filename); |
goto RAII_ERR; |
} |
/* abort if any file is compressed with an unsupported method */ |
if ((curzipnode->compmethod != 0/*store*/) && (curzipnode->compmethod != 8/*deflate*/)) { /* unsupported compression method */ |
kitten_printf(8, 2, "Error: Package contains a file compressed with an unsupported method (%d):", curzipnode->compmethod); |
puts(""); |
printf(" %s\n", curzipnode->filename); |
goto RAII_ERR; |
} |
if (strcmp(curzipnode->filename, appinfofile) == 0) appinfopresence = 1; |
prevzipnode = curzipnode; |
curzipnode = curzipnode->nextfile; |
} |
/* if appinfo file not found, this is not a real FreeDOS package */ |
if (appinfopresence != 1) { |
kitten_printf(3, 12, "Error: Package do not contain the %s file! Not a valid FreeDOS package.", appinfofile); |
puts(""); |
goto RAII_ERR; |
} |
goto RAII; |
RAII_ERR: |
zip_freelist(&ziplinkedlist); |
ziplinkedlist = NULL; |
if ((zipfd != NULL) && (*zipfd != NULL)) { |
fclose(*zipfd); |
*zipfd = NULL; |
} |
RAII: |
pkg_freeflist(flist); |
return(ziplinkedlist); |
} |
/* install a package that has been prepared already. returns 0 on success, |
* or a negative value on error, or a positive value on warning */ |
int pkginstall_installpackage(const char *pkgname, const char *dosdir, const struct customdirs *dirlist, struct ziplist *ziplinkedlist, FILE *zipfd) { |
char *buff; |
char *fulldestfilename; |
char packageslst[64]; |
char *shortfile; |
long filesextractedsuccess = 0, filesextractedfailure = 0; |
struct ziplist *curzipnode; |
FILE *lstfd; |
sprintf(packageslst, "packages\\%s.lst", pkgname); /* Prepare the packages/xxxx.lst filename string for later use */ |
buff = malloc(512); |
fulldestfilename = malloc(1024); |
if ((buff == NULL) || (fulldestfilename == NULL)) { |
kitten_puts(8, 0, "Out of memory!"); |
zip_freelist(&ziplinkedlist); |
free(buff); |
free(fulldestfilename); |
return(-1); |
} |
/* create the %DOSDIR%/packages directory, just in case it doesn't exist yet */ |
sprintf(buff, "%s\\packages\\", dosdir); |
mkpath(buff); |
/* open the lst file */ |
sprintf(buff, "%s\\%s", dosdir, packageslst); |
lstfd = fopen(buff, "wb"); /* opening it in binary mode, because I like to have control over line terminators (CR/LF) */ |
if (lstfd == NULL) { |
kitten_printf(3, 10, "Error: Could not create %s!", buff); |
puts(""); |
zip_freelist(&ziplinkedlist); |
free(buff); |
free(fulldestfilename); |
return(-2); |
} |
/* write list of files in zip into the lst, and create the directories structure */ |
for (curzipnode = ziplinkedlist; curzipnode != NULL; curzipnode = curzipnode->nextfile) { |
int unzip_result; |
if ((curzipnode->flags & ZIP_FLAG_ISADIR) != 0) continue; /* skip directories */ |
if (strcasecmp(curzipnode->filename, packageslst) == 0) continue; /* skip silently the package.lst file, if found */ |
shortfile = computelocalpath(curzipnode->filename, buff, dosdir, dirlist); /* substitute paths to custom dirs */ |
/* log the filename to packages\pkg.lst (with original, unmapped drive) */ |
fprintf(lstfd, "%s%s\r\n", buff, shortfile); |
/* create the path, just in case it doesn't exist yet */ |
mkpath(buff); |
sprintf(fulldestfilename, "%s%s", buff, shortfile); |
/* Now unzip the file */ |
unzip_result = zip_unzip(zipfd, curzipnode, fulldestfilename); |
if (unzip_result != 0) { |
kitten_printf(8, 3, "Error while extracting '%s' to '%s'!", curzipnode->filename, fulldestfilename); |
printf(" [%d]\n", unzip_result); |
filesextractedfailure += 1; |
} else { |
printf(" %s -> %s\n", curzipnode->filename, buff); |
filesextractedsuccess += 1; |
} |
/* if it's a LINK file, recompute a new content */ |
if (islinkfile(curzipnode->filename) != 0) { |
processlinkfile(fulldestfilename, dosdir, dirlist, buff); |
} |
} |
fclose(lstfd); |
/* free the ziplist and close file descriptor */ |
zip_freelist(&ziplinkedlist); |
free(buff); |
free(fulldestfilename); |
kitten_printf(3, 19, "Package %s installed: %ld files extracted, %ld errors.", pkgname, filesextractedsuccess, filesextractedfailure); |
puts(""); |
return(filesextractedfailure); |
} |
/pkginst/pkginst.h |
---|
0,0 → 1,15 |
/* |
* This file is part of SvarDOS |
* Copyright (C) 2012-2021 Mateusz Viste |
*/ |
#ifndef pkginst_sentinel |
#define pkginst_sentinel |
#include "loadconf.h" /* required for struct customdirs */ |
int is_package_installed(const char *pkgname, const char *dosdir); |
struct ziplist *pkginstall_preparepackage(const char *pkgname, const char *localfile, int flags, FILE **zipfd, const char *dosdir, const struct customdirs *dirlist); |
int pkginstall_installpackage(const char *pkgname, const char *dosdir, const struct customdirs *dirlist, struct ziplist *ziplinkedlist, FILE *zipfd); |
#endif |
/pkginst/pkgrem.c |
---|
0,0 → 1,178 |
/* |
* This file is part of the pkginst (SvarDOS) project. |
* Copyright (C) Mateusz Viste 2012-2021. All rights reserved. |
*/ |
#include <ctype.h> /* toupper() */ |
#include <stdio.h> |
#include <string.h> /* strlen() */ |
#include <stdlib.h> /* free() */ |
#include <unistd.h> /* rmdir(), unlink() */ |
#include <direct.h> /* watcom needs this for the rmdir() prototype */ |
#include "fileexst.h" |
#include "getdelim.h" |
#include "helpers.h" /* slash2backslash() */ |
#include "kprintf.h" |
#include "pkgrem.h" |
#include "rtrim.h" |
#include "version.h" |
struct dirliststruct { |
struct dirliststruct *next; |
char dirname[2]; /* this must be the last item in the structure */ |
}; |
/* adds a directory to dirlist, if not already present */ |
static struct dirliststruct *rememberdir(struct dirliststruct *dirlist, const char *path) { |
struct dirliststruct *res; |
/* if already present, do nothing */ |
for (res = dirlist; res != NULL; res = res->next) { |
if (strcasecmp(res->dirname, path) == 0) return(dirlist); |
} |
/* not in the list yet - add it */ |
res = malloc(sizeof(struct dirliststruct) + strlen(path)); |
if (res == NULL) { /* out of memory */ |
kitten_printf(4, 3, "Out of memory! Could not store directory %s!", path); |
puts(""); |
return(NULL); |
} |
strcpy(res->dirname, path); |
res->next = dirlist; |
return(res); |
} |
/* explode a path into subdirectories, and remember each one inside dirlist */ |
static struct dirliststruct *rememberpath(struct dirliststruct *dirlist, char *path) { |
int x, gameover = 0; |
/* iterate on the path, and add each subdirectory */ |
for (x = 0;; x++) { |
switch (path[x]) { |
case 0: |
gameover = 1; |
case '/': |
case '\\': |
path[x] = 0; |
dirlist = rememberdir(dirlist, path); |
path[x] = '\\'; |
} |
if (gameover != 0) break; |
} |
return(dirlist); |
} |
/* removes a package from the system. Returns 0 on success, non-zero otherwise */ |
int pkgrem(const char *pkgname, const char *dosdir) { |
char fpath[256]; |
char shellcmd[256]; |
char *lineptr; |
FILE *flist; |
int getdelimlen; |
int lastdirsep; |
int x; |
size_t getdelimcount = 0; |
struct dirliststruct *dirlist = NULL; /* used to remember directories to remove */ |
char pkglistfile[256]; |
/* Check if the file %DOSDIR%\packages\pkgname.lst exists (if not, the package is not installed) */ |
sprintf(fpath, "%s\\packages\\%s.lst", dosdir, pkgname); |
if (fileexists(fpath) == 0) { /* file does not exist */ |
kitten_printf(4, 0, "Package %s is not installed, so not removed.", pkgname); |
puts(""); |
return(-1); |
} |
/* open the file %DOSDIR%\packages\pkgname.lst */ |
flist = fopen(fpath, "r"); |
if (flist == NULL) { |
kitten_puts(4, 1, "Error opening lst file!"); |
return(-2); |
} |
sprintf(pkglistfile, "packages\\%s.lst", pkgname); |
/* remove all files/folders listed in pkgname.lst but NOT pkgname.lst */ |
for (;;) { |
/* read line from file */ |
lineptr = NULL; |
getdelimlen = getdelim(&lineptr, &getdelimcount, '\n', flist); |
if (getdelimlen < 0) { |
free(lineptr); |
break; |
} |
rtrim(lineptr); /* right-trim the filename */ |
slash2backslash(lineptr); /* change all / to \ */ |
if ((lineptr[0] == 0) || (lineptr[0] == '\r') || (lineptr[0] == '\n')) { |
free(lineptr); /* free the memory occupied by the line */ |
continue; /* skip empty lines */ |
} |
/* remember the path part for removal later */ |
lastdirsep = -1; |
for (x = 1; lineptr[x] != 0; x++) { |
if ((lineptr[x] == '\\') && (lineptr[x - 1] != ':')) lastdirsep = x; |
} |
if (lastdirsep > 0) { |
lineptr[lastdirsep] = 0; |
dirlist = rememberpath(dirlist, lineptr); |
lineptr[lastdirsep] = '\\'; |
} |
/* if it's a directory, skip it */ |
if (lineptr[strlen(lineptr) - 1] == '\\') { |
free(lineptr); /* free the memory occupied by the line */ |
continue; |
} |
/* it's a file - remove it */ |
if (strcasecmp(pkglistfile, lineptr) != 0) { /* never delete pkgname.lst at this point - it will be deleted later */ |
if ((lineptr[0] == '\\') || (lineptr[1] == ':')) { /* this is an absolute path */ |
sprintf(shellcmd, "%s", lineptr); |
} else { /* else it's a relative path starting at %dosdir% */ |
sprintf(shellcmd, "%s\\%s", dosdir, lineptr); |
} |
kitten_printf(4, 4, "removing %s", shellcmd); |
puts(""); |
unlink(shellcmd); |
} |
free(lineptr); /* free the memory occupied by the line */ |
} |
/* close the file */ |
fclose(flist); |
/* iterate through dirlist and remove directories if empty, from longest to shortest */ |
while (dirlist != NULL) { |
struct dirliststruct *dirlistpos, *previousdir; |
/* find the longest path, and put it on top */ |
previousdir = dirlist; |
for (dirlistpos = dirlist->next; dirlistpos != NULL; dirlistpos = dirlistpos->next) { |
if (strlen(dirlistpos->dirname) > strlen(dirlist->dirname)) { |
previousdir->next = dirlistpos->next; |
dirlistpos->next = dirlist; |
dirlist = dirlistpos; |
dirlistpos = previousdir; |
} else { |
previousdir = dirlistpos; |
} |
} |
if ((dirlist->dirname[0] == '\\') || (dirlist->dirname[1] == ':')) { /* this is an absolute path */ |
sprintf(shellcmd, "%s", dirlist->dirname); |
} else { /* else it's a relative path starting at %dosdir% */ |
sprintf(shellcmd, "%s\\%s", dosdir, dirlist->dirname); |
} |
/* printf("RMDIR %s\n", shellcmd); */ |
rmdir(shellcmd); |
/* free the allocated memory for this entry */ |
dirlistpos = dirlist; |
dirlist = dirlistpos->next; |
free(dirlistpos); |
} |
/* remove %DOSDIR%\packages\pkgname.lst */ |
unlink(fpath); |
kitten_printf(4, 5, "Package %s has been removed.", pkgname); |
puts(""); |
return(0); |
} |
/pkginst/pkgrem.h |
---|
0,0 → 1,9 |
/* |
* This file is part of the SvarDOS project. |
* Copyright (C) Mateusz Viste 2012-2021. All rights reserved. |
*/ |
#ifndef pkgrem_sentinel |
#define pkgrem_sentinel |
int pkgrem(const char *pkgname, const char *dosdir); |
#endif |
/pkginst/rtrim.c |
---|
0,0 → 1,47 |
/* |
* Right trim any space, tab, cr or lf |
* Copyright (C) 2012-2016 Mateusz Viste |
*/ |
#include "rtrim.h" |
void rtrim(char *str) { |
int x, realendofstr = 0; |
for (x = 0; str[x] != 0; x++) { |
switch (str[x]) { |
case ' ': |
case '\t': |
case '\r': |
case '\n': |
break; |
default: |
realendofstr = x + 1; |
break; |
} |
} |
str[realendofstr] = 0; |
} |
void trim(char *str) { |
int x, y, firstchar = -1, lastchar = -1; |
for (x = 0; str[x] != 0; x++) { |
switch (str[x]) { |
case ' ': |
case '\t': |
case '\n': |
case '\r': |
break; |
default: |
if (firstchar < 0) firstchar = x; |
lastchar = x; |
break; |
} |
} |
str[lastchar + 1] = 0; /* right trim */ |
if (firstchar > 0) { /* left trim (shift to the left ) */ |
y = 0; |
for (x = firstchar; str[x] != 0; x++) str[y++] = str[x]; |
str[y] = 0; |
} |
} |
/pkginst/rtrim.h |
---|
0,0 → 1,14 |
/* |
* This file is part of FDNPKG |
* Copyright (C) 2012-2016 Mateusz Viste |
* |
* trim spaces, tabs, cr's and lf's from both left and right ends of a string |
*/ |
#ifndef trim_sentinel |
#define trim_sentinel |
void rtrim(char *str); |
void trim(char *str); |
#endif |
/pkginst/showinst.c |
---|
0,0 → 1,177 |
/* |
* This file is part of PKGINST (SvarDOS) |
* Copyright (C) 2013-2021 Mateusz Viste. All rights reserved. |
*/ |
#include <stdio.h> |
#include <ctype.h> /* tolower() */ |
#include <stdlib.h> /* atoi(), qsort() - not using it after all, redefining it manually later */ |
#include <string.h> /* strlen() */ |
#include <sys/types.h> |
#include <direct.h> /* opendir() and friends */ |
#include "fdnpkg.h" |
#include "fileexst.h" |
#include "getdelim.h" |
#include "helpers.h" /* fdnpkg_strcasestr(), slash2backslash()... */ |
#include "kprintf.h" |
#include "libunzip.h" /* zip_freelist()... */ |
#include "lsm.h" |
#include "pkginst.h" |
#include "pkgrem.h" |
#include "rtrim.h" |
#include "showinst.h" /* include self for control */ |
#include "version.h" |
/* this is a wrapper around strcasecmp(), to be used by qsort() */ |
static int strcompare(const void *str1, const void *str2) { |
char **s1 = (char **)str1; |
char **s2 = (char **)str2; |
return(strcasecmp(*s1, *s2)); |
} |
static int loadinstpkglist(char **packagelist, char **packagelist_ver, int packagelist_maxlen, const char *filterstr, const char *dosdir) { |
DIR *dp; |
int packagelist_len = 0, x; |
struct dirent *ep; |
#define verstr_maxlen 64 |
char pkgdir[512], lsmfilename[1024], verstr[verstr_maxlen]; |
sprintf(pkgdir, "%s\\packages", dosdir); |
dp = opendir(pkgdir); |
if (dp != NULL) { |
while ((ep = readdir(dp)) != NULL) { |
if (ep->d_name[0] != '.') { /* ignore '.', '..', and hidden directories */ |
if (strlen(ep->d_name) > 4) { |
int tlen = strlen(ep->d_name); |
if ((ep->d_name[tlen - 4] != '.') || (tolower(ep->d_name[tlen - 3]) != 'l') || (tolower(ep->d_name[tlen - 2]) != 's') || (tolower(ep->d_name[tlen - 1]) != 't')) continue; /* if it's not an .lst file, skip it silently */ |
if (filterstr != NULL) { |
if (fdnpkg_strcasestr(ep->d_name, filterstr) == NULL) continue; /* if it's not matching the non-NULL filter, skip it */ |
} |
if (packagelist_len >= packagelist_maxlen) { |
closedir(dp); |
return(-1); /* if not enough place in the list - return an error */ |
} |
packagelist[packagelist_len] = strdup(ep->d_name); |
packagelist[packagelist_len][strlen(packagelist[packagelist_len]) - 4] = 0; /* cut out the .lst extension */ |
packagelist_len += 1; |
} |
} |
} |
closedir(dp); |
qsort(packagelist, packagelist_len, sizeof (char **), strcompare); /* sort the package list */ |
for (x = 0; x < packagelist_len; x++) { |
/* for each package, load the metadata from %DOSDIR\APPINFO\*.lsm */ |
sprintf(lsmfilename, "%s\\appinfo\\%s.lsm", dosdir, packagelist[x]); |
if (readlsm(lsmfilename, verstr, verstr_maxlen) != 0) sprintf(verstr, "(unknown version)"); |
packagelist_ver[x] = strdup(verstr); |
} |
return(packagelist_len); |
} else { |
kitten_printf(9, 0, "Error: Could not access the %s directory.", pkgdir); |
puts(""); |
return(-1); |
} |
} |
#define packagelist_maxlen 1024 |
void showinstalledpkgs(const char *filterstr, const char *dosdir) { |
char *packagelist[packagelist_maxlen]; |
char *packagelist_ver[packagelist_maxlen]; |
int packagelist_len, x; |
/* load the list of packages */ |
packagelist_len = loadinstpkglist(packagelist, packagelist_ver, packagelist_maxlen, filterstr, dosdir); /* Populate the packages list */ |
if (packagelist_len < 0) return; |
if (packagelist_len == 0) { |
kitten_puts(5, 0, "No package matched the search."); |
return; |
} |
/* iterate through all packages */ |
for (x = 0; x < packagelist_len; x++) { |
/* print the package/version couple on screen */ |
printf("%s %s\n", packagelist[x], packagelist_ver[x]); |
} |
} |
/* frees a linked list of filenames */ |
void pkg_freeflist(struct flist_t *flist) { |
while (flist != NULL) { |
struct flist_t *victim = flist; |
flist = flist->next; |
free(victim); |
} |
} |
/* returns a linked list of the files that belong to package pkgname */ |
struct flist_t *pkg_loadflist(const char *pkgname, const char *dosdir) { |
struct flist_t *res = NULL, *newnode; |
FILE *fd; |
char *lineptr; |
char buff[512]; |
int getdelimlen, fnamelen; |
size_t getdelimcount = 0; |
sprintf(buff, "%s\\packages\\%s.lst", dosdir, pkgname); |
if (fileexists(buff) == 0) { /* file does not exist */ |
kitten_printf(9, 1, "Error: Local package %s not found.", pkgname); |
puts(""); |
return(NULL); |
} |
fd = fopen(buff, "rb"); |
if (fd == NULL) { |
kitten_puts(4, 1, "Error opening lst file!"); |
return(NULL); |
} |
/* iterate through all lines of the file */ |
for (;;) { |
lineptr = NULL; |
getdelimlen = getdelim(&lineptr, &getdelimcount, '\n', fd); |
if (getdelimlen < 0) { /* EOF */ |
free(lineptr); |
break; |
} |
rtrim(lineptr); /* right-trim the filename */ |
slash2backslash(lineptr); /* change all / to \ */ |
if ((lineptr[0] == 0) || (lineptr[0] == '\r') || (lineptr[0] == '\n')) continue; /* skip empty lines */ |
if (lineptr[strlen(lineptr) - 1] == '\\') continue; /* skip directories */ |
if ((lineptr[0] == '\\') || (lineptr[1] == ':')) { /* this is an absolute path */ |
fnamelen = snprintf(buff, sizeof(buff), "%s", lineptr); |
} else { /* else it's a relative path starting at %dosdir% */ |
fnamelen = snprintf(buff, sizeof(buff), "%s\\%s\n", dosdir, lineptr); |
} |
free(lineptr); /* free the memory occupied by the line */ |
/* add the new node to the result */ |
newnode = malloc(sizeof(struct flist_t) + fnamelen); |
if (newnode == NULL) { |
kitten_printf(2, 14, "Out of memory! (%s)", "malloc failure"); |
continue; |
} |
newnode->next = res; |
strcpy(newnode->fname, buff); |
res = newnode; |
} |
fclose(fd); |
return(res); |
} |
/* Prints files owned by a package */ |
int listfilesofpkg(const char *pkgname, const char *dosdir) { |
struct flist_t *flist, *flist_ptr; |
/* load the list of files belonging to pkgname */ |
flist = pkg_loadflist(pkgname, dosdir); |
if (flist == NULL) return(-1); |
/* display each filename on screen */ |
for (flist_ptr = flist; flist_ptr != NULL; flist_ptr = flist_ptr->next) { |
puts(flist_ptr->fname); |
} |
/* free the list of files */ |
pkg_freeflist(flist); |
return(0); |
} |
/pkginst/showinst.h |
---|
0,0 → 1,12 |
/* |
* This file is part of pkginst (SvarDOS) |
* Copyright (C) 2013-2021 Mateusz Viste |
*/ |
#ifndef showinst_h_sentinel |
#define showinst_h_sentinel |
void pkg_freeflist(struct flist_t *flist); |
struct flist_t *pkg_loadflist(const char *pkgname, const char *dosdir); |
void showinstalledpkgs(const char *filterstr, const char *dosdir); |
int listfilesofpkg(const char *pkgname, const char *dosdir); |
#endif |
/pkginst/version.h |
---|
0,0 → 1,10 |
/* |
*/ |
#ifndef COMMON_H_SENTINEL |
#define COMMON_H_SENTINEL |
#define PVER "20210123" |
#define PDATE "2012-2021" |
#endif |
/pkginst/zlib/readme.txt |
---|
0,0 → 1,3 |
This directory contains the zlib v1.2.8 library, precompiled with Open Watcom |
ver 1.9, large model. Compiled with the -DNO_GZIP definition, to save a few |
kilobytes of unnecessary code. |
/pkginst/zlib/zconf.h |
---|
0,0 → 1,511 |
/* zconf.h -- configuration of the zlib compression library |
* Copyright (C) 1995-2013 Jean-loup Gailly. |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* @(#) $Id$ */ |
#ifndef ZCONF_H |
#define ZCONF_H |
/* |
* If you *really* need a unique prefix for all types and library functions, |
* compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. |
* Even better than compiling with -DZ_PREFIX would be to use configure to set |
* this permanently in zconf.h using "./configure --zprefix". |
*/ |
#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ |
# define Z_PREFIX_SET |
/* all linked symbols */ |
# define _dist_code z__dist_code |
# define _length_code z__length_code |
# define _tr_align z__tr_align |
# define _tr_flush_bits z__tr_flush_bits |
# define _tr_flush_block z__tr_flush_block |
# define _tr_init z__tr_init |
# define _tr_stored_block z__tr_stored_block |
# define _tr_tally z__tr_tally |
# define adler32 z_adler32 |
# define adler32_combine z_adler32_combine |
# define adler32_combine64 z_adler32_combine64 |
# ifndef Z_SOLO |
# define compress z_compress |
# define compress2 z_compress2 |
# define compressBound z_compressBound |
# endif |
# define crc32 z_crc32 |
# define crc32_combine z_crc32_combine |
# define crc32_combine64 z_crc32_combine64 |
# define deflate z_deflate |
# define deflateBound z_deflateBound |
# define deflateCopy z_deflateCopy |
# define deflateEnd z_deflateEnd |
# define deflateInit2_ z_deflateInit2_ |
# define deflateInit_ z_deflateInit_ |
# define deflateParams z_deflateParams |
# define deflatePending z_deflatePending |
# define deflatePrime z_deflatePrime |
# define deflateReset z_deflateReset |
# define deflateResetKeep z_deflateResetKeep |
# define deflateSetDictionary z_deflateSetDictionary |
# define deflateSetHeader z_deflateSetHeader |
# define deflateTune z_deflateTune |
# define deflate_copyright z_deflate_copyright |
# define get_crc_table z_get_crc_table |
# ifndef Z_SOLO |
# define gz_error z_gz_error |
# define gz_intmax z_gz_intmax |
# define gz_strwinerror z_gz_strwinerror |
# define gzbuffer z_gzbuffer |
# define gzclearerr z_gzclearerr |
# define gzclose z_gzclose |
# define gzclose_r z_gzclose_r |
# define gzclose_w z_gzclose_w |
# define gzdirect z_gzdirect |
# define gzdopen z_gzdopen |
# define gzeof z_gzeof |
# define gzerror z_gzerror |
# define gzflush z_gzflush |
# define gzgetc z_gzgetc |
# define gzgetc_ z_gzgetc_ |
# define gzgets z_gzgets |
# define gzoffset z_gzoffset |
# define gzoffset64 z_gzoffset64 |
# define gzopen z_gzopen |
# define gzopen64 z_gzopen64 |
# ifdef _WIN32 |
# define gzopen_w z_gzopen_w |
# endif |
# define gzprintf z_gzprintf |
# define gzvprintf z_gzvprintf |
# define gzputc z_gzputc |
# define gzputs z_gzputs |
# define gzread z_gzread |
# define gzrewind z_gzrewind |
# define gzseek z_gzseek |
# define gzseek64 z_gzseek64 |
# define gzsetparams z_gzsetparams |
# define gztell z_gztell |
# define gztell64 z_gztell64 |
# define gzungetc z_gzungetc |
# define gzwrite z_gzwrite |
# endif |
# define inflate z_inflate |
# define inflateBack z_inflateBack |
# define inflateBackEnd z_inflateBackEnd |
# define inflateBackInit_ z_inflateBackInit_ |
# define inflateCopy z_inflateCopy |
# define inflateEnd z_inflateEnd |
# define inflateGetHeader z_inflateGetHeader |
# define inflateInit2_ z_inflateInit2_ |
# define inflateInit_ z_inflateInit_ |
# define inflateMark z_inflateMark |
# define inflatePrime z_inflatePrime |
# define inflateReset z_inflateReset |
# define inflateReset2 z_inflateReset2 |
# define inflateSetDictionary z_inflateSetDictionary |
# define inflateGetDictionary z_inflateGetDictionary |
# define inflateSync z_inflateSync |
# define inflateSyncPoint z_inflateSyncPoint |
# define inflateUndermine z_inflateUndermine |
# define inflateResetKeep z_inflateResetKeep |
# define inflate_copyright z_inflate_copyright |
# define inflate_fast z_inflate_fast |
# define inflate_table z_inflate_table |
# ifndef Z_SOLO |
# define uncompress z_uncompress |
# endif |
# define zError z_zError |
# ifndef Z_SOLO |
# define zcalloc z_zcalloc |
# define zcfree z_zcfree |
# endif |
# define zlibCompileFlags z_zlibCompileFlags |
# define zlibVersion z_zlibVersion |
/* all zlib typedefs in zlib.h and zconf.h */ |
# define Byte z_Byte |
# define Bytef z_Bytef |
# define alloc_func z_alloc_func |
# define charf z_charf |
# define free_func z_free_func |
# ifndef Z_SOLO |
# define gzFile z_gzFile |
# endif |
# define gz_header z_gz_header |
# define gz_headerp z_gz_headerp |
# define in_func z_in_func |
# define intf z_intf |
# define out_func z_out_func |
# define uInt z_uInt |
# define uIntf z_uIntf |
# define uLong z_uLong |
# define uLongf z_uLongf |
# define voidp z_voidp |
# define voidpc z_voidpc |
# define voidpf z_voidpf |
/* all zlib structs in zlib.h and zconf.h */ |
# define gz_header_s z_gz_header_s |
# define internal_state z_internal_state |
#endif |
#if defined(__MSDOS__) && !defined(MSDOS) |
# define MSDOS |
#endif |
#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) |
# define OS2 |
#endif |
#if defined(_WINDOWS) && !defined(WINDOWS) |
# define WINDOWS |
#endif |
#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) |
# ifndef WIN32 |
# define WIN32 |
# endif |
#endif |
#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) |
# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) |
# ifndef SYS16BIT |
# define SYS16BIT |
# endif |
# endif |
#endif |
/* |
* Compile with -DMAXSEG_64K if the alloc function cannot allocate more |
* than 64k bytes at a time (needed on systems with 16-bit int). |
*/ |
#ifdef SYS16BIT |
# define MAXSEG_64K |
#endif |
#ifdef MSDOS |
# define UNALIGNED_OK |
#endif |
#ifdef __STDC_VERSION__ |
# ifndef STDC |
# define STDC |
# endif |
# if __STDC_VERSION__ >= 199901L |
# ifndef STDC99 |
# define STDC99 |
# endif |
# endif |
#endif |
#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) |
# define STDC |
#endif |
#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) |
# define STDC |
#endif |
#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) |
# define STDC |
#endif |
#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) |
# define STDC |
#endif |
#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ |
# define STDC |
#endif |
#ifndef STDC |
# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ |
# define const /* note: need a more gentle solution here */ |
# endif |
#endif |
#if defined(ZLIB_CONST) && !defined(z_const) |
# define z_const const |
#else |
# define z_const |
#endif |
/* Some Mac compilers merge all .h files incorrectly: */ |
#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) |
# define NO_DUMMY_DECL |
#endif |
/* Maximum value for memLevel in deflateInit2 */ |
#ifndef MAX_MEM_LEVEL |
# ifdef MAXSEG_64K |
# define MAX_MEM_LEVEL 8 |
# else |
# define MAX_MEM_LEVEL 9 |
# endif |
#endif |
/* Maximum value for windowBits in deflateInit2 and inflateInit2. |
* WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files |
* created by gzip. (Files created by minigzip can still be extracted by |
* gzip.) |
*/ |
#ifndef MAX_WBITS |
# define MAX_WBITS 15 /* 32K LZ77 window */ |
#endif |
/* The memory requirements for deflate are (in bytes): |
(1 << (windowBits+2)) + (1 << (memLevel+9)) |
that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) |
plus a few kilobytes for small objects. For example, if you want to reduce |
the default memory requirements from 256K to 128K, compile with |
make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" |
Of course this will generally degrade compression (there's no free lunch). |
The memory requirements for inflate are (in bytes) 1 << windowBits |
that is, 32K for windowBits=15 (default value) plus a few kilobytes |
for small objects. |
*/ |
/* Type declarations */ |
#ifndef OF /* function prototypes */ |
# ifdef STDC |
# define OF(args) args |
# else |
# define OF(args) () |
# endif |
#endif |
#ifndef Z_ARG /* function prototypes for stdarg */ |
# if defined(STDC) || defined(Z_HAVE_STDARG_H) |
# define Z_ARG(args) args |
# else |
# define Z_ARG(args) () |
# endif |
#endif |
/* The following definitions for FAR are needed only for MSDOS mixed |
* model programming (small or medium model with some far allocations). |
* This was tested only with MSC; for other MSDOS compilers you may have |
* to define NO_MEMCPY in zutil.h. If you don't need the mixed model, |
* just define FAR to be empty. |
*/ |
#ifdef SYS16BIT |
# if defined(M_I86SM) || defined(M_I86MM) |
/* MSC small or medium model */ |
# define SMALL_MEDIUM |
# ifdef _MSC_VER |
# define FAR _far |
# else |
# define FAR far |
# endif |
# endif |
# if (defined(__SMALL__) || defined(__MEDIUM__)) |
/* Turbo C small or medium model */ |
# define SMALL_MEDIUM |
# ifdef __BORLANDC__ |
# define FAR _far |
# else |
# define FAR far |
# endif |
# endif |
#endif |
#if defined(WINDOWS) || defined(WIN32) |
/* If building or using zlib as a DLL, define ZLIB_DLL. |
* This is not mandatory, but it offers a little performance increase. |
*/ |
# ifdef ZLIB_DLL |
# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) |
# ifdef ZLIB_INTERNAL |
# define ZEXTERN extern __declspec(dllexport) |
# else |
# define ZEXTERN extern __declspec(dllimport) |
# endif |
# endif |
# endif /* ZLIB_DLL */ |
/* If building or using zlib with the WINAPI/WINAPIV calling convention, |
* define ZLIB_WINAPI. |
* Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. |
*/ |
# ifdef ZLIB_WINAPI |
# ifdef FAR |
# undef FAR |
# endif |
# include <windows.h> |
/* No need for _export, use ZLIB.DEF instead. */ |
/* For complete Windows compatibility, use WINAPI, not __stdcall. */ |
# define ZEXPORT WINAPI |
# ifdef WIN32 |
# define ZEXPORTVA WINAPIV |
# else |
# define ZEXPORTVA FAR CDECL |
# endif |
# endif |
#endif |
#if defined (__BEOS__) |
# ifdef ZLIB_DLL |
# ifdef ZLIB_INTERNAL |
# define ZEXPORT __declspec(dllexport) |
# define ZEXPORTVA __declspec(dllexport) |
# else |
# define ZEXPORT __declspec(dllimport) |
# define ZEXPORTVA __declspec(dllimport) |
# endif |
# endif |
#endif |
#ifndef ZEXTERN |
# define ZEXTERN extern |
#endif |
#ifndef ZEXPORT |
# define ZEXPORT |
#endif |
#ifndef ZEXPORTVA |
# define ZEXPORTVA |
#endif |
#ifndef FAR |
# define FAR |
#endif |
#if !defined(__MACTYPES__) |
typedef unsigned char Byte; /* 8 bits */ |
#endif |
typedef unsigned int uInt; /* 16 bits or more */ |
typedef unsigned long uLong; /* 32 bits or more */ |
#ifdef SMALL_MEDIUM |
/* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ |
# define Bytef Byte FAR |
#else |
typedef Byte FAR Bytef; |
#endif |
typedef char FAR charf; |
typedef int FAR intf; |
typedef uInt FAR uIntf; |
typedef uLong FAR uLongf; |
#ifdef STDC |
typedef void const *voidpc; |
typedef void FAR *voidpf; |
typedef void *voidp; |
#else |
typedef Byte const *voidpc; |
typedef Byte FAR *voidpf; |
typedef Byte *voidp; |
#endif |
#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC) |
# include <limits.h> |
# if (UINT_MAX == 0xffffffffUL) |
# define Z_U4 unsigned |
# elif (ULONG_MAX == 0xffffffffUL) |
# define Z_U4 unsigned long |
# elif (USHRT_MAX == 0xffffffffUL) |
# define Z_U4 unsigned short |
# endif |
#endif |
#ifdef Z_U4 |
typedef Z_U4 z_crc_t; |
#else |
typedef unsigned long z_crc_t; |
#endif |
#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ |
# define Z_HAVE_UNISTD_H |
#endif |
#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */ |
# define Z_HAVE_STDARG_H |
#endif |
#ifdef STDC |
# ifndef Z_SOLO |
# include <sys/types.h> /* for off_t */ |
# endif |
#endif |
#if defined(STDC) || defined(Z_HAVE_STDARG_H) |
# ifndef Z_SOLO |
# include <stdarg.h> /* for va_list */ |
# endif |
#endif |
#ifdef _WIN32 |
# ifndef Z_SOLO |
# include <stddef.h> /* for wchar_t */ |
# endif |
#endif |
/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and |
* "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even |
* though the former does not conform to the LFS document), but considering |
* both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as |
* equivalently requesting no 64-bit operations |
*/ |
#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1 |
# undef _LARGEFILE64_SOURCE |
#endif |
#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) |
# define Z_HAVE_UNISTD_H |
#endif |
#ifndef Z_SOLO |
# if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) |
# include <unistd.h> /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ |
# ifdef VMS |
# include <unixio.h> /* for off_t */ |
# endif |
# ifndef z_off_t |
# define z_off_t off_t |
# endif |
# endif |
#endif |
#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 |
# define Z_LFS64 |
#endif |
#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) |
# define Z_LARGE64 |
#endif |
#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) |
# define Z_WANT64 |
#endif |
#if !defined(SEEK_SET) && !defined(Z_SOLO) |
# define SEEK_SET 0 /* Seek from beginning of file. */ |
# define SEEK_CUR 1 /* Seek from current position. */ |
# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ |
#endif |
#ifndef z_off_t |
# define z_off_t long |
#endif |
#if !defined(_WIN32) && defined(Z_LARGE64) |
# define z_off64_t off64_t |
#else |
# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO) |
# define z_off64_t __int64 |
# else |
# define z_off64_t z_off_t |
# endif |
#endif |
/* MVS linker does not support external names larger than 8 bytes */ |
#if defined(__MVS__) |
#pragma map(deflateInit_,"DEIN") |
#pragma map(deflateInit2_,"DEIN2") |
#pragma map(deflateEnd,"DEEND") |
#pragma map(deflateBound,"DEBND") |
#pragma map(inflateInit_,"ININ") |
#pragma map(inflateInit2_,"ININ2") |
#pragma map(inflateEnd,"INEND") |
#pragma map(inflateSync,"INSY") |
#pragma map(inflateSetDictionary,"INSEDI") |
#pragma map(compressBound,"CMBND") |
#pragma map(inflate_table,"INTABL") |
#pragma map(inflate_fast,"INFA") |
#pragma map(inflate_copyright,"INCOPY") |
#endif |
#endif /* ZCONF_H */ |
/pkginst/zlib/zlib.h |
---|
0,0 → 1,1768 |
/* zlib.h -- interface of the 'zlib' general purpose compression library |
version 1.2.8, April 28th, 2013 |
Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler |
This software is provided 'as-is', without any express or implied |
warranty. In no event will the authors be held liable for any damages |
arising from the use of this software. |
Permission is granted to anyone to use this software for any purpose, |
including commercial applications, and to alter it and redistribute it |
freely, subject to the following restrictions: |
1. The origin of this software must not be misrepresented; you must not |
claim that you wrote the original software. If you use this software |
in a product, an acknowledgment in the product documentation would be |
appreciated but is not required. |
2. Altered source versions must be plainly marked as such, and must not be |
misrepresented as being the original software. |
3. This notice may not be removed or altered from any source distribution. |
Jean-loup Gailly Mark Adler |
jloup@gzip.org madler@alumni.caltech.edu |
The data format used by the zlib library is described by RFCs (Request for |
Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 |
(zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). |
*/ |
#ifndef ZLIB_H |
#define ZLIB_H |
#include "zconf.h" |
#ifdef __cplusplus |
extern "C" { |
#endif |
#define ZLIB_VERSION "1.2.8" |
#define ZLIB_VERNUM 0x1280 |
#define ZLIB_VER_MAJOR 1 |
#define ZLIB_VER_MINOR 2 |
#define ZLIB_VER_REVISION 8 |
#define ZLIB_VER_SUBREVISION 0 |
/* |
The 'zlib' compression library provides in-memory compression and |
decompression functions, including integrity checks of the uncompressed data. |
This version of the library supports only one compression method (deflation) |
but other algorithms will be added later and will have the same stream |
interface. |
Compression can be done in a single step if the buffers are large enough, |
or can be done by repeated calls of the compression function. In the latter |
case, the application must provide more input and/or consume the output |
(providing more output space) before each call. |
The compressed data format used by default by the in-memory functions is |
the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped |
around a deflate stream, which is itself documented in RFC 1951. |
The library also supports reading and writing files in gzip (.gz) format |
with an interface similar to that of stdio using the functions that start |
with "gz". The gzip format is different from the zlib format. gzip is a |
gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. |
This library can optionally read and write gzip streams in memory as well. |
The zlib format was designed to be compact and fast for use in memory |
and on communications channels. The gzip format was designed for single- |
file compression on file systems, has a larger header than zlib to maintain |
directory information, and uses a different, slower check method than zlib. |
The library does not install any signal handler. The decoder checks |
the consistency of the compressed data, so the library should never crash |
even in case of corrupted input. |
*/ |
typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); |
typedef void (*free_func) OF((voidpf opaque, voidpf address)); |
struct internal_state; |
typedef struct z_stream_s { |
z_const Bytef *next_in; /* next input byte */ |
uInt avail_in; /* number of bytes available at next_in */ |
uLong total_in; /* total number of input bytes read so far */ |
Bytef *next_out; /* next output byte should be put there */ |
uInt avail_out; /* remaining free space at next_out */ |
uLong total_out; /* total number of bytes output so far */ |
z_const char *msg; /* last error message, NULL if no error */ |
struct internal_state FAR *state; /* not visible by applications */ |
alloc_func zalloc; /* used to allocate the internal state */ |
free_func zfree; /* used to free the internal state */ |
voidpf opaque; /* private data object passed to zalloc and zfree */ |
int data_type; /* best guess about the data type: binary or text */ |
uLong adler; /* adler32 value of the uncompressed data */ |
uLong reserved; /* reserved for future use */ |
} z_stream; |
typedef z_stream FAR *z_streamp; |
/* |
gzip header information passed to and from zlib routines. See RFC 1952 |
for more details on the meanings of these fields. |
*/ |
typedef struct gz_header_s { |
int text; /* true if compressed data believed to be text */ |
uLong time; /* modification time */ |
int xflags; /* extra flags (not used when writing a gzip file) */ |
int os; /* operating system */ |
Bytef *extra; /* pointer to extra field or Z_NULL if none */ |
uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ |
uInt extra_max; /* space at extra (only when reading header) */ |
Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ |
uInt name_max; /* space at name (only when reading header) */ |
Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ |
uInt comm_max; /* space at comment (only when reading header) */ |
int hcrc; /* true if there was or will be a header crc */ |
int done; /* true when done reading gzip header (not used |
when writing a gzip file) */ |
} gz_header; |
typedef gz_header FAR *gz_headerp; |
/* |
The application must update next_in and avail_in when avail_in has dropped |
to zero. It must update next_out and avail_out when avail_out has dropped |
to zero. The application must initialize zalloc, zfree and opaque before |
calling the init function. All other fields are set by the compression |
library and must not be updated by the application. |
The opaque value provided by the application will be passed as the first |
parameter for calls of zalloc and zfree. This can be useful for custom |
memory management. The compression library attaches no meaning to the |
opaque value. |
zalloc must return Z_NULL if there is not enough memory for the object. |
If zlib is used in a multi-threaded application, zalloc and zfree must be |
thread safe. |
On 16-bit systems, the functions zalloc and zfree must be able to allocate |
exactly 65536 bytes, but will not be required to allocate more than this if |
the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, pointers |
returned by zalloc for objects of exactly 65536 bytes *must* have their |
offset normalized to zero. The default allocation function provided by this |
library ensures this (see zutil.c). To reduce memory requirements and avoid |
any allocation of 64K objects, at the expense of compression ratio, compile |
the library with -DMAX_WBITS=14 (see zconf.h). |
The fields total_in and total_out can be used for statistics or progress |
reports. After compression, total_in holds the total size of the |
uncompressed data and may be saved for use in the decompressor (particularly |
if the decompressor wants to decompress everything in a single step). |
*/ |
/* constants */ |
#define Z_NO_FLUSH 0 |
#define Z_PARTIAL_FLUSH 1 |
#define Z_SYNC_FLUSH 2 |
#define Z_FULL_FLUSH 3 |
#define Z_FINISH 4 |
#define Z_BLOCK 5 |
#define Z_TREES 6 |
/* Allowed flush values; see deflate() and inflate() below for details */ |
#define Z_OK 0 |
#define Z_STREAM_END 1 |
#define Z_NEED_DICT 2 |
#define Z_ERRNO (-1) |
#define Z_STREAM_ERROR (-2) |
#define Z_DATA_ERROR (-3) |
#define Z_MEM_ERROR (-4) |
#define Z_BUF_ERROR (-5) |
#define Z_VERSION_ERROR (-6) |
/* Return codes for the compression/decompression functions. Negative values |
* are errors, positive values are used for special but normal events. |
*/ |
#define Z_NO_COMPRESSION 0 |
#define Z_BEST_SPEED 1 |
#define Z_BEST_COMPRESSION 9 |
#define Z_DEFAULT_COMPRESSION (-1) |
/* compression levels */ |
#define Z_FILTERED 1 |
#define Z_HUFFMAN_ONLY 2 |
#define Z_RLE 3 |
#define Z_FIXED 4 |
#define Z_DEFAULT_STRATEGY 0 |
/* compression strategy; see deflateInit2() below for details */ |
#define Z_BINARY 0 |
#define Z_TEXT 1 |
#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ |
#define Z_UNKNOWN 2 |
/* Possible values of the data_type field (though see inflate()) */ |
#define Z_DEFLATED 8 |
/* The deflate compression method (the only one supported in this version) */ |
#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ |
#define zlib_version zlibVersion() |
/* for compatibility with versions < 1.0.2 */ |
/* basic functions */ |
ZEXTERN const char * ZEXPORT zlibVersion OF((void)); |
/* The application can compare zlibVersion and ZLIB_VERSION for consistency. |
If the first character differs, the library code actually used is not |
compatible with the zlib.h header file used by the application. This check |
is automatically made by deflateInit and inflateInit. |
*/ |
/* |
ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); |
Initializes the internal stream state for compression. The fields |
zalloc, zfree and opaque must be initialized before by the caller. If |
zalloc and zfree are set to Z_NULL, deflateInit updates them to use default |
allocation functions. |
The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: |
1 gives best speed, 9 gives best compression, 0 gives no compression at all |
(the input data is simply copied a block at a time). Z_DEFAULT_COMPRESSION |
requests a default compromise between speed and compression (currently |
equivalent to level 6). |
deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough |
memory, Z_STREAM_ERROR if level is not a valid compression level, or |
Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible |
with the version assumed by the caller (ZLIB_VERSION). msg is set to null |
if there is no error message. deflateInit does not perform any compression: |
this will be done by deflate(). |
*/ |
ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); |
/* |
deflate compresses as much data as possible, and stops when the input |
buffer becomes empty or the output buffer becomes full. It may introduce |
some output latency (reading input without producing any output) except when |
forced to flush. |
The detailed semantics are as follows. deflate performs one or both of the |
following actions: |
- Compress more input starting at next_in and update next_in and avail_in |
accordingly. If not all input can be processed (because there is not |
enough room in the output buffer), next_in and avail_in are updated and |
processing will resume at this point for the next call of deflate(). |
- Provide more output starting at next_out and update next_out and avail_out |
accordingly. This action is forced if the parameter flush is non zero. |
Forcing flush frequently degrades the compression ratio, so this parameter |
should be set only when necessary (in interactive applications). Some |
output may be provided even if flush is not set. |
Before the call of deflate(), the application should ensure that at least |
one of the actions is possible, by providing more input and/or consuming more |
output, and updating avail_in or avail_out accordingly; avail_out should |
never be zero before the call. The application can consume the compressed |
output when it wants, for example when the output buffer is full (avail_out |
== 0), or after each call of deflate(). If deflate returns Z_OK and with |
zero avail_out, it must be called again after making room in the output |
buffer because there might be more output pending. |
Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to |
decide how much data to accumulate before producing output, in order to |
maximize compression. |
If the parameter flush is set to Z_SYNC_FLUSH, all pending output is |
flushed to the output buffer and the output is aligned on a byte boundary, so |
that the decompressor can get all input data available so far. (In |
particular avail_in is zero after the call if enough output space has been |
provided before the call.) Flushing may degrade compression for some |
compression algorithms and so it should be used only when necessary. This |
completes the current deflate block and follows it with an empty stored block |
that is three bits plus filler bits to the next byte, followed by four bytes |
(00 00 ff ff). |
If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the |
output buffer, but the output is not aligned to a byte boundary. All of the |
input data so far will be available to the decompressor, as for Z_SYNC_FLUSH. |
This completes the current deflate block and follows it with an empty fixed |
codes block that is 10 bits long. This assures that enough bytes are output |
in order for the decompressor to finish the block before the empty fixed code |
block. |
If flush is set to Z_BLOCK, a deflate block is completed and emitted, as |
for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to |
seven bits of the current block are held to be written as the next byte after |
the next deflate block is completed. In this case, the decompressor may not |
be provided enough bits at this point in order to complete decompression of |
the data provided so far to the compressor. It may need to wait for the next |
block to be emitted. This is for advanced applications that need to control |
the emission of deflate blocks. |
If flush is set to Z_FULL_FLUSH, all output is flushed as with |
Z_SYNC_FLUSH, and the compression state is reset so that decompression can |
restart from this point if previous compressed data has been damaged or if |
random access is desired. Using Z_FULL_FLUSH too often can seriously degrade |
compression. |
If deflate returns with avail_out == 0, this function must be called again |
with the same value of the flush parameter and more output space (updated |
avail_out), until the flush is complete (deflate returns with non-zero |
avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that |
avail_out is greater than six to avoid repeated flush markers due to |
avail_out == 0 on return. |
If the parameter flush is set to Z_FINISH, pending input is processed, |
pending output is flushed and deflate returns with Z_STREAM_END if there was |
enough output space; if deflate returns with Z_OK, this function must be |
called again with Z_FINISH and more output space (updated avail_out) but no |
more input data, until it returns with Z_STREAM_END or an error. After |
deflate has returned Z_STREAM_END, the only possible operations on the stream |
are deflateReset or deflateEnd. |
Z_FINISH can be used immediately after deflateInit if all the compression |
is to be done in a single step. In this case, avail_out must be at least the |
value returned by deflateBound (see below). Then deflate is guaranteed to |
return Z_STREAM_END. If not enough output space is provided, deflate will |
not return Z_STREAM_END, and it must be called again as described above. |
deflate() sets strm->adler to the adler32 checksum of all input read |
so far (that is, total_in bytes). |
deflate() may update strm->data_type if it can make a good guess about |
the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered |
binary. This field is only for information purposes and does not affect the |
compression algorithm in any manner. |
deflate() returns Z_OK if some progress has been made (more input |
processed or more output produced), Z_STREAM_END if all input has been |
consumed and all output has been produced (only when flush is set to |
Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example |
if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible |
(for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not |
fatal, and deflate() can be called again with more input and more output |
space to continue compressing. |
*/ |
ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); |
/* |
All dynamically allocated data structures for this stream are freed. |
This function discards any unprocessed input and does not flush any pending |
output. |
deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the |
stream state was inconsistent, Z_DATA_ERROR if the stream was freed |
prematurely (some input or output was discarded). In the error case, msg |
may be set but then points to a static string (which must not be |
deallocated). |
*/ |
/* |
ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); |
Initializes the internal stream state for decompression. The fields |
next_in, avail_in, zalloc, zfree and opaque must be initialized before by |
the caller. If next_in is not Z_NULL and avail_in is large enough (the |
exact value depends on the compression method), inflateInit determines the |
compression method from the zlib header and allocates all data structures |
accordingly; otherwise the allocation will be deferred to the first call of |
inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to |
use default allocation functions. |
inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough |
memory, Z_VERSION_ERROR if the zlib library version is incompatible with the |
version assumed by the caller, or Z_STREAM_ERROR if the parameters are |
invalid, such as a null pointer to the structure. msg is set to null if |
there is no error message. inflateInit does not perform any decompression |
apart from possibly reading the zlib header if present: actual decompression |
will be done by inflate(). (So next_in and avail_in may be modified, but |
next_out and avail_out are unused and unchanged.) The current implementation |
of inflateInit() does not process any header information -- that is deferred |
until inflate() is called. |
*/ |
ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); |
/* |
inflate decompresses as much data as possible, and stops when the input |
buffer becomes empty or the output buffer becomes full. It may introduce |
some output latency (reading input without producing any output) except when |
forced to flush. |
The detailed semantics are as follows. inflate performs one or both of the |
following actions: |
- Decompress more input starting at next_in and update next_in and avail_in |
accordingly. If not all input can be processed (because there is not |
enough room in the output buffer), next_in is updated and processing will |
resume at this point for the next call of inflate(). |
- Provide more output starting at next_out and update next_out and avail_out |
accordingly. inflate() provides as much output as possible, until there is |
no more input data or no more space in the output buffer (see below about |
the flush parameter). |
Before the call of inflate(), the application should ensure that at least |
one of the actions is possible, by providing more input and/or consuming more |
output, and updating the next_* and avail_* values accordingly. The |
application can consume the uncompressed output when it wants, for example |
when the output buffer is full (avail_out == 0), or after each call of |
inflate(). If inflate returns Z_OK and with zero avail_out, it must be |
called again after making room in the output buffer because there might be |
more output pending. |
The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH, |
Z_BLOCK, or Z_TREES. Z_SYNC_FLUSH requests that inflate() flush as much |
output as possible to the output buffer. Z_BLOCK requests that inflate() |
stop if and when it gets to the next deflate block boundary. When decoding |
the zlib or gzip format, this will cause inflate() to return immediately |
after the header and before the first block. When doing a raw inflate, |
inflate() will go ahead and process the first block, and will return when it |
gets to the end of that block, or when it runs out of data. |
The Z_BLOCK option assists in appending to or combining deflate streams. |
Also to assist in this, on return inflate() will set strm->data_type to the |
number of unused bits in the last byte taken from strm->next_in, plus 64 if |
inflate() is currently decoding the last block in the deflate stream, plus |
128 if inflate() returned immediately after decoding an end-of-block code or |
decoding the complete header up to just before the first byte of the deflate |
stream. The end-of-block will not be indicated until all of the uncompressed |
data from that block has been written to strm->next_out. The number of |
unused bits may in general be greater than seven, except when bit 7 of |
data_type is set, in which case the number of unused bits will be less than |
eight. data_type is set as noted here every time inflate() returns for all |
flush options, and so can be used to determine the amount of currently |
consumed input in bits. |
The Z_TREES option behaves as Z_BLOCK does, but it also returns when the |
end of each deflate block header is reached, before any actual data in that |
block is decoded. This allows the caller to determine the length of the |
deflate block header for later use in random access within a deflate block. |
256 is added to the value of strm->data_type when inflate() returns |
immediately after reaching the end of the deflate block header. |
inflate() should normally be called until it returns Z_STREAM_END or an |
error. However if all decompression is to be performed in a single step (a |
single call of inflate), the parameter flush should be set to Z_FINISH. In |
this case all pending input is processed and all pending output is flushed; |
avail_out must be large enough to hold all of the uncompressed data for the |
operation to complete. (The size of the uncompressed data may have been |
saved by the compressor for this purpose.) The use of Z_FINISH is not |
required to perform an inflation in one step. However it may be used to |
inform inflate that a faster approach can be used for the single inflate() |
call. Z_FINISH also informs inflate to not maintain a sliding window if the |
stream completes, which reduces inflate's memory footprint. If the stream |
does not complete, either because not all of the stream is provided or not |
enough output space is provided, then a sliding window will be allocated and |
inflate() can be called again to continue the operation as if Z_NO_FLUSH had |
been used. |
In this implementation, inflate() always flushes as much output as |
possible to the output buffer, and always uses the faster approach on the |
first call. So the effects of the flush parameter in this implementation are |
on the return value of inflate() as noted below, when inflate() returns early |
when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of |
memory for a sliding window when Z_FINISH is used. |
If a preset dictionary is needed after this call (see inflateSetDictionary |
below), inflate sets strm->adler to the Adler-32 checksum of the dictionary |
chosen by the compressor and returns Z_NEED_DICT; otherwise it sets |
strm->adler to the Adler-32 checksum of all output produced so far (that is, |
total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described |
below. At the end of the stream, inflate() checks that its computed adler32 |
checksum is equal to that saved by the compressor and returns Z_STREAM_END |
only if the checksum is correct. |
inflate() can decompress and check either zlib-wrapped or gzip-wrapped |
deflate data. The header type is detected automatically, if requested when |
initializing with inflateInit2(). Any information contained in the gzip |
header is not retained, so applications that need that information should |
instead use raw inflate, see inflateInit2() below, or inflateBack() and |
perform their own processing of the gzip header and trailer. When processing |
gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output |
producted so far. The CRC-32 is checked against the gzip trailer. |
inflate() returns Z_OK if some progress has been made (more input processed |
or more output produced), Z_STREAM_END if the end of the compressed data has |
been reached and all uncompressed output has been produced, Z_NEED_DICT if a |
preset dictionary is needed at this point, Z_DATA_ERROR if the input data was |
corrupted (input stream not conforming to the zlib format or incorrect check |
value), Z_STREAM_ERROR if the stream structure was inconsistent (for example |
next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory, |
Z_BUF_ERROR if no progress is possible or if there was not enough room in the |
output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and |
inflate() can be called again with more input and more output space to |
continue decompressing. If Z_DATA_ERROR is returned, the application may |
then call inflateSync() to look for a good compression block if a partial |
recovery of the data is desired. |
*/ |
ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); |
/* |
All dynamically allocated data structures for this stream are freed. |
This function discards any unprocessed input and does not flush any pending |
output. |
inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state |
was inconsistent. In the error case, msg may be set but then points to a |
static string (which must not be deallocated). |
*/ |
/* Advanced functions */ |
/* |
The following functions are needed only in some special applications. |
*/ |
/* |
ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, |
int level, |
int method, |
int windowBits, |
int memLevel, |
int strategy)); |
This is another version of deflateInit with more compression options. The |
fields next_in, zalloc, zfree and opaque must be initialized before by the |
caller. |
The method parameter is the compression method. It must be Z_DEFLATED in |
this version of the library. |
The windowBits parameter is the base two logarithm of the window size |
(the size of the history buffer). It should be in the range 8..15 for this |
version of the library. Larger values of this parameter result in better |
compression at the expense of memory usage. The default value is 15 if |
deflateInit is used instead. |
windowBits can also be -8..-15 for raw deflate. In this case, -windowBits |
determines the window size. deflate() will then generate raw deflate data |
with no zlib header or trailer, and will not compute an adler32 check value. |
windowBits can also be greater than 15 for optional gzip encoding. Add |
16 to windowBits to write a simple gzip header and trailer around the |
compressed data instead of a zlib wrapper. The gzip header will have no |
file name, no extra data, no comment, no modification time (set to zero), no |
header crc, and the operating system will be set to 255 (unknown). If a |
gzip stream is being written, strm->adler is a crc32 instead of an adler32. |
The memLevel parameter specifies how much memory should be allocated |
for the internal compression state. memLevel=1 uses minimum memory but is |
slow and reduces compression ratio; memLevel=9 uses maximum memory for |
optimal speed. The default value is 8. See zconf.h for total memory usage |
as a function of windowBits and memLevel. |
The strategy parameter is used to tune the compression algorithm. Use the |
value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a |
filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no |
string match), or Z_RLE to limit match distances to one (run-length |
encoding). Filtered data consists mostly of small values with a somewhat |
random distribution. In this case, the compression algorithm is tuned to |
compress them better. The effect of Z_FILTERED is to force more Huffman |
coding and less string matching; it is somewhat intermediate between |
Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as |
fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data. The |
strategy parameter only affects the compression ratio but not the |
correctness of the compressed output even if it is not set appropriately. |
Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler |
decoder for special applications. |
deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough |
memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid |
method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is |
incompatible with the version assumed by the caller (ZLIB_VERSION). msg is |
set to null if there is no error message. deflateInit2 does not perform any |
compression: this will be done by deflate(). |
*/ |
ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, |
const Bytef *dictionary, |
uInt dictLength)); |
/* |
Initializes the compression dictionary from the given byte sequence |
without producing any compressed output. When using the zlib format, this |
function must be called immediately after deflateInit, deflateInit2 or |
deflateReset, and before any call of deflate. When doing raw deflate, this |
function must be called either before any call of deflate, or immediately |
after the completion of a deflate block, i.e. after all input has been |
consumed and all output has been delivered when using any of the flush |
options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH. The |
compressor and decompressor must use exactly the same dictionary (see |
inflateSetDictionary). |
The dictionary should consist of strings (byte sequences) that are likely |
to be encountered later in the data to be compressed, with the most commonly |
used strings preferably put towards the end of the dictionary. Using a |
dictionary is most useful when the data to be compressed is short and can be |
predicted with good accuracy; the data can then be compressed better than |
with the default empty dictionary. |
Depending on the size of the compression data structures selected by |
deflateInit or deflateInit2, a part of the dictionary may in effect be |
discarded, for example if the dictionary is larger than the window size |
provided in deflateInit or deflateInit2. Thus the strings most likely to be |
useful should be put at the end of the dictionary, not at the front. In |
addition, the current implementation of deflate will use at most the window |
size minus 262 bytes of the provided dictionary. |
Upon return of this function, strm->adler is set to the adler32 value |
of the dictionary; the decompressor may later use this value to determine |
which dictionary has been used by the compressor. (The adler32 value |
applies to the whole dictionary even if only a subset of the dictionary is |
actually used by the compressor.) If a raw deflate was requested, then the |
adler32 value is not computed and strm->adler is not set. |
deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a |
parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is |
inconsistent (for example if deflate has already been called for this stream |
or if not at a block boundary for raw deflate). deflateSetDictionary does |
not perform any compression: this will be done by deflate(). |
*/ |
ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, |
z_streamp source)); |
/* |
Sets the destination stream as a complete copy of the source stream. |
This function can be useful when several compression strategies will be |
tried, for example when there are several ways of pre-processing the input |
data with a filter. The streams that will be discarded should then be freed |
by calling deflateEnd. Note that deflateCopy duplicates the internal |
compression state which can be quite large, so this strategy is slow and can |
consume lots of memory. |
deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not |
enough memory, Z_STREAM_ERROR if the source stream state was inconsistent |
(such as zalloc being Z_NULL). msg is left unchanged in both source and |
destination. |
*/ |
ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); |
/* |
This function is equivalent to deflateEnd followed by deflateInit, |
but does not free and reallocate all the internal compression state. The |
stream will keep the same compression level and any other attributes that |
may have been set by deflateInit2. |
deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source |
stream state was inconsistent (such as zalloc or state being Z_NULL). |
*/ |
ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, |
int level, |
int strategy)); |
/* |
Dynamically update the compression level and compression strategy. The |
interpretation of level and strategy is as in deflateInit2. This can be |
used to switch between compression and straight copy of the input data, or |
to switch to a different kind of input data requiring a different strategy. |
If the compression level is changed, the input available so far is |
compressed with the old level (and may be flushed); the new level will take |
effect only at the next call of deflate(). |
Before the call of deflateParams, the stream state must be set as for |
a call of deflate(), since the currently available input may have to be |
compressed and flushed. In particular, strm->avail_out must be non-zero. |
deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source |
stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if |
strm->avail_out was zero. |
*/ |
ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, |
int good_length, |
int max_lazy, |
int nice_length, |
int max_chain)); |
/* |
Fine tune deflate's internal compression parameters. This should only be |
used by someone who understands the algorithm used by zlib's deflate for |
searching for the best matching string, and even then only by the most |
fanatic optimizer trying to squeeze out the last compressed bit for their |
specific input data. Read the deflate.c source code for the meaning of the |
max_lazy, good_length, nice_length, and max_chain parameters. |
deflateTune() can be called after deflateInit() or deflateInit2(), and |
returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. |
*/ |
ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, |
uLong sourceLen)); |
/* |
deflateBound() returns an upper bound on the compressed size after |
deflation of sourceLen bytes. It must be called after deflateInit() or |
deflateInit2(), and after deflateSetHeader(), if used. This would be used |
to allocate an output buffer for deflation in a single pass, and so would be |
called before deflate(). If that first deflate() call is provided the |
sourceLen input bytes, an output buffer allocated to the size returned by |
deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed |
to return Z_STREAM_END. Note that it is possible for the compressed size to |
be larger than the value returned by deflateBound() if flush options other |
than Z_FINISH or Z_NO_FLUSH are used. |
*/ |
ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, |
unsigned *pending, |
int *bits)); |
/* |
deflatePending() returns the number of bytes and bits of output that have |
been generated, but not yet provided in the available output. The bytes not |
provided would be due to the available output space having being consumed. |
The number of bits of output not provided are between 0 and 7, where they |
await more bits to join them in order to fill out a full byte. If pending |
or bits are Z_NULL, then those values are not set. |
deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source |
stream state was inconsistent. |
*/ |
ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, |
int bits, |
int value)); |
/* |
deflatePrime() inserts bits in the deflate output stream. The intent |
is that this function is used to start off the deflate output with the bits |
leftover from a previous deflate stream when appending to it. As such, this |
function can only be used for raw deflate, and must be used before the first |
deflate() call after a deflateInit2() or deflateReset(). bits must be less |
than or equal to 16, and that many of the least significant bits of value |
will be inserted in the output. |
deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough |
room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the |
source stream state was inconsistent. |
*/ |
ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, |
gz_headerp head)); |
/* |
deflateSetHeader() provides gzip header information for when a gzip |
stream is requested by deflateInit2(). deflateSetHeader() may be called |
after deflateInit2() or deflateReset() and before the first call of |
deflate(). The text, time, os, extra field, name, and comment information |
in the provided gz_header structure are written to the gzip header (xflag is |
ignored -- the extra flags are set according to the compression level). The |
caller must assure that, if not Z_NULL, name and comment are terminated with |
a zero byte, and that if extra is not Z_NULL, that extra_len bytes are |
available there. If hcrc is true, a gzip header crc is included. Note that |
the current versions of the command-line version of gzip (up through version |
1.3.x) do not support header crc's, and will report that it is a "multi-part |
gzip file" and give up. |
If deflateSetHeader is not used, the default gzip header has text false, |
the time set to zero, and os set to 255, with no extra, name, or comment |
fields. The gzip header is returned to the default state by deflateReset(). |
deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source |
stream state was inconsistent. |
*/ |
/* |
ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, |
int windowBits)); |
This is another version of inflateInit with an extra parameter. The |
fields next_in, avail_in, zalloc, zfree and opaque must be initialized |
before by the caller. |
The windowBits parameter is the base two logarithm of the maximum window |
size (the size of the history buffer). It should be in the range 8..15 for |
this version of the library. The default value is 15 if inflateInit is used |
instead. windowBits must be greater than or equal to the windowBits value |
provided to deflateInit2() while compressing, or it must be equal to 15 if |
deflateInit2() was not used. If a compressed stream with a larger window |
size is given as input, inflate() will return with the error code |
Z_DATA_ERROR instead of trying to allocate a larger window. |
windowBits can also be zero to request that inflate use the window size in |
the zlib header of the compressed stream. |
windowBits can also be -8..-15 for raw inflate. In this case, -windowBits |
determines the window size. inflate() will then process raw deflate data, |
not looking for a zlib or gzip header, not generating a check value, and not |
looking for any check values for comparison at the end of the stream. This |
is for use with other formats that use the deflate compressed data format |
such as zip. Those formats provide their own check values. If a custom |
format is developed using the raw deflate format for compressed data, it is |
recommended that a check value such as an adler32 or a crc32 be applied to |
the uncompressed data as is done in the zlib, gzip, and zip formats. For |
most applications, the zlib format should be used as is. Note that comments |
above on the use in deflateInit2() applies to the magnitude of windowBits. |
windowBits can also be greater than 15 for optional gzip decoding. Add |
32 to windowBits to enable zlib and gzip decoding with automatic header |
detection, or add 16 to decode only the gzip format (the zlib format will |
return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a |
crc32 instead of an adler32. |
inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough |
memory, Z_VERSION_ERROR if the zlib library version is incompatible with the |
version assumed by the caller, or Z_STREAM_ERROR if the parameters are |
invalid, such as a null pointer to the structure. msg is set to null if |
there is no error message. inflateInit2 does not perform any decompression |
apart from possibly reading the zlib header if present: actual decompression |
will be done by inflate(). (So next_in and avail_in may be modified, but |
next_out and avail_out are unused and unchanged.) The current implementation |
of inflateInit2() does not process any header information -- that is |
deferred until inflate() is called. |
*/ |
ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, |
const Bytef *dictionary, |
uInt dictLength)); |
/* |
Initializes the decompression dictionary from the given uncompressed byte |
sequence. This function must be called immediately after a call of inflate, |
if that call returned Z_NEED_DICT. The dictionary chosen by the compressor |
can be determined from the adler32 value returned by that call of inflate. |
The compressor and decompressor must use exactly the same dictionary (see |
deflateSetDictionary). For raw inflate, this function can be called at any |
time to set the dictionary. If the provided dictionary is smaller than the |
window and there is already data in the window, then the provided dictionary |
will amend what's there. The application must insure that the dictionary |
that was used for compression is provided. |
inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a |
parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is |
inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the |
expected one (incorrect adler32 value). inflateSetDictionary does not |
perform any decompression: this will be done by subsequent calls of |
inflate(). |
*/ |
ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm, |
Bytef *dictionary, |
uInt *dictLength)); |
/* |
Returns the sliding dictionary being maintained by inflate. dictLength is |
set to the number of bytes in the dictionary, and that many bytes are copied |
to dictionary. dictionary must have enough space, where 32768 bytes is |
always enough. If inflateGetDictionary() is called with dictionary equal to |
Z_NULL, then only the dictionary length is returned, and nothing is copied. |
Similary, if dictLength is Z_NULL, then it is not set. |
inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the |
stream state is inconsistent. |
*/ |
ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); |
/* |
Skips invalid compressed data until a possible full flush point (see above |
for the description of deflate with Z_FULL_FLUSH) can be found, or until all |
available input is skipped. No output is provided. |
inflateSync searches for a 00 00 FF FF pattern in the compressed data. |
All full flush points have this pattern, but not all occurrences of this |
pattern are full flush points. |
inflateSync returns Z_OK if a possible full flush point has been found, |
Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point |
has been found, or Z_STREAM_ERROR if the stream structure was inconsistent. |
In the success case, the application may save the current current value of |
total_in which indicates where valid compressed data was found. In the |
error case, the application may repeatedly call inflateSync, providing more |
input each time, until success or end of the input data. |
*/ |
ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, |
z_streamp source)); |
/* |
Sets the destination stream as a complete copy of the source stream. |
This function can be useful when randomly accessing a large stream. The |
first pass through the stream can periodically record the inflate state, |
allowing restarting inflate at those points when randomly accessing the |
stream. |
inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not |
enough memory, Z_STREAM_ERROR if the source stream state was inconsistent |
(such as zalloc being Z_NULL). msg is left unchanged in both source and |
destination. |
*/ |
ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); |
/* |
This function is equivalent to inflateEnd followed by inflateInit, |
but does not free and reallocate all the internal decompression state. The |
stream will keep attributes that may have been set by inflateInit2. |
inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source |
stream state was inconsistent (such as zalloc or state being Z_NULL). |
*/ |
ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, |
int windowBits)); |
/* |
This function is the same as inflateReset, but it also permits changing |
the wrap and window size requests. The windowBits parameter is interpreted |
the same as it is for inflateInit2. |
inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source |
stream state was inconsistent (such as zalloc or state being Z_NULL), or if |
the windowBits parameter is invalid. |
*/ |
ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, |
int bits, |
int value)); |
/* |
This function inserts bits in the inflate input stream. The intent is |
that this function is used to start inflating at a bit position in the |
middle of a byte. The provided bits will be used before any bytes are used |
from next_in. This function should only be used with raw inflate, and |
should be used before the first inflate() call after inflateInit2() or |
inflateReset(). bits must be less than or equal to 16, and that many of the |
least significant bits of value will be inserted in the input. |
If bits is negative, then the input stream bit buffer is emptied. Then |
inflatePrime() can be called again to put bits in the buffer. This is used |
to clear out bits leftover after feeding inflate a block description prior |
to feeding inflate codes. |
inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source |
stream state was inconsistent. |
*/ |
ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); |
/* |
This function returns two values, one in the lower 16 bits of the return |
value, and the other in the remaining upper bits, obtained by shifting the |
return value down 16 bits. If the upper value is -1 and the lower value is |
zero, then inflate() is currently decoding information outside of a block. |
If the upper value is -1 and the lower value is non-zero, then inflate is in |
the middle of a stored block, with the lower value equaling the number of |
bytes from the input remaining to copy. If the upper value is not -1, then |
it is the number of bits back from the current bit position in the input of |
the code (literal or length/distance pair) currently being processed. In |
that case the lower value is the number of bytes already emitted for that |
code. |
A code is being processed if inflate is waiting for more input to complete |
decoding of the code, or if it has completed decoding but is waiting for |
more output space to write the literal or match data. |
inflateMark() is used to mark locations in the input data for random |
access, which may be at bit positions, and to note those cases where the |
output of a code may span boundaries of random access blocks. The current |
location in the input stream can be determined from avail_in and data_type |
as noted in the description for the Z_BLOCK flush parameter for inflate. |
inflateMark returns the value noted above or -1 << 16 if the provided |
source stream state was inconsistent. |
*/ |
ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, |
gz_headerp head)); |
/* |
inflateGetHeader() requests that gzip header information be stored in the |
provided gz_header structure. inflateGetHeader() may be called after |
inflateInit2() or inflateReset(), and before the first call of inflate(). |
As inflate() processes the gzip stream, head->done is zero until the header |
is completed, at which time head->done is set to one. If a zlib stream is |
being decoded, then head->done is set to -1 to indicate that there will be |
no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be |
used to force inflate() to return immediately after header processing is |
complete and before any actual data is decompressed. |
The text, time, xflags, and os fields are filled in with the gzip header |
contents. hcrc is set to true if there is a header CRC. (The header CRC |
was valid if done is set to one.) If extra is not Z_NULL, then extra_max |
contains the maximum number of bytes to write to extra. Once done is true, |
extra_len contains the actual extra field length, and extra contains the |
extra field, or that field truncated if extra_max is less than extra_len. |
If name is not Z_NULL, then up to name_max characters are written there, |
terminated with a zero unless the length is greater than name_max. If |
comment is not Z_NULL, then up to comm_max characters are written there, |
terminated with a zero unless the length is greater than comm_max. When any |
of extra, name, or comment are not Z_NULL and the respective field is not |
present in the header, then that field is set to Z_NULL to signal its |
absence. This allows the use of deflateSetHeader() with the returned |
structure to duplicate the header. However if those fields are set to |
allocated memory, then the application will need to save those pointers |
elsewhere so that they can be eventually freed. |
If inflateGetHeader is not used, then the header information is simply |
discarded. The header is always checked for validity, including the header |
CRC if present. inflateReset() will reset the process to discard the header |
information. The application would need to call inflateGetHeader() again to |
retrieve the header from the next gzip stream. |
inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source |
stream state was inconsistent. |
*/ |
/* |
ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, |
unsigned char FAR *window)); |
Initialize the internal stream state for decompression using inflateBack() |
calls. The fields zalloc, zfree and opaque in strm must be initialized |
before the call. If zalloc and zfree are Z_NULL, then the default library- |
derived memory allocation routines are used. windowBits is the base two |
logarithm of the window size, in the range 8..15. window is a caller |
supplied buffer of that size. Except for special applications where it is |
assured that deflate was used with small window sizes, windowBits must be 15 |
and a 32K byte window must be supplied to be able to decompress general |
deflate streams. |
See inflateBack() for the usage of these routines. |
inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of |
the parameters are invalid, Z_MEM_ERROR if the internal state could not be |
allocated, or Z_VERSION_ERROR if the version of the library does not match |
the version of the header file. |
*/ |
typedef unsigned (*in_func) OF((void FAR *, |
z_const unsigned char FAR * FAR *)); |
typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); |
ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, |
in_func in, void FAR *in_desc, |
out_func out, void FAR *out_desc)); |
/* |
inflateBack() does a raw inflate with a single call using a call-back |
interface for input and output. This is potentially more efficient than |
inflate() for file i/o applications, in that it avoids copying between the |
output and the sliding window by simply making the window itself the output |
buffer. inflate() can be faster on modern CPUs when used with large |
buffers. inflateBack() trusts the application to not change the output |
buffer passed by the output function, at least until inflateBack() returns. |
inflateBackInit() must be called first to allocate the internal state |
and to initialize the state with the user-provided window buffer. |
inflateBack() may then be used multiple times to inflate a complete, raw |
deflate stream with each call. inflateBackEnd() is then called to free the |
allocated state. |
A raw deflate stream is one with no zlib or gzip header or trailer. |
This routine would normally be used in a utility that reads zip or gzip |
files and writes out uncompressed files. The utility would decode the |
header and process the trailer on its own, hence this routine expects only |
the raw deflate stream to decompress. This is different from the normal |
behavior of inflate(), which expects either a zlib or gzip header and |
trailer around the deflate stream. |
inflateBack() uses two subroutines supplied by the caller that are then |
called by inflateBack() for input and output. inflateBack() calls those |
routines until it reads a complete deflate stream and writes out all of the |
uncompressed data, or until it encounters an error. The function's |
parameters and return types are defined above in the in_func and out_func |
typedefs. inflateBack() will call in(in_desc, &buf) which should return the |
number of bytes of provided input, and a pointer to that input in buf. If |
there is no input available, in() must return zero--buf is ignored in that |
case--and inflateBack() will return a buffer error. inflateBack() will call |
out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() |
should return zero on success, or non-zero on failure. If out() returns |
non-zero, inflateBack() will return with an error. Neither in() nor out() |
are permitted to change the contents of the window provided to |
inflateBackInit(), which is also the buffer that out() uses to write from. |
The length written by out() will be at most the window size. Any non-zero |
amount of input may be provided by in(). |
For convenience, inflateBack() can be provided input on the first call by |
setting strm->next_in and strm->avail_in. If that input is exhausted, then |
in() will be called. Therefore strm->next_in must be initialized before |
calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called |
immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in |
must also be initialized, and then if strm->avail_in is not zero, input will |
initially be taken from strm->next_in[0 .. strm->avail_in - 1]. |
The in_desc and out_desc parameters of inflateBack() is passed as the |
first parameter of in() and out() respectively when they are called. These |
descriptors can be optionally used to pass any information that the caller- |
supplied in() and out() functions need to do their job. |
On return, inflateBack() will set strm->next_in and strm->avail_in to |
pass back any unused input that was provided by the last in() call. The |
return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR |
if in() or out() returned an error, Z_DATA_ERROR if there was a format error |
in the deflate stream (in which case strm->msg is set to indicate the nature |
of the error), or Z_STREAM_ERROR if the stream was not properly initialized. |
In the case of Z_BUF_ERROR, an input or output error can be distinguished |
using strm->next_in which will be Z_NULL only if in() returned an error. If |
strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning |
non-zero. (in() will always be called before out(), so strm->next_in is |
assured to be defined if out() returns non-zero.) Note that inflateBack() |
cannot return Z_OK. |
*/ |
ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); |
/* |
All memory allocated by inflateBackInit() is freed. |
inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream |
state was inconsistent. |
*/ |
ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); |
/* Return flags indicating compile-time options. |
Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: |
1.0: size of uInt |
3.2: size of uLong |
5.4: size of voidpf (pointer) |
7.6: size of z_off_t |
Compiler, assembler, and debug options: |
8: DEBUG |
9: ASMV or ASMINF -- use ASM code |
10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention |
11: 0 (reserved) |
One-time table building (smaller code, but not thread-safe if true): |
12: BUILDFIXED -- build static block decoding tables when needed |
13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed |
14,15: 0 (reserved) |
Library content (indicates missing functionality): |
16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking |
deflate code when not needed) |
17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect |
and decode gzip streams (to avoid linking crc code) |
18-19: 0 (reserved) |
Operation variations (changes in library functionality): |
20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate |
21: FASTEST -- deflate algorithm with only one, lowest compression level |
22,23: 0 (reserved) |
The sprintf variant used by gzprintf (zero is best): |
24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format |
25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! |
26: 0 = returns value, 1 = void -- 1 means inferred string length returned |
Remainder: |
27-31: 0 (reserved) |
*/ |
#ifndef Z_SOLO |
/* utility functions */ |
/* |
The following utility functions are implemented on top of the basic |
stream-oriented functions. To simplify the interface, some default options |
are assumed (compression level and memory usage, standard memory allocation |
functions). The source code of these utility functions can be modified if |
you need special options. |
*/ |
ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, |
const Bytef *source, uLong sourceLen)); |
/* |
Compresses the source buffer into the destination buffer. sourceLen is |
the byte length of the source buffer. Upon entry, destLen is the total size |
of the destination buffer, which must be at least the value returned by |
compressBound(sourceLen). Upon exit, destLen is the actual size of the |
compressed buffer. |
compress returns Z_OK if success, Z_MEM_ERROR if there was not |
enough memory, Z_BUF_ERROR if there was not enough room in the output |
buffer. |
*/ |
ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, |
const Bytef *source, uLong sourceLen, |
int level)); |
/* |
Compresses the source buffer into the destination buffer. The level |
parameter has the same meaning as in deflateInit. sourceLen is the byte |
length of the source buffer. Upon entry, destLen is the total size of the |
destination buffer, which must be at least the value returned by |
compressBound(sourceLen). Upon exit, destLen is the actual size of the |
compressed buffer. |
compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough |
memory, Z_BUF_ERROR if there was not enough room in the output buffer, |
Z_STREAM_ERROR if the level parameter is invalid. |
*/ |
ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); |
/* |
compressBound() returns an upper bound on the compressed size after |
compress() or compress2() on sourceLen bytes. It would be used before a |
compress() or compress2() call to allocate the destination buffer. |
*/ |
ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, |
const Bytef *source, uLong sourceLen)); |
/* |
Decompresses the source buffer into the destination buffer. sourceLen is |
the byte length of the source buffer. Upon entry, destLen is the total size |
of the destination buffer, which must be large enough to hold the entire |
uncompressed data. (The size of the uncompressed data must have been saved |
previously by the compressor and transmitted to the decompressor by some |
mechanism outside the scope of this compression library.) Upon exit, destLen |
is the actual size of the uncompressed buffer. |
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not |
enough memory, Z_BUF_ERROR if there was not enough room in the output |
buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. In |
the case where there is not enough room, uncompress() will fill the output |
buffer with the uncompressed data up to that point. |
*/ |
/* gzip file access functions */ |
/* |
This library supports reading and writing files in gzip (.gz) format with |
an interface similar to that of stdio, using the functions that start with |
"gz". The gzip format is different from the zlib format. gzip is a gzip |
wrapper, documented in RFC 1952, wrapped around a deflate stream. |
*/ |
typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ |
/* |
ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); |
Opens a gzip (.gz) file for reading or writing. The mode parameter is as |
in fopen ("rb" or "wb") but can also include a compression level ("wb9") or |
a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only |
compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F' |
for fixed code compression as in "wb9F". (See the description of |
deflateInit2 for more information about the strategy parameter.) 'T' will |
request transparent writing or appending with no compression and not using |
the gzip format. |
"a" can be used instead of "w" to request that the gzip stream that will |
be written be appended to the file. "+" will result in an error, since |
reading and writing to the same gzip file is not supported. The addition of |
"x" when writing will create the file exclusively, which fails if the file |
already exists. On systems that support it, the addition of "e" when |
reading or writing will set the flag to close the file on an execve() call. |
These functions, as well as gzip, will read and decode a sequence of gzip |
streams in a file. The append function of gzopen() can be used to create |
such a file. (Also see gzflush() for another way to do this.) When |
appending, gzopen does not test whether the file begins with a gzip stream, |
nor does it look for the end of the gzip streams to begin appending. gzopen |
will simply append a gzip stream to the existing file. |
gzopen can be used to read a file which is not in gzip format; in this |
case gzread will directly read from the file without decompression. When |
reading, this will be detected automatically by looking for the magic two- |
byte gzip header. |
gzopen returns NULL if the file could not be opened, if there was |
insufficient memory to allocate the gzFile state, or if an invalid mode was |
specified (an 'r', 'w', or 'a' was not provided, or '+' was provided). |
errno can be checked to determine if the reason gzopen failed was that the |
file could not be opened. |
*/ |
ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); |
/* |
gzdopen associates a gzFile with the file descriptor fd. File descriptors |
are obtained from calls like open, dup, creat, pipe or fileno (if the file |
has been previously opened with fopen). The mode parameter is as in gzopen. |
The next call of gzclose on the returned gzFile will also close the file |
descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor |
fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd, |
mode);. The duplicated descriptor should be saved to avoid a leak, since |
gzdopen does not close fd if it fails. If you are using fileno() to get the |
file descriptor from a FILE *, then you will have to use dup() to avoid |
double-close()ing the file descriptor. Both gzclose() and fclose() will |
close the associated file descriptor, so they need to have different file |
descriptors. |
gzdopen returns NULL if there was insufficient memory to allocate the |
gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not |
provided, or '+' was provided), or if fd is -1. The file descriptor is not |
used until the next gz* read, write, seek, or close operation, so gzdopen |
will not detect if fd is invalid (unless fd is -1). |
*/ |
ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); |
/* |
Set the internal buffer size used by this library's functions. The |
default buffer size is 8192 bytes. This function must be called after |
gzopen() or gzdopen(), and before any other calls that read or write the |
file. The buffer memory allocation is always deferred to the first read or |
write. Two buffers are allocated, either both of the specified size when |
writing, or one of the specified size and the other twice that size when |
reading. A larger buffer size of, for example, 64K or 128K bytes will |
noticeably increase the speed of decompression (reading). |
The new buffer size also affects the maximum length for gzprintf(). |
gzbuffer() returns 0 on success, or -1 on failure, such as being called |
too late. |
*/ |
ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); |
/* |
Dynamically update the compression level or strategy. See the description |
of deflateInit2 for the meaning of these parameters. |
gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not |
opened for writing. |
*/ |
ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); |
/* |
Reads the given number of uncompressed bytes from the compressed file. If |
the input file is not in gzip format, gzread copies the given number of |
bytes into the buffer directly from the file. |
After reaching the end of a gzip stream in the input, gzread will continue |
to read, looking for another gzip stream. Any number of gzip streams may be |
concatenated in the input file, and will all be decompressed by gzread(). |
If something other than a gzip stream is encountered after a gzip stream, |
that remaining trailing garbage is ignored (and no error is returned). |
gzread can be used to read a gzip file that is being concurrently written. |
Upon reaching the end of the input, gzread will return with the available |
data. If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then |
gzclearerr can be used to clear the end of file indicator in order to permit |
gzread to be tried again. Z_OK indicates that a gzip stream was completed |
on the last gzread. Z_BUF_ERROR indicates that the input file ended in the |
middle of a gzip stream. Note that gzread does not return -1 in the event |
of an incomplete gzip stream. This error is deferred until gzclose(), which |
will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip |
stream. Alternatively, gzerror can be used before gzclose to detect this |
case. |
gzread returns the number of uncompressed bytes actually read, less than |
len for end of file, or -1 for error. |
*/ |
ZEXTERN int ZEXPORT gzwrite OF((gzFile file, |
voidpc buf, unsigned len)); |
/* |
Writes the given number of uncompressed bytes into the compressed file. |
gzwrite returns the number of uncompressed bytes written or 0 in case of |
error. |
*/ |
ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); |
/* |
Converts, formats, and writes the arguments to the compressed file under |
control of the format string, as in fprintf. gzprintf returns the number of |
uncompressed bytes actually written, or 0 in case of error. The number of |
uncompressed bytes written is limited to 8191, or one less than the buffer |
size given to gzbuffer(). The caller should assure that this limit is not |
exceeded. If it is exceeded, then gzprintf() will return an error (0) with |
nothing written. In this case, there may also be a buffer overflow with |
unpredictable consequences, which is possible only if zlib was compiled with |
the insecure functions sprintf() or vsprintf() because the secure snprintf() |
or vsnprintf() functions were not available. This can be determined using |
zlibCompileFlags(). |
*/ |
ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); |
/* |
Writes the given null-terminated string to the compressed file, excluding |
the terminating null character. |
gzputs returns the number of characters written, or -1 in case of error. |
*/ |
ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); |
/* |
Reads bytes from the compressed file until len-1 characters are read, or a |
newline character is read and transferred to buf, or an end-of-file |
condition is encountered. If any characters are read or if len == 1, the |
string is terminated with a null character. If no characters are read due |
to an end-of-file or len < 1, then the buffer is left untouched. |
gzgets returns buf which is a null-terminated string, or it returns NULL |
for end-of-file or in case of error. If there was an error, the contents at |
buf are indeterminate. |
*/ |
ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); |
/* |
Writes c, converted to an unsigned char, into the compressed file. gzputc |
returns the value that was written, or -1 in case of error. |
*/ |
ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); |
/* |
Reads one byte from the compressed file. gzgetc returns this byte or -1 |
in case of end of file or error. This is implemented as a macro for speed. |
As such, it does not do all of the checking the other functions do. I.e. |
it does not check to see if file is NULL, nor whether the structure file |
points to has been clobbered or not. |
*/ |
ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); |
/* |
Push one character back onto the stream to be read as the first character |
on the next read. At least one character of push-back is allowed. |
gzungetc() returns the character pushed, or -1 on failure. gzungetc() will |
fail if c is -1, and may fail if a character has been pushed but not read |
yet. If gzungetc is used immediately after gzopen or gzdopen, at least the |
output buffer size of pushed characters is allowed. (See gzbuffer above.) |
The pushed character will be discarded if the stream is repositioned with |
gzseek() or gzrewind(). |
*/ |
ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); |
/* |
Flushes all pending output into the compressed file. The parameter flush |
is as in the deflate() function. The return value is the zlib error number |
(see function gzerror below). gzflush is only permitted when writing. |
If the flush parameter is Z_FINISH, the remaining data is written and the |
gzip stream is completed in the output. If gzwrite() is called again, a new |
gzip stream will be started in the output. gzread() is able to read such |
concatented gzip streams. |
gzflush should be called only when strictly necessary because it will |
degrade compression if called too often. |
*/ |
/* |
ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, |
z_off_t offset, int whence)); |
Sets the starting position for the next gzread or gzwrite on the given |
compressed file. The offset represents a number of bytes in the |
uncompressed data stream. The whence parameter is defined as in lseek(2); |
the value SEEK_END is not supported. |
If the file is opened for reading, this function is emulated but can be |
extremely slow. If the file is opened for writing, only forward seeks are |
supported; gzseek then compresses a sequence of zeroes up to the new |
starting position. |
gzseek returns the resulting offset location as measured in bytes from |
the beginning of the uncompressed stream, or -1 in case of error, in |
particular if the file is opened for writing and the new starting position |
would be before the current position. |
*/ |
ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); |
/* |
Rewinds the given file. This function is supported only for reading. |
gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) |
*/ |
/* |
ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); |
Returns the starting position for the next gzread or gzwrite on the given |
compressed file. This position represents a number of bytes in the |
uncompressed data stream, and is zero when starting, even if appending or |
reading a gzip stream from the middle of a file using gzdopen(). |
gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) |
*/ |
/* |
ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); |
Returns the current offset in the file being read or written. This offset |
includes the count of bytes that precede the gzip stream, for example when |
appending or when using gzdopen() for reading. When reading, the offset |
does not include as yet unused buffered input. This information can be used |
for a progress indicator. On error, gzoffset() returns -1. |
*/ |
ZEXTERN int ZEXPORT gzeof OF((gzFile file)); |
/* |
Returns true (1) if the end-of-file indicator has been set while reading, |
false (0) otherwise. Note that the end-of-file indicator is set only if the |
read tried to go past the end of the input, but came up short. Therefore, |
just like feof(), gzeof() may return false even if there is no more data to |
read, in the event that the last read request was for the exact number of |
bytes remaining in the input file. This will happen if the input file size |
is an exact multiple of the buffer size. |
If gzeof() returns true, then the read functions will return no more data, |
unless the end-of-file indicator is reset by gzclearerr() and the input file |
has grown since the previous end of file was detected. |
*/ |
ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); |
/* |
Returns true (1) if file is being copied directly while reading, or false |
(0) if file is a gzip stream being decompressed. |
If the input file is empty, gzdirect() will return true, since the input |
does not contain a gzip stream. |
If gzdirect() is used immediately after gzopen() or gzdopen() it will |
cause buffers to be allocated to allow reading the file to determine if it |
is a gzip file. Therefore if gzbuffer() is used, it should be called before |
gzdirect(). |
When writing, gzdirect() returns true (1) if transparent writing was |
requested ("wT" for the gzopen() mode), or false (0) otherwise. (Note: |
gzdirect() is not needed when writing. Transparent writing must be |
explicitly requested, so the application already knows the answer. When |
linking statically, using gzdirect() will include all of the zlib code for |
gzip file reading and decompression, which may not be desired.) |
*/ |
ZEXTERN int ZEXPORT gzclose OF((gzFile file)); |
/* |
Flushes all pending output if necessary, closes the compressed file and |
deallocates the (de)compression state. Note that once file is closed, you |
cannot call gzerror with file, since its structures have been deallocated. |
gzclose must not be called more than once on the same file, just as free |
must not be called more than once on the same allocation. |
gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a |
file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the |
last read ended in the middle of a gzip stream, or Z_OK on success. |
*/ |
ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); |
ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); |
/* |
Same as gzclose(), but gzclose_r() is only for use when reading, and |
gzclose_w() is only for use when writing or appending. The advantage to |
using these instead of gzclose() is that they avoid linking in zlib |
compression or decompression code that is not used when only reading or only |
writing respectively. If gzclose() is used, then both compression and |
decompression code will be included the application when linking to a static |
zlib library. |
*/ |
ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); |
/* |
Returns the error message for the last error which occurred on the given |
compressed file. errnum is set to zlib error number. If an error occurred |
in the file system and not in the compression library, errnum is set to |
Z_ERRNO and the application may consult errno to get the exact error code. |
The application must not modify the returned string. Future calls to |
this function may invalidate the previously returned string. If file is |
closed, then the string previously returned by gzerror will no longer be |
available. |
gzerror() should be used to distinguish errors from end-of-file for those |
functions above that do not distinguish those cases in their return values. |
*/ |
ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); |
/* |
Clears the error and end-of-file flags for file. This is analogous to the |
clearerr() function in stdio. This is useful for continuing to read a gzip |
file that is being written concurrently. |
*/ |
#endif /* !Z_SOLO */ |
/* checksum functions */ |
/* |
These functions are not related to compression but are exported |
anyway because they might be useful in applications using the compression |
library. |
*/ |
ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); |
/* |
Update a running Adler-32 checksum with the bytes buf[0..len-1] and |
return the updated checksum. If buf is Z_NULL, this function returns the |
required initial value for the checksum. |
An Adler-32 checksum is almost as reliable as a CRC32 but can be computed |
much faster. |
Usage example: |
uLong adler = adler32(0L, Z_NULL, 0); |
while (read_buffer(buffer, length) != EOF) { |
adler = adler32(adler, buffer, length); |
} |
if (adler != original_adler) error(); |
*/ |
/* |
ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, |
z_off_t len2)); |
Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 |
and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for |
each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of |
seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note |
that the z_off_t type (like off_t) is a signed integer. If len2 is |
negative, the result has no meaning or utility. |
*/ |
ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); |
/* |
Update a running CRC-32 with the bytes buf[0..len-1] and return the |
updated CRC-32. If buf is Z_NULL, this function returns the required |
initial value for the crc. Pre- and post-conditioning (one's complement) is |
performed within this function so it shouldn't be done by the application. |
Usage example: |
uLong crc = crc32(0L, Z_NULL, 0); |
while (read_buffer(buffer, length) != EOF) { |
crc = crc32(crc, buffer, length); |
} |
if (crc != original_crc) error(); |
*/ |
/* |
ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); |
Combine two CRC-32 check values into one. For two sequences of bytes, |
seq1 and seq2 with lengths len1 and len2, CRC-32 check values were |
calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 |
check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and |
len2. |
*/ |
/* various hacks, don't look :) */ |
/* deflateInit and inflateInit are macros to allow checking the zlib version |
* and the compiler's view of z_stream: |
*/ |
ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, |
const char *version, int stream_size)); |
ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, |
const char *version, int stream_size)); |
ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, |
int windowBits, int memLevel, |
int strategy, const char *version, |
int stream_size)); |
ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, |
const char *version, int stream_size)); |
ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, |
unsigned char FAR *window, |
const char *version, |
int stream_size)); |
#define deflateInit(strm, level) \ |
deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) |
#define inflateInit(strm) \ |
inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) |
#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ |
deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ |
(strategy), ZLIB_VERSION, (int)sizeof(z_stream)) |
#define inflateInit2(strm, windowBits) \ |
inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ |
(int)sizeof(z_stream)) |
#define inflateBackInit(strm, windowBits, window) \ |
inflateBackInit_((strm), (windowBits), (window), \ |
ZLIB_VERSION, (int)sizeof(z_stream)) |
#ifndef Z_SOLO |
/* gzgetc() macro and its supporting function and exposed data structure. Note |
* that the real internal state is much larger than the exposed structure. |
* This abbreviated structure exposes just enough for the gzgetc() macro. The |
* user should not mess with these exposed elements, since their names or |
* behavior could change in the future, perhaps even capriciously. They can |
* only be used by the gzgetc() macro. You have been warned. |
*/ |
struct gzFile_s { |
unsigned have; |
unsigned char *next; |
z_off64_t pos; |
}; |
ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ |
#ifdef Z_PREFIX_SET |
# undef z_gzgetc |
# define z_gzgetc(g) \ |
((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g)) |
#else |
# define gzgetc(g) \ |
((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g)) |
#endif |
/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or |
* change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if |
* both are true, the application gets the *64 functions, and the regular |
* functions are changed to 64 bits) -- in case these are set on systems |
* without large file support, _LFS64_LARGEFILE must also be true |
*/ |
#ifdef Z_LARGE64 |
ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); |
ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); |
ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); |
ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); |
ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); |
ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); |
#endif |
#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) |
# ifdef Z_PREFIX_SET |
# define z_gzopen z_gzopen64 |
# define z_gzseek z_gzseek64 |
# define z_gztell z_gztell64 |
# define z_gzoffset z_gzoffset64 |
# define z_adler32_combine z_adler32_combine64 |
# define z_crc32_combine z_crc32_combine64 |
# else |
# define gzopen gzopen64 |
# define gzseek gzseek64 |
# define gztell gztell64 |
# define gzoffset gzoffset64 |
# define adler32_combine adler32_combine64 |
# define crc32_combine crc32_combine64 |
# endif |
# ifndef Z_LARGE64 |
ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); |
ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); |
ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); |
ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); |
ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); |
ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); |
# endif |
#else |
ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); |
ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); |
ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); |
ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); |
ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); |
ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); |
#endif |
#else /* Z_SOLO */ |
ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); |
ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); |
#endif /* !Z_SOLO */ |
/* hack for buggy compilers */ |
#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) |
struct internal_state {int dummy;}; |
#endif |
/* undocumented functions */ |
ZEXTERN const char * ZEXPORT zError OF((int)); |
ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); |
ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void)); |
ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); |
ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); |
ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); |
#if defined(_WIN32) && !defined(Z_SOLO) |
ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path, |
const char *mode)); |
#endif |
#if defined(STDC) || defined(Z_HAVE_STDARG_H) |
# ifndef Z_SOLO |
ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file, |
const char *format, |
va_list va)); |
# endif |
#endif |
#ifdef __cplusplus |
} |
#endif |
#endif /* ZLIB_H */ |
/pkginst/zlib/zlib_l.lib |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |