components/archiver/bzip2/files/oldapi.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  *  Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.
  23  */
  24
  25 #include <stdio.h>
  26 #include "bzlib.h"
  27
  28 /*
  29  * Wrappers for the old names. For compatibility with Solaris 8.
  30  */
  31
  32 int
  33 bzCompressInit(bz_stream *strm, int blockSize100k, int verbosity,
  34     int workFactor)
  35 {
  36         return (BZ2_bzCompressInit(strm, blockSize100k, verbosity, workFactor));
  37 }
  38
  39 int
  40 bzCompress(bz_stream *strm, int action)
  41 {
  42         return (BZ2_bzCompress(strm, action));
  43 }
  44
  45 int
  46 bzCompressEnd(bz_stream *strm)
  47 {
  48         return (BZ2_bzCompressEnd(strm));
  49 }
  50
  51 int
  52 bzDecompressInit(bz_stream *strm, int verbosity, int small)
  53 {
  54         return (BZ2_bzDecompressInit(strm, verbosity, small));
  55 }
  56
  57 int
  58 bzDecompress(bz_stream *strm)
  59 {
  60         return (BZ2_bzDecompress(strm));
  61 }
  62
  63 int
  64 bzDecompressEnd(bz_stream *strm)
  65 {
  66         return (BZ2_bzDecompressEnd(strm));
  67 }
  68
  69 BZFILE *
  70 bzReadOpen(int *bzerror, FILE *f, int verbosity, int small, void *unused,
  71     int nUnused)
  72 {
  73         return (BZ2_bzReadOpen(bzerror, f, verbosity, small, unused, nUnused));
  74 }
  75
  76 void
  77 bzReadClose(int *bzerror, BZFILE *b)
  78 {
  79         BZ2_bzReadClose(bzerror, b);
  80 }
  81
  82 void
  83 bzReadGetUnused(int *bzerror, BZFILE *b, void **unused, int *nUnused)
  84 {
  85         BZ2_bzReadGetUnused(bzerror, b, unused, nUnused);
  86 }
  87
  88 int
  89 bzRead(int *bzerror, BZFILE *b, void *buf, int len)
  90 {
  91         return (BZ2_bzRead(bzerror, b, buf, len));
  92 }
  93
  94 BZFILE *
  95 bzWriteOpen(int *bzerror, FILE *f, int blockSize100k, int verbosity,
  96     int workFactor)
  97 {
  98         return (BZ2_bzWriteOpen(bzerror, f, blockSize100k, verbosity,
  99             workFactor));
 100 }
 101
 102 void
 103 bzWrite(int *bzerror, BZFILE *b, void *buf, int len)
 104 {
 105         BZ2_bzWrite(bzerror, b, buf, len);
 106 }
 107
 108 void
 109 bzWriteClose(int *bzerror, BZFILE *b, int abandon, unsigned int *nbytes_in,
 110     unsigned int *nbytes_out)
 111 {
 112         BZ2_bzWriteClose(bzerror, b, abandon, nbytes_in, nbytes_out);
 113 }
 114
 115 int
 116 bzBuffToBuffCompress(char *dest, unsigned int *destLen, char *source,
 117     unsigned int sourceLen, int blockSize100k, int verbosity, int workFactor)
 118 {
 119         return (BZ2_bzBuffToBuffCompress(dest, destLen, source, sourceLen,
 120             blockSize100k, verbosity, workFactor));
 121 }
 122
 123 int
 124 bzBuffToBuffDecompress(char *dest, unsigned int *destLen, char *source,
 125     unsigned int sourceLen, int small, int verbosity)
 126 {
 127         return (BZ2_bzBuffToBuffDecompress(dest, destLen, source, sourceLen,
 128             small, verbosity));
 129 }
 130
 131
 132 const char *
 133 bzlibVersion(void)
 134 {
 135         return (BZ2_bzlibVersion());
 136 }
 137
 138 BZFILE *
 139 bzopen(const char *path, const char *mode)
 140 {
 141         return (BZ2_bzopen(path, mode));
 142 }
 143
 144 BZFILE *
 145 bzdopen(int fd, const char *mode)
 146 {
 147         return (BZ2_bzdopen(fd, mode));
 148 }
 149
 150 int
 151 bzread(BZFILE *b, void *buf, int len)
 152 {
 153         return (BZ2_bzread(b, buf, len));
 154 }
 155
 156 int
 157 bzwrite(BZFILE *b, void *buf, int len)
 158 {
 159         return (BZ2_bzwrite(b, buf, len));
 160 }
 161
 162 int
 163 bzflush(BZFILE *b)
 164 {
 165         return (BZ2_bzflush(b));
 166 }
 167
 168 void
 169 bzclose(BZFILE *b)
 170 {
 171         BZ2_bzclose(b);
 172 }
 173
 174 const char *
 175 bzerror(BZFILE *b, int *errnum)
 176 {
 177         return (BZ2_bzerror(b, errnum));
 178 }